v_0.1.0

add options in emittor
setState functions

Author: programming-with-ia

README.md

@@ -78,18 +78,12 @@ function Page() {
 
 This adjusted code snippet provides a simple and easy-to-understand usage example of the `emittor` package. It demonstrates using the `useEmittor` hook to manage state, similar to how `useState` is used in React.
 
+</br>
+
 > **Warning** </br>
 > Always create an emittor in a separate file</br>
 > Because in development mode, the whole file will be rendered again. That can cause unexpected bugs.
 
-.
-
-> **Note** </br>
-> create emittor anywhere in your project like [`createContext`](https://react.dev/reference/react/createContext) in React. </br>
-> and import `Emittor` where use or link (in components and other places)
-
-</br>
-
 ## Emittor In Multiple Components
 
 The emittor package enables automatic state synchronization across React components. By simply integrating emittor, any component subscribing to state changes will update whenever the state changes anywhere in the application. This eliminates the need for manual state passing or provider wrapping, streamlining development and enhancing component responsiveness.
@@ -242,6 +236,30 @@ export default function Page() {
 }
 ```
 
+</br>
+
+---
+
+---
+
+</br>
+
+# API Reference
+
+| Method          | Description                                                                                     |
+|-----------------|-------------------------------------------------------------------------------------------------|
+| `constructor(initialState: T, options: { match?: boolean })` | Initializes an instance of `Emittor` with an initial state and optional matching behavior. If `options.match` is true, `setMatchState` and `emit` are bound to handle state updates; otherwise, `setOnlyState` and `emit` are used. |
+| `setState()`, `emit()`      | Sets the state and Executes all subscribed callbacks (also use `state`)                                            |
+| `getState()`                | Returns the current state (also use `state`).                                                                       |
+| `state`                     | Is current state (with `get` & `set`) you can modify directly.                                                                     |
+| `exec()`, `refresh()`       | Executes all subscribed callbacks with the current state.                                       |
+| `run(state: T)`             | Executes all callbacks with the provided `state` (this will not changed current state).                                               |
+| `connect(callback: Callback<T>)`    | Adds the `callback` to the list of callbacks to be executed on state changes.                    |
+| `disconnect(callback: Callback<T>)` | Removes the specified `callback` from the list of callbacks.                                      |
+| *`setOnlyState(state: T)`   | Updates the state without checking and executes all subscribed callbacks.               |
+| *`setMatchState(state: T)`  | Updates the state only if the new `state` differs from the current state and then executes `setOnlyState(state)`. |
+
+
 </br>
 
 ## 📄 License

package.json

@@ -1,16 +1,16 @@
 {
   "name": "emittor",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "description": "State Management using custom hook without Wrapping components using Providers",
   "private": false,
   "repository": {
     "type": "git",
-    "url": "https://github.com/immiProgrammer/emittor.git"
+    "url": "https://github.com/programming-with-ia/emittor.git"
   },
   "bugs": {
-    "url": "https://github.com/immiProgrammer/emittor/issues"
+    "url": "https://github.com/programming-with-ia/emittor/issues"
   },
-  "homepage": "https://github.com/immiProgrammer/emittor#readme",
+  "homepage": "https://github.com/programming-with-ia/emittor#readme",
   "typings": "dist/index.d.ts",
   "files": [
     "dist"
@@ -34,7 +34,7 @@
     "nextjs state manager",
     "state management"
   ],
-  "author": "immiProgrammer",
+  "author": "immi",
   "license": "MIT",
   "devDependencies": {
     "@types/react": "^18.2.73",

src/createEmittor.ts

@@ -1,11 +1,32 @@
 type Callback<T> = (state: T) => void;
 
+type EmittorOptions = { 
+    match?: boolean
+}
+
 export class Emittor<T> {
     private callbacks: Callback<T>[] = [];
     private _state: T;
+    public setState: Callback<T>;
+    public emit: Callback<T>
 
-    constructor(initialState: T) {
+    constructor(initialState: T, options:EmittorOptions  = { match: true }) {
         this._state = initialState;
+        if (options.match) {
+            this.emit = this.setState = this.setMatchState.bind(this);
+        } else {
+            this.emit = this.setState = this.setOnlyState.bind(this);
+        }
+    }
+
+    setOnlyState(state: T){
+        this._state = state
+        this.exec()
+    }
+
+    setMatchState(state: T){
+        if (state == this._state)return
+        this.setOnlyState(state)
     }
 
     exec(): void {
@@ -21,19 +42,12 @@ export class Emittor<T> {
         });
     }
 
-    emit(state: T): void {
-        // Set the new state if provided and execute callbacks
-        this._state = state;
-        this.exec();
-
-    } setState = this.emit
-
     get state(): T {
         return this._state;
     }
 
     set state(nState: T) {
-        this.emit(nState);
+        this.setState(nState);
     }
 
     getState() {
@@ -54,8 +68,8 @@ export class Emittor<T> {
     }
 }
 
-export function createEmittor<T>(state: T) {
-    return new Emittor(state)
+export function createEmittor<T>(state: T, options?:EmittorOptions) {
+    return new Emittor(state, options)
 }
 
 //* ---
@@ -73,15 +87,15 @@ type ReducerEmittorCallback<R extends string> = {
 
 export class ReducerEmittor<T, R extends string> extends Emittor<T> {
     reducers: ReducerEmittorCallback<R>
-    constructor(initState: T, reducers: Reducers<T, R>) {
-        super(initState)
+    constructor(initState: T, reducers: Reducers<T, R>, options?:EmittorOptions) {
+        super(initState, options)
         this.reducers = {} as ReducerEmittorCallback<R>
         Object.entries(reducers).map(([name, callback]) => {
             this.reducers[name as R] = () => (callback as ReducerCallback<T>)(this)
         })
     }
 }
 
-export function createReducerEmittor<T, K extends string>(initState: T, reducers: Reducers<T, K>) {
-    return new ReducerEmittor(initState, reducers)
+export function createReducerEmittor<T, K extends string>(initState: T, reducers: Reducers<T, K>, options?:EmittorOptions) {
+    return new ReducerEmittor(initState, reducers, options)
 }