synstate 0.1.2 → 1.0.0

package/dist/utils/create-reducer.d.mts

@@ -7,7 +7,7 @@ import { type InitializedObservable } from '../core/index.mjs';
  * @template A - The type of actions
  * @param reducer - A pure function that takes current state and action, returns new state
  * @param initialState - The initial value of the state
- * @returns An object containing the state observable, dispatch function, and snapshot getter
+ * @returns A 3-element tuple: `[state, dispatch, { getSnapshot, initialState }]`
  *
  * @example
  * ```ts
@@ -23,24 +23,27 @@ import { type InitializedObservable } from '../core/index.mjs';
  *   0,
  * );
  *
- * const mut_history: number[] = [];
+ * const stateHistory: number[] = [];
  *
  * state.subscribe((value: number) => {
- *   mut_history.push(value);
+ *   stateHistory.push(value);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(stateHistory, [0]);
  *
  * dispatch({ type: 'increment' }); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(stateHistory, [0, 1]);
  *
  * dispatch({ type: 'increment' });
  *
  * dispatch({ type: 'decrement' });
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2, 1]);
+ * assert.deepStrictEqual(stateHistory, [0, 1, 2, 1]);
  * ```
  */
-export declare const createReducer: <S, A>(reducer: Reducer<S, A>, initialState: S) => readonly [state: InitializedObservable<S>, dispatch: (action: A) => S, getSnapshot: () => S];
+export declare const createReducer: <S, A>(reducer: Reducer<S, A>, initialState: S) => readonly [state: InitializedObservable<S>, dispatch: (action: A) => S, Readonly<{
+    getSnapshot: () => S;
+    initialState: S;
+}>];
 //# sourceMappingURL=create-reducer.d.mts.map

package/dist/utils/create-reducer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,cAAc,CAAC,KACd,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,WAAW,EAAE,MAAM,CAAC,CAerB,CAAC"}
+{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../../src/utils/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,cAAc,CAAC,KACd,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,QAAQ,CAAC;IACP,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CAeH,CAAC"}

package/dist/utils/create-reducer.mjs

@@ -11,7 +11,7 @@ import { source } from '../core/create/source.mjs';
  * @template A - The type of actions
  * @param reducer - A pure function that takes current state and action, returns new state
  * @param initialState - The initial value of the state
- * @returns An object containing the state observable, dispatch function, and snapshot getter
+ * @returns A 3-element tuple: `[state, dispatch, { getSnapshot, initialState }]`
  *
  * @example
  * ```ts
@@ -27,23 +27,23 @@ import { source } from '../core/create/source.mjs';
  *   0,
  * );
  *
- * const mut_history: number[] = [];
+ * const stateHistory: number[] = [];
  *
  * state.subscribe((value: number) => {
- *   mut_history.push(value);
+ *   stateHistory.push(value);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(stateHistory, [0]);
  *
  * dispatch({ type: 'increment' }); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(stateHistory, [0, 1]);
  *
  * dispatch({ type: 'increment' });
  *
  * dispatch({ type: 'decrement' });
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2, 1]);
+ * assert.deepStrictEqual(stateHistory, [0, 1, 2, 1]);
  * ```
  */
 const createReducer = (reducer, initialState) => {
@@ -54,7 +54,7 @@ const createReducer = (reducer, initialState) => {
         return nextState;
     };
     const getSnapshot = () => state.getSnapshot().value;
-    return [state, dispatch, getSnapshot];
+    return [state, dispatch, { getSnapshot, initialState }];
 };
 
 export { createReducer };

package/dist/utils/create-reducer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.mjs","sources":["../../src/utils/create-reducer.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;MACU,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,KAKb;AACF,IAAA,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC;AAErC,IAAA,MAAM,QAAQ,GAAG,CAAC,MAAS,KAAO;AAChC,QAAA,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;AAE5D,QAAA,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;AAErB,QAAA,OAAO,SAAS;AAClB,IAAA,CAAC;IAED,MAAM,WAAW,GAAG,MAAS,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK;AAEtD,IAAA,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAU;AAChD;;;;"}
+{"version":3,"file":"create-reducer.mjs","sources":["../../src/utils/create-reducer.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;MACU,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,KAQb;AACF,IAAA,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC;AAErC,IAAA,MAAM,QAAQ,GAAG,CAAC,MAAS,KAAO;AAChC,QAAA,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;AAE5D,QAAA,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;AAErB,QAAA,OAAO,SAAS;AAClB,IAAA,CAAC;IAED,MAAM,WAAW,GAAG,MAAS,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK;IAEtD,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,CAAU;AAClE;;;;"}

package/dist/utils/create-state.d.mts

@@ -5,77 +5,37 @@ import { type InitializedObservable } from '../core/index.mjs';
  *
  * @template S - The type of the state
  * @param initialState - The initial value of the state
- * @returns An object containing the state observable and methods to manipulate it
+ * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`
  *
  * @example
  * ```ts
  * const [state, setState, { updateState, resetState }] = createState(0);
  *
- * const mut_history: number[] = [];
+ * const stateHistory: number[] = [];
  *
  * state.subscribe((value: number) => {
- *   mut_history.push(value);
+ *   stateHistory.push(value);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(stateHistory, [0]);
  *
  * setState(10); // logs: 10
  *
- * assert.deepStrictEqual(mut_history, [0, 10]);
+ * assert.deepStrictEqual(stateHistory, [0, 10]);
  *
  * updateState((prev: number) => prev + 1); // logs: 11
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11]);
  *
  * resetState(); // logs: 0
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11, 0]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);
  * ```
  */
 export declare const createState: <S>(initialState: S) => readonly [state: InitializedObservable<S>, setState: (v: S) => S, Readonly<{
     updateState: (updateFn: (prev: S) => S) => S;
     resetState: () => S;
     getSnapshot: () => S;
-}>];
-/**
- * Creates a reactive boolean state with convenient methods for boolean operations.
- * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
- *
- * @param initialState - The initial boolean value
- * @returns An object with the state observable and boolean-specific methods
- *
- * @example
- * ```ts
- * const [state, { setTrue, toggle }] = createBooleanState(false);
- *
- * const mut_history: boolean[] = [];
- *
- * state.subscribe((value: boolean) => {
- *   mut_history.push(value);
- * });
- *
- * assert.deepStrictEqual(mut_history, [false]);
- *
- * setTrue(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true]);
- *
- * toggle(); // logs: false
- *
- * assert.deepStrictEqual(mut_history, [false, true, false]);
- *
- * toggle(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true, false, true]);
- * ```
- */
-export declare const createBooleanState: (initialState: boolean) => readonly [state: InitializedObservable<boolean>, Readonly<{
-    setTrue: () => void;
-    setFalse: () => void;
-    setState: (next: boolean) => boolean;
-    toggle: () => boolean;
-    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
-    resetState: () => boolean;
-    getSnapshot: () => boolean;
+    initialState: S;
 }>];
 //# sourceMappingURL=create-state.d.mts.map

package/dist/utils/create-state.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAwB/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,cAAc,CAAC,KACd,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,QAAQ,CAAC;IACP,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC;CACtB,CAAC,CAwBH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,kBAAkB,GAC7B,cAAc,OAAO,KACpB,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,OAAO,CAAC,EACrC,QAAQ,CAAC;IACP,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;IACrC,MAAM,EAAE,MAAM,OAAO,CAAC;IACtB,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,KAAK,OAAO,CAAC;IAC/D,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC,CAqBH,CAAC"}
+{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAwB/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,cAAc,CAAC,KACd,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,QAAQ,CAAC;IACP,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CAyBH,CAAC"}

package/dist/utils/create-state.mjs

@@ -14,35 +14,35 @@ const reducer = (state, action) => {
  *
  * @template S - The type of the state
  * @param initialState - The initial value of the state
- * @returns An object containing the state observable and methods to manipulate it
+ * @returns A 3-element tuple: `[state, setState, { updateState, resetState, getSnapshot, initialState }]`
  *
  * @example
  * ```ts
  * const [state, setState, { updateState, resetState }] = createState(0);
  *
- * const mut_history: number[] = [];
+ * const stateHistory: number[] = [];
  *
  * state.subscribe((value: number) => {
- *   mut_history.push(value);
+ *   stateHistory.push(value);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(stateHistory, [0]);
  *
  * setState(10); // logs: 10
  *
- * assert.deepStrictEqual(mut_history, [0, 10]);
+ * assert.deepStrictEqual(stateHistory, [0, 10]);
  *
  * updateState((prev: number) => prev + 1); // logs: 11
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11]);
  *
  * resetState(); // logs: 0
  *
- * assert.deepStrictEqual(mut_history, [0, 10, 11, 0]);
+ * assert.deepStrictEqual(stateHistory, [0, 10, 11, 0]);
  * ```
  */
 const createState = (initialState) => {
-    const [state, dispatch, getSnapshot] = createReducer(reducer, initialState);
+    const [state, dispatch, { getSnapshot }] = createReducer(reducer, initialState);
     const updateState = (updateFn) => dispatch({ type: 'update', updateFn });
     const setState = (nextState) => dispatch({ type: 'set', nextState });
     const resetState = () => dispatch({ type: 'set', nextState: initialState });
@@ -53,60 +53,10 @@ const createState = (initialState) => {
             updateState,
             resetState,
             getSnapshot,
-        },
-    ];
-};
-/**
- * Creates a reactive boolean state with convenient methods for boolean operations.
- * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
- *
- * @param initialState - The initial boolean value
- * @returns An object with the state observable and boolean-specific methods
- *
- * @example
- * ```ts
- * const [state, { setTrue, toggle }] = createBooleanState(false);
- *
- * const mut_history: boolean[] = [];
- *
- * state.subscribe((value: boolean) => {
- *   mut_history.push(value);
- * });
- *
- * assert.deepStrictEqual(mut_history, [false]);
- *
- * setTrue(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true]);
- *
- * toggle(); // logs: false
- *
- * assert.deepStrictEqual(mut_history, [false, true, false]);
- *
- * toggle(); // logs: true
- *
- * assert.deepStrictEqual(mut_history, [false, true, false, true]);
- * ```
- */
-const createBooleanState = (initialState) => {
-    const [state, setState, { updateState, resetState, getSnapshot }] = createState(initialState);
-    return [
-        state,
-        {
-            setTrue: () => {
-                setState(true);
-            },
-            setFalse: () => {
-                setState(false);
-            },
-            toggle: () => updateState((s) => !s),
-            setState,
-            updateState,
-            resetState,
-            getSnapshot,
+            initialState,
         },
     ];
 };
 
-export { createBooleanState, createState };
+export { createState };
 //# sourceMappingURL=create-state.mjs.map

package/dist/utils/create-state.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-state.mjs","sources":["../../src/utils/create-state.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAcA,MAAM,OAAO,GAAG,CAAK,KAAQ,EAAE,MAAiB,KAAO;AACrD,IAAA,QAAQ,MAAM,CAAC,IAAI;AACjB,QAAA,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,SAAS;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;;AAEnC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,WAAW,GAAG,CACzB,YAAe,KASb;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC,GAAG,aAAa,CAClD,OAAO,EACP,YAAY,CACb;AAED,IAAA,MAAM,WAAW,GAAG,CAAC,QAAwB,KAC3C,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAExC,IAAA,MAAM,QAAQ,GAAG,CAAC,SAAY,KAAQ,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;AAE1E,IAAA,MAAM,UAAU,GAAG,MACjB,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IAEpD,OAAO;QACL,KAAK;QACL,QAAQ;AACR,QAAA;YACE,WAAW;YACX,UAAU;YACV,WAAW;AACZ,SAAA;KACO;AACZ;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,kBAAkB,GAAG,CAChC,YAAqB,KAYnB;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,GAC/D,WAAW,CAAC,YAAY,CAAC;IAE3B,OAAO;QACL,KAAK;AACL,QAAA;YACE,OAAO,EAAE,MAAK;gBACZ,QAAQ,CAAC,IAAI,CAAC;YAChB,CAAC;YACD,QAAQ,EAAE,MAAK;gBACb,QAAQ,CAAC,KAAK,CAAC;YACjB,CAAC;AACD,YAAA,MAAM,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YACpC,QAAQ;YACR,WAAW;YACX,UAAU;YACV,WAAW;AACZ,SAAA;KACO;AACZ;;;;"}
+{"version":3,"file":"create-state.mjs","sources":["../../src/utils/create-state.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAcA,MAAM,OAAO,GAAG,CAAK,KAAQ,EAAE,MAAiB,KAAO;AACrD,IAAA,QAAQ,MAAM,CAAC,IAAI;AACjB,QAAA,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,SAAS;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;;AAEnC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,WAAW,GAAG,CACzB,YAAe,KAUb;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,aAAa,CACtD,OAAO,EACP,YAAY,CACb;AAED,IAAA,MAAM,WAAW,GAAG,CAAC,QAAwB,KAC3C,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAExC,IAAA,MAAM,QAAQ,GAAG,CAAC,SAAY,KAAQ,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;AAE1E,IAAA,MAAM,UAAU,GAAG,MACjB,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IAEpD,OAAO;QACL,KAAK;QACL,QAAQ;AACR,QAAA;YACE,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;AACb,SAAA;KACO;AACZ;;;;"}

package/dist/utils/index.d.mts

@@ -1,3 +1,5 @@
+export * from './collect-to-array.mjs';
+export * from './create-boolean-state.mjs';
 export * from './create-event-emitter.mjs';
 export * from './create-reducer.mjs';
 export * from './create-state.mjs';

package/dist/utils/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/utils/index.mts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/utils/index.mts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

package/dist/utils/index.mjs

@@ -1,4 +1,6 @@
+export { collectToArray } from './collect-to-array.mjs';
+export { createBooleanState } from './create-boolean-state.mjs';
 export { createEventEmitter, createValueEmitter } from './create-event-emitter.mjs';
 export { createReducer } from './create-reducer.mjs';
-export { createBooleanState, createState } from './create-state.mjs';
+export { createState } from './create-state.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -28,36 +28,42 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^6.5.0"
+    "ts-data-forge": "^6.8.0"
   },
   "devDependencies": {
+    "@reduxjs/toolkit": "^2.11.2",
     "@types/argparse": "^2.0.17",
     "@types/react": "^19.2.14",
     "argparse": "^2.0.1",
-    "react": "^19.2.4"
+    "jotai": "^2.18.1",
+    "mobx": "^6.15.0",
+    "react": "^19.2.4",
+    "rxjs": "^7.8.2",
+    "valtio": "^2.3.1",
+    "zustand": "^5.0.12"
   },
   "scripts": {
+    "benchmark": "tsx ./scripts/cmd/run-benchmark.mts",
+    "benchmark:cascaded-diamond": "tsx ./scripts/cmd/run-benchmark-cascaded-diamond.mts",
+    "benchmark:deep-chain": "tsx ./scripts/cmd/run-benchmark-deep-chain.mts",
     "build": "tsx ./scripts/cmd/build.mts",
     "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
     "check:ext": "tsx ./scripts/cmd/check-ext.mts",
     "check-all": "tsx ./scripts/cmd/check-all.mts",
-    "codemod": "convert-to-readonly '{src,samples,test}/**/*.{mts,tsx}'",
-    "doc": "tsx ./scripts/cmd/gen-docs.mts",
+    "doc": "run-s doc:embed doc:embed:jsdoc doc:gen-sample-diffs fmt",
     "doc:embed": "tsx ./scripts/cmd/embed-examples.mts",
     "doc:embed:jsdoc": "tsx ./scripts/cmd/embed-examples-in-jsdoc.mts",
-    "doc:preview": "vite preview --config ./configs/vite.doc.config.ts",
-    "doc:watch": "typedoc --options ./configs/typedoc.config.mjs --watch",
-    "fmt": "pnpm run z:prettier .",
+    "doc:gen-sample-diffs": "tsx ./scripts/cmd/generate-sample-diffs.mts",
+    "fmt": "format-uncommitted",
+    "fmt:full": "pnpm run z:prettier .",
     "gi": "run-s gi:src fmt",
-    "gi:src": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts",
+    "gi:src": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude \"core/utils/**\"",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "pnpm run z:vitest:node run",
-    "test:all": "run-p test test:stream",
     "test:browser": "pnpm run z:vitest --project='Browser' run",
     "test:cov": "pnpm run z:vitest:node run --coverage",
     "test:cov:ui": "vite preview --outDir ./coverage",
-    "test:stream": "pnpm run z:vitest:stream run",
     "test:ui": "pnpm run z:vitest:node --ui",
     "testw": "pnpm run z:vitest:node watch",
     "tsc": "tsc --noEmit",

package/src/core/class/child-observable-class.mts

@@ -1,5 +1,6 @@
 import { Arr } from 'ts-data-forge';
 import {
+  isChildObservable,
   isManagerObservable,
   type AsyncChildObservable,
   type ChildObservable,
@@ -14,13 +15,64 @@ import {
   type WithInitialValueOperator,
   type Wrap,
 } from '../types/index.mjs';
-import { binarySearch, issueUpdaterSymbol, maxDepth } from '../utils/index.mjs';
+import { binarySearch, issueUpdateToken, maxDepth } from '../utils/index.mjs';
 import { ObservableBaseClass } from './observable-base-class.mjs';
 
+/**
+ * Detects circular dependencies by walking the full ancestor chain of the
+ * given parents and checking whether `child` already appears among them.
+ *
+ * @throws {Error} if a circular dependency is detected
+ */
+const hasCircularDependencyFrom = (
+  node: Observable<unknown>,
+  mut_visited: MutableSet<ObservableId>,
+  mut_inPath: MutableSet<ObservableId>,
+): boolean => {
+  if (mut_inPath.has(node.id)) return true;
+
+  if (mut_visited.has(node.id)) return false;
+
+  mut_visited.add(node.id);
+
+  mut_inPath.add(node.id);
+
+  if (isChildObservable(node)) {
+    for (const parent of node.parents) {
+      if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+        return true;
+      }
+    }
+  }
+
+  mut_inPath.delete(node.id);
+
+  return false;
+};
+
+const detectCircularDependency = (
+  child: ChildObservable<unknown>,
+  parents: readonly Observable<unknown>[],
+): void => {
+  const mut_visited = new Set<ObservableId>();
+
+  const mut_inPath = new Set<ObservableId>([child.id]);
+
+  for (const parent of parents) {
+    if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+      throw new Error(
+        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
+      );
+    }
+  }
+};
+
 const registerChild = <A,>(
   child: ChildObservable<A>,
   parents: ChildObservable<A>['parents'],
 ): void => {
+  detectCircularDependency(child, parents);
+
   for (const p of parents) {
     p.addChild(child);
   }
@@ -76,7 +128,7 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
   implements AsyncChildObservable<A, P>
 {
   readonly parents;
-  #mut_procedure: readonly ChildObservable<unknown>[];
+  #mut_propagationOrder: readonly ChildObservable<unknown>[];
   protected readonly descendantsIdSet: MutableSet<ObservableId>;
 
   constructor({
@@ -96,7 +148,7 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
 
     this.parents = parents;
 
-    this.#mut_procedure = [];
+    this.#mut_propagationOrder = [];
 
     this.descendantsIdSet = new Set<ObservableId>();
 
@@ -110,20 +162,24 @@ export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
     this.descendantsIdSet.add(child.id);
 
     const insertPos = binarySearch(
-      this.#mut_procedure.map((a) => a.depth),
+      this.#mut_propagationOrder.map((a) => a.depth),
       child.depth,
     );
 
-    this.#mut_procedure = Arr.toInserted(this.#mut_procedure, insertPos, child);
+    this.#mut_propagationOrder = Arr.toInserted(
+      this.#mut_propagationOrder,
+      insertPos,
+      child,
+    );
   }
 
   startUpdate(nextValue: A): void {
-    const updaterSymbol = issueUpdaterSymbol();
+    const updateToken = issueUpdateToken();
 
-    this.setNext(nextValue, updaterSymbol);
+    this.setNext(nextValue, updateToken);
 
-    for (const p of this.#mut_procedure) {
-      p.tryUpdate(updaterSymbol);
+    for (const p of this.#mut_propagationOrder) {
+      p.tryUpdate(updateToken);
     }
   }
 

package/src/core/class/circular-dependency-comparison.test.mts

@@ -0,0 +1,142 @@
+/**
+ * Comparison tests: how SynState, RxJS, and Jotai handle circular dependencies.
+ *
+ * - SynState: detects cycles at construction time and throws a clear error.
+ * - RxJS: pipe() always returns a new Observable, so static cycles cannot be
+ *   expressed through the public API. No detection is needed or provided.
+ * - Jotai: circular atom definitions are silently accepted. A cycle manifests
+ *   only at read time as a `Maximum call stack size exceeded` error.
+ */
+/* eslint-disable functional/immutable-data */
+/* eslint-disable no-new */
+import { type Atom, atom, createStore } from 'jotai';
+import { BehaviorSubject, combineLatest, map as rxMap } from 'rxjs';
+import { Optional } from 'ts-data-forge';
+import { combine } from '../combine/index.mjs';
+import { source } from '../create/index.mjs';
+import { map } from '../operators/index.mjs';
+import { SyncChildObservableClass } from './child-observable-class.mjs';
+import { RootObservableClass } from './root-observable-class.mjs';
+
+describe('circular dependency comparison', () => {
+  describe('SynState', () => {
+    test('detects cycle at construction time with a clear error message', () => {
+      const root = new RootObservableClass({
+        initialValue: Optional.some(0),
+      });
+
+      const childA = new SyncChildObservableClass({
+        parents: [root],
+        initialValue: Optional.some(0),
+      });
+
+      const childB = new SyncChildObservableClass({
+        parents: [childA],
+        initialValue: Optional.some(0),
+      });
+
+      // Simulate a cycle: childA → childB → childA
+      // In normal usage this is impossible — the check runs in every
+      // child constructor before the reference becomes available.
+      Object.defineProperty(childA, 'parents', {
+        value: [childB],
+        writable: false,
+        configurable: true,
+      });
+
+      expect(() => {
+        new SyncChildObservableClass({
+          parents: [childA],
+          initialValue: Optional.some(0),
+        });
+      }).toThrow(
+        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
+      );
+    });
+
+    test('accepts valid DAG (diamond dependency)', () => {
+      const a$ = source(0);
+
+      const b$ = a$.pipe(map((x) => x * 10));
+
+      const c$ = a$.pipe(map((x) => x * 1000));
+
+      expect(() => {
+        combine([b$, c$]);
+      }).not.toThrow();
+    });
+  });
+
+  describe('RxJS', () => {
+    test('cannot express static graph cycles — pipe() always creates new instances', () => {
+      // RxJS pipe() returns a brand-new Observable each time, so there is no
+      // way to construct a cycle through the public API.  This test documents
+      // that behavior rather than asserting error detection.
+      const a$ = new BehaviorSubject(0);
+
+      const b$ = a$.pipe(rxMap((x) => x + 1));
+
+      // b$ is a wholly separate object; there is no "parents" link back to a$.
+      expect(a$).not.toBe(b$);
+
+      // A diamond dependency works but produces glitches (intermediate states).
+      const left$ = a$.pipe(rxMap((x) => x * 10));
+
+      const right$ = a$.pipe(rxMap((x) => x * 1000));
+
+      const combined$ = combineLatest([left$, right$]).pipe(
+        rxMap(([l, r]) => l + r),
+      );
+
+      const mut_values: number[] = [];
+
+      combined$.subscribe((v) => {
+        mut_values.push(v);
+      });
+
+      a$.next(1);
+
+      a$.next(2);
+
+      // Glitch values (10, 1020) appear between the correct values.
+      assert.deepStrictEqual(mut_values, [0, 10, 1010, 1020, 2020]);
+    });
+  });
+
+  describe('Jotai', () => {
+    test('does not detect circular atom definitions — crashes on read', () => {
+      const store = createStore();
+
+      // Two atoms that depend on each other — an obvious cycle.
+      // Explicit type annotations are required because TypeScript cannot infer
+      // the type of mutually-recursive initializers.
+      const atomA: Atom<number> = atom((get) => get(atomB) + 1);
+
+      const atomB: Atom<number> = atom((get) => get(atomA) + 1);
+
+      // Definition succeeds without any error.
+      // Reading triggers infinite recursion.
+      expect(() => {
+        store.get(atomA);
+      }).toThrow('Maximum call stack size exceeded');
+    });
+
+    test('handles valid DAG (diamond dependency) correctly', () => {
+      const store = createStore();
+
+      const base = atom(1);
+
+      const left = atom((get) => get(base) * 10);
+
+      const right = atom((get) => get(base) * 1000);
+
+      const combined = atom((get) => get(left) + get(right));
+
+      expect(store.get(combined)).toBe(1010);
+
+      store.set(base, 2);
+
+      expect(store.get(combined)).toBe(2020);
+    });
+  });
+});