synstate-preact-signals 0.2.2 → 1.0.0

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

@@ -25,7 +25,7 @@ import { type InitializedObservable } from 'synstate';
  * assert.strictEqual(isOpenSignal.value, true);
  * ```
  */
-export declare const createBooleanState: (initialState: boolean) => readonly [signal: ReadonlySignal<boolean>, Readonly<{
+export declare const createBooleanState: (initialState: boolean) => readonly [signal: ReadonlySignal<boolean>, utils: Readonly<{
     state: InitializedObservable<boolean>;
     setTrue: () => void;
     setFalse: () => void;

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

@@ -1 +1 @@
-{"version":3,"file":"create-boolean-state.d.mts","sourceRoot":"","sources":["../src/create-boolean-state.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,kBAAkB,GAC7B,cAAc,OAAO,KACpB,SAAS,CACV,MAAM,EAAE,cAAc,CAAC,OAAO,CAAC,EAC/B,QAAQ,CAAC;IACP,KAAK,EAAE,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACtC,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;IAC3B,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC,CA+BH,CAAC"}
+{"version":3,"file":"create-boolean-state.d.mts","sourceRoot":"","sources":["../src/create-boolean-state.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,kBAAkB,iBACf,OAAO,KACpB,SAAS,CACV,MAAM,EAAE,cAAc,CAAC,OAAO,CAAC,EAC/B,KAAK,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACtC,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;IAC3B,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC,CA+BH,CAAC"}

package/dist/create-boolean-state.mjs

@@ -1,48 +1,34 @@
 import { createBooleanState as createBooleanState$1 } from 'synstate';
 import { toSignal } from './to-signal.mjs';
 
-/**
- * Creates a synstate boolean state with a `ReadonlySignal` for reading the
- * current value in Preact components.
- *
- * @example
- * ```ts
- * // eslint-disable-next-line @typescript-eslint/no-shadow
- * const [isOpenSignal, { setTrue: open, setFalse: close, toggle }] =
- *   createBooleanState(false);
- *
- * assert.strictEqual(isOpenSignal.value, false);
- *
- * open();
- *
- * assert.strictEqual(isOpenSignal.value, true);
- *
- * close();
- *
- * assert.strictEqual(isOpenSignal.value, false);
- *
- * toggle();
- *
- * assert.strictEqual(isOpenSignal.value, true);
- * ```
- */
 const createBooleanState = (initialState) => {
-    const [state, { setTrue, setFalse, setState, toggle, updateState, resetState, getSnapshot, },] = createBooleanState$1(initialState);
-    const sig = toSignal(state);
-    return [
-        sig,
-        {
-            state,
-            setTrue,
-            setFalse,
-            setState,
-            toggle,
-            updateState,
-            resetState,
-            getSnapshot,
-            initialState,
-        },
-    ];
+  const [
+    state,
+    {
+      setTrue,
+      setFalse,
+      setState,
+      toggle,
+      updateState,
+      resetState,
+      getSnapshot
+    }
+  ] = createBooleanState$1(initialState);
+  const sig = toSignal(state);
+  return [
+    sig,
+    {
+      state,
+      setTrue,
+      setFalse,
+      setState,
+      toggle,
+      updateState,
+      resetState,
+      getSnapshot,
+      initialState
+    }
+  ];
 };
 
 export { createBooleanState };

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

@@ -1 +1 @@
-{"version":3,"file":"create-boolean-state.mjs","sources":["../src/create-boolean-state.mts"],"sourcesContent":[null],"names":["createBooleanStateBase"],"mappings":";;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,kBAAkB,GAAG,CAChC,YAAqB,KAcnB;IACF,MAAM,CACJ,KAAK,EACL,EACE,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,WAAW,EACX,UAAU,EACV,WAAW,GACZ,EACF,GAAGA,oBAAsB,CAAC,YAAY,CAAC;AAExC,IAAA,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC;IAE3B,OAAO;QACL,GAAG;AACH,QAAA;YACE,KAAK;YACL,OAAO;YACP,QAAQ;YACR,QAAQ;YACR,MAAM;YACN,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;AACb,SAAA;KACO;AACZ;;;;"}
+{"version":3,"file":"create-boolean-state.mjs","sources":["../src/create-boolean-state.mts"],"sourcesContent":["import { type ReadonlySignal } from '@preact/signals';\nimport {\n  type InitializedObservable,\n  createBooleanState as createBooleanStateBase,\n} from 'synstate';\nimport { toSignal } from './to-signal.mjs';\n\n/**\n * Creates a synstate boolean state with a `ReadonlySignal` for reading the\n * current value in Preact components.\n *\n * @example\n * ```ts\n * // eslint-disable-next-line @typescript-eslint/no-shadow\n * const [isOpenSignal, { setTrue: open, setFalse: close, toggle }] =\n *   createBooleanState(false);\n *\n * assert.strictEqual(isOpenSignal.value, false);\n *\n * open();\n *\n * assert.strictEqual(isOpenSignal.value, true);\n *\n * close();\n *\n * assert.strictEqual(isOpenSignal.value, false);\n *\n * toggle();\n *\n * assert.strictEqual(isOpenSignal.value, true);\n * ```\n */\nexport const createBooleanState = (\n  initialState: boolean,\n): readonly [\n  signal: ReadonlySignal<boolean>,\n  utils: Readonly<{\n    state: InitializedObservable<boolean>;\n    setTrue: () => void;\n    setFalse: () => void;\n    setState: (next: boolean) => boolean;\n    toggle: () => boolean;\n    updateState: (updateFn: (prev: boolean) => boolean) => boolean;\n    resetState: () => boolean;\n    getSnapshot: () => boolean;\n    initialState: boolean;\n  }>,\n] => {\n  const [\n    state,\n    {\n      setTrue,\n      setFalse,\n      setState,\n      toggle,\n      updateState,\n      resetState,\n      getSnapshot,\n    },\n  ] = createBooleanStateBase(initialState);\n\n  const sig = toSignal(state);\n\n  return [\n    sig,\n    {\n      state,\n      setTrue,\n      setFalse,\n      setState,\n      toggle,\n      updateState,\n      resetState,\n      getSnapshot,\n      initialState,\n    },\n  ] as const;\n};\n"],"names":["createBooleanStateBase"],"mappings":";;;AAgCO,MAAM,kBAAA,GAAqB,CAChC,YAAA,KAcG;AACH,EAAA,MAAM;AAAA,IACJ,KAAA;AAAA,IACA;AAAA,MACE,OAAA;AAAA,MACA,QAAA;AAAA,MACA,QAAA;AAAA,MACA,MAAA;AAAA,MACA,WAAA;AAAA,MACA,UAAA;AAAA,MACA;AAAA;AACF,GACF,GAAIA,qBAAuB,YAAY,CAAA;AAEvC,EAAA,MAAM,GAAA,GAAM,SAAS,KAAK,CAAA;AAE1B,EAAA,OAAO;AAAA,IACL,GAAA;AAAA,IACA;AAAA,MACE,KAAA;AAAA,MACA,OAAA;AAAA,MACA,QAAA;AAAA,MACA,QAAA;AAAA,MACA,MAAA;AAAA,MACA,WAAA;AAAA,MACA,UAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA;AACF,GACF;AACF;;;;"}

package/dist/create-reducer.d.mts

@@ -32,7 +32,7 @@ import { type Reducer } from 'ts-type-forge';
  * assert.strictEqual(getSnapshot(), 1);
  * ```
  */
-export declare const createReducer: <S, A>(reducer: Reducer<S, A>, initialState: S) => readonly [signal: ReadonlySignal<S>, dispatch: (action: A) => S, Readonly<{
+export declare const createReducer: <S, A>(reducer: Reducer<S, A>, initialState: S) => readonly [signal: ReadonlySignal<S>, dispatch: (action: A) => S, utils: Readonly<{
     state: InitializedObservable<S>;
     getSnapshot: () => S;
     initialState: S;

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

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../src/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,cAAc,CAAC,KACd,SAAS,CACV,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,QAAQ,CAAC;IACP,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CAUH,CAAC"}
+{"version":3,"file":"create-reducer.d.mts","sourceRoot":"","sources":["../src/create-reducer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,WACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,gBACR,CAAC,KACd,SAAS,CACV,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAC1B,KAAK,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CAUH,CAAC"}

package/dist/create-reducer.mjs

@@ -1,41 +1,13 @@
 import { createReducer as createReducer$1 } from 'synstate';
 import { toSignal } from './to-signal.mjs';
 
-/**
- * Creates a synstate reducer with a `ReadonlySignal` for reading the current
- * value in Preact components.
- *
- * @example
- * ```ts
- * type Action = Readonly<{ type: 'increment' } | { type: 'decrement' }>;
- *
- * const [countSignal, dispatch, { getSnapshot }] = createReducer(
- *   (state: number, action: Action) =>
- *     action.type === 'increment' ? state + 1 : state - 1,
- *   0,
- * );
- *
- * assert.strictEqual(countSignal.value, 0);
- *
- * dispatch({ type: 'increment' });
- *
- * assert.strictEqual(countSignal.value, 1);
- *
- * dispatch({ type: 'increment' });
- *
- * assert.strictEqual(countSignal.value, 2);
- *
- * dispatch({ type: 'decrement' });
- *
- * assert.strictEqual(countSignal.value, 1);
- *
- * assert.strictEqual(getSnapshot(), 1);
- * ```
- */
 const createReducer = (reducer, initialState) => {
-    const [state, dispatch, { getSnapshot }] = createReducer$1(reducer, initialState);
-    const sig = toSignal(state);
-    return [sig, dispatch, { state, getSnapshot, initialState }];
+  const [state, dispatch, { getSnapshot }] = createReducer$1(
+    reducer,
+    initialState
+  );
+  const sig = toSignal(state);
+  return [sig, dispatch, { state, getSnapshot, initialState }];
 };
 
 export { createReducer };

package/dist/create-reducer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-reducer.mjs","sources":["../src/create-reducer.mts"],"sourcesContent":[null],"names":["createReducerBase"],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;MACU,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,KASb;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAGA,eAAiB,CAC1D,OAAO,EACP,YAAY,CACb;AAED,IAAA,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC;AAE3B,IAAA,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC;AAC9D;;;;"}
+{"version":3,"file":"create-reducer.mjs","sources":["../src/create-reducer.mts"],"sourcesContent":["import { type ReadonlySignal } from '@preact/signals';\nimport {\n  createReducer as createReducerBase,\n  type InitializedObservable,\n} from 'synstate';\nimport { type Reducer } from 'ts-type-forge';\nimport { toSignal } from './to-signal.mjs';\n\n/**\n * Creates a synstate reducer with a `ReadonlySignal` for reading the current\n * value in Preact components.\n *\n * @example\n * ```ts\n * type Action = Readonly<{ type: 'increment' } | { type: 'decrement' }>;\n *\n * const [countSignal, dispatch, { getSnapshot }] = createReducer(\n *   (state: number, action: Action) =>\n *     action.type === 'increment' ? state + 1 : state - 1,\n *   0,\n * );\n *\n * assert.strictEqual(countSignal.value, 0);\n *\n * dispatch({ type: 'increment' });\n *\n * assert.strictEqual(countSignal.value, 1);\n *\n * dispatch({ type: 'increment' });\n *\n * assert.strictEqual(countSignal.value, 2);\n *\n * dispatch({ type: 'decrement' });\n *\n * assert.strictEqual(countSignal.value, 1);\n *\n * assert.strictEqual(getSnapshot(), 1);\n * ```\n */\nexport const createReducer = <S, A>(\n  reducer: Reducer<S, A>,\n  initialState: S,\n): readonly [\n  signal: ReadonlySignal<S>,\n  dispatch: (action: A) => S,\n  utils: Readonly<{\n    state: InitializedObservable<S>;\n    getSnapshot: () => S;\n    initialState: S;\n  }>,\n] => {\n  const [state, dispatch, { getSnapshot }] = createReducerBase(\n    reducer,\n    initialState,\n  );\n\n  const sig = toSignal(state);\n\n  return [sig, dispatch, { state, getSnapshot, initialState }];\n};\n"],"names":["createReducerBase"],"mappings":";;;AAuCO,MAAM,aAAA,GAAgB,CAC3B,OAAA,EACA,YAAA,KASG;AACH,EAAA,MAAM,CAAC,KAAA,EAAO,QAAA,EAAU,EAAE,WAAA,EAAa,CAAA,GAAIA,eAAA;AAAA,IACzC,OAAA;AAAA,IACA;AAAA,GACF;AAEA,EAAA,MAAM,GAAA,GAAM,SAAS,KAAK,CAAA;AAE1B,EAAA,OAAO,CAAC,GAAA,EAAK,QAAA,EAAU,EAAE,KAAA,EAAO,WAAA,EAAa,cAAc,CAAA;AAC7D;;;;"}

package/dist/create-state.d.mts

@@ -35,7 +35,7 @@ import { type InitializedObservable } from 'synstate';
  * assert.strictEqual(getSnapshot(), 0);
  * ```
  */
-export declare const createState: <S>(initialState: S) => readonly [signal: ReadonlySignal<S>, setState: (v: S) => S, Readonly<{
+export declare const createState: <S>(initialState: S) => readonly [signal: ReadonlySignal<S>, setState: (v: S) => S, utils: Readonly<{
     state: InitializedObservable<S>;
     updateState: (updateFn: (prev: S) => S) => S;
     resetState: () => S;

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

@@ -1 +1 @@
-{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../src/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,cAAc,CAAC,KACd,SAAS,CACV,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,QAAQ,CAAC;IACP,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAChC,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,CAkBH,CAAC"}
+{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../src/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,gBACb,CAAC,KACd,SAAS,CACV,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,KAAK,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAChC,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,CAkBH,CAAC"}

package/dist/create-state.mjs

@@ -1,55 +1,20 @@
 import { createState as createState$1 } from 'synstate';
 import { toSignal } from './to-signal.mjs';
 
-/**
- * Creates a synstate state with a `ReadonlySignal` for reading the current
- * value in Preact components.
- *
- * Unlike `synstate-preact-hooks`' `createState` which returns a hook, this
- * returns a `ReadonlySignal` that can be embedded directly in JSX without
- * hooks, enabling fine-grained DOM updates.
- *
- * @example
- * ```ts
- * const [
- *   countSignal,
- *   setCount,
- *   { updateState, resetState, getSnapshot, initialState },
- * ] = createState(0);
- *
- * assert.strictEqual(countSignal.value, 0);
- *
- * assert.strictEqual(initialState, 0);
- *
- * setCount(5);
- *
- * assert.strictEqual(countSignal.value, 5);
- *
- * updateState((prev) => prev + 1);
- *
- * assert.strictEqual(countSignal.value, 6);
- *
- * resetState();
- *
- * assert.strictEqual(countSignal.value, 0);
- *
- * assert.strictEqual(getSnapshot(), 0);
- * ```
- */
 const createState = (initialState) => {
-    const [state, setState, { updateState, resetState, getSnapshot }] = createState$1(initialState);
-    const sig = toSignal(state);
-    return [
-        sig,
-        setState,
-        {
-            state,
-            updateState,
-            resetState,
-            getSnapshot,
-            initialState,
-        },
-    ];
+  const [state, setState, { updateState, resetState, getSnapshot }] = createState$1(initialState);
+  const sig = toSignal(state);
+  return [
+    sig,
+    setState,
+    {
+      state,
+      updateState,
+      resetState,
+      getSnapshot,
+      initialState
+    }
+  ];
 };
 
 export { createState };

package/dist/create-state.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-state.mjs","sources":["../src/create-state.mts"],"sourcesContent":[null],"names":["createStateBase"],"mappings":";;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACI,MAAM,WAAW,GAAG,CACzB,YAAe,KAWb;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,GAC/DA,aAAe,CAAC,YAAY,CAAC;AAE/B,IAAA,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC;IAE3B,OAAO;QACL,GAAG;QACH,QAAQ;AACR,QAAA;YACE,KAAK;YACL,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;AACb,SAAA;KACO;AACZ;;;;"}
+{"version":3,"file":"create-state.mjs","sources":["../src/create-state.mts"],"sourcesContent":["import { type ReadonlySignal } from '@preact/signals';\nimport {\n  createState as createStateBase,\n  type InitializedObservable,\n} from 'synstate';\nimport { toSignal } from './to-signal.mjs';\n\n/**\n * Creates a synstate state with a `ReadonlySignal` for reading the current\n * value in Preact components.\n *\n * Unlike `synstate-preact-hooks`' `createState` which returns a hook, this\n * returns a `ReadonlySignal` that can be embedded directly in JSX without\n * hooks, enabling fine-grained DOM updates.\n *\n * @example\n * ```ts\n * const [\n *   countSignal,\n *   setCount,\n *   { updateState, resetState, getSnapshot, initialState },\n * ] = createState(0);\n *\n * assert.strictEqual(countSignal.value, 0);\n *\n * assert.strictEqual(initialState, 0);\n *\n * setCount(5);\n *\n * assert.strictEqual(countSignal.value, 5);\n *\n * updateState((prev) => prev + 1);\n *\n * assert.strictEqual(countSignal.value, 6);\n *\n * resetState();\n *\n * assert.strictEqual(countSignal.value, 0);\n *\n * assert.strictEqual(getSnapshot(), 0);\n * ```\n */\nexport const createState = <S,>(\n  initialState: S,\n): readonly [\n  signal: ReadonlySignal<S>,\n  setState: (v: S) => S,\n  utils: Readonly<{\n    state: InitializedObservable<S>;\n    updateState: (updateFn: (prev: S) => S) => S;\n    resetState: () => S;\n    getSnapshot: () => S;\n    initialState: S;\n  }>,\n] => {\n  const [state, setState, { updateState, resetState, getSnapshot }] =\n    createStateBase(initialState);\n\n  const sig = toSignal(state);\n\n  return [\n    sig,\n    setState,\n    {\n      state,\n      updateState,\n      resetState,\n      getSnapshot,\n      initialState,\n    },\n  ] as const;\n};\n"],"names":["createStateBase"],"mappings":";;;AA0CO,MAAM,WAAA,GAAc,CACzB,YAAA,KAWG;AACH,EAAA,MAAM,CAAC,KAAA,EAAO,QAAA,EAAU,EAAE,WAAA,EAAa,YAAY,WAAA,EAAa,CAAA,GAC9DA,aAAA,CAAgB,YAAY,CAAA;AAE9B,EAAA,MAAM,GAAA,GAAM,SAAS,KAAK,CAAA;AAE1B,EAAA,OAAO;AAAA,IACL,GAAA;AAAA,IACA,QAAA;AAAA,IACA;AAAA,MACE,KAAA;AAAA,MACA,WAAA;AAAA,MACA,UAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA;AACF,GACF;AACF;;;;"}

package/dist/from-signal.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"from-signal.d.mts","sourceRoot":"","sources":["../src/from-signal.mts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAU,KAAK,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAE1B,KAAK,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,UAAU,EAAE,2BAA2B,CAAC,CAAC,CAAC,EAC1C,OAAO,EAAE,MAAM,IAAI,CASpB,CAAC"}
+{"version":3,"file":"from-signal.d.mts","sourceRoot":"","sources":["../src/from-signal.mts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAU,KAAK,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,OAErB,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,KACjC,SAAS,CACV,UAAU,EAAE,2BAA2B,CAAC,CAAC,CAAC,EAC1C,OAAO,EAAE,MAAM,IAAI,CASpB,CAAC"}

package/dist/from-signal.mjs

@@ -1,50 +1,12 @@
 import { effect } from '@preact/signals';
 import { source } from 'synstate';
 
-/**
- * Converts a Preact `Signal` (or `ReadonlySignal`) into a synstate
- * `InitializedSourceObservable`.
- *
- * This allows applying synstate's rich operator chain (e.g. `map`, `filter`,
- * `debounce`, `switchMap`) to values originating from Preact Signals.
- *
- * The bridge uses `effect()` from `@preact/signals` to track signal changes
- * and propagate them to the observable.
- *
- * @returns A tuple of `[observable, dispose]`.
- *   - `observable` — an `InitializedSourceObservable` that mirrors the signal.
- *   - `dispose` — a function to stop tracking the signal. Call this when the
- *     bridge is no longer needed to avoid memory leaks.
- *
- * @example
- * ```ts
- * const input = signal('hello');
- *
- * const [input$, dispose] = fromSignal(input);
- *
- * const mut_valueHistory: string[] = [];
- *
- * input$.subscribe((value) => {
- *   mut_valueHistory.push(value);
- * });
- *
- * assert.deepStrictEqual(mut_valueHistory, ['hello']);
- *
- * input.value = 'world';
- *
- * assert.deepStrictEqual(mut_valueHistory, ['hello', 'world']);
- *
- * dispose(); // stop tracking the signal
- * ```
- */
-const fromSignal = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-sig) => {
-    const src = source(sig.value);
-    const dispose = effect(() => {
-        src.next(sig.value);
-    });
-    return [src, dispose];
+const fromSignal = (sig) => {
+  const src = source(sig.value);
+  const dispose = effect(() => {
+    src.next(sig.value);
+  });
+  return [src, dispose];
 };
 
 export { fromSignal };

package/dist/from-signal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-signal.mjs","sources":["../src/from-signal.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AACI,MAAM,UAAU,GAAG;AACxB;AACA,GAAkC,KAIhC;IACF,MAAM,GAAG,GAAG,MAAM,CAAI,GAAG,CAAC,KAAK,CAAC;AAEhC,IAAA,MAAM,OAAO,GAAG,MAAM,CAAC,MAAK;AAC1B,QAAA,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;AACrB,IAAA,CAAC,CAAC;AAEF,IAAA,OAAO,CAAC,GAAG,EAAE,OAAO,CAAU;AAChC;;;;"}
+{"version":3,"file":"from-signal.mjs","sources":["../src/from-signal.mts"],"sourcesContent":["import { effect, type ReadonlySignal, type Signal } from '@preact/signals';\nimport { source, type InitializedSourceObservable } from 'synstate';\n\n/**\n * Converts a Preact `Signal` (or `ReadonlySignal`) into a synstate\n * `InitializedSourceObservable`.\n *\n * This allows applying synstate's rich operator chain (e.g. `map`, `filter`,\n * `debounce`, `switchMap`) to values originating from Preact Signals.\n *\n * The bridge uses `effect()` from `@preact/signals` to track signal changes\n * and propagate them to the observable.\n *\n * @returns A tuple of `[observable, dispose]`.\n *   - `observable` — an `InitializedSourceObservable` that mirrors the signal.\n *   - `dispose` — a function to stop tracking the signal. Call this when the\n *     bridge is no longer needed to avoid memory leaks.\n *\n * @example\n * ```ts\n * const input = signal('hello');\n *\n * const [input$, dispose] = fromSignal(input);\n *\n * const mut_valueHistory: string[] = [];\n *\n * input$.subscribe((value) => {\n *   mut_valueHistory.push(value);\n * });\n *\n * assert.deepStrictEqual(mut_valueHistory, ['hello']);\n *\n * input.value = 'world';\n *\n * assert.deepStrictEqual(mut_valueHistory, ['hello', 'world']);\n *\n * dispose(); // stop tracking the signal\n * ```\n */\nexport const fromSignal = <A,>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  sig: ReadonlySignal<A> | Signal<A>,\n): readonly [\n  observable: InitializedSourceObservable<A>,\n  dispose: () => void,\n] => {\n  const src = source<A>(sig.value);\n\n  const dispose = effect(() => {\n    src.next(sig.value);\n  });\n\n  return [src, dispose] as const;\n};\n"],"names":[],"mappings":";;;AAuCO,MAAM,UAAA,GAAa,CAExB,GAAA,KAIG;AACH,EAAA,MAAM,GAAA,GAAM,MAAA,CAAU,GAAA,CAAI,KAAK,CAAA;AAE/B,EAAA,MAAM,OAAA,GAAU,OAAO,MAAM;AAC3B,IAAA,GAAA,CAAI,IAAA,CAAK,IAAI,KAAK,CAAA;AAAA,EACpB,CAAC,CAAA;AAED,EAAA,OAAO,CAAC,KAAK,OAAO,CAAA;AACtB;;;;"}

package/dist/to-signal.mjs

@@ -2,13 +2,12 @@ import { signal } from '@preact/signals';
 import { Optional } from 'ts-data-forge';
 
 function toSignal(observable$, fallback) {
-    const initialValue = Optional.unwrapOr(observable$.getSnapshot(), fallback);
-    const sig = signal(initialValue);
-    observable$.subscribe((value) => {
-        // eslint-disable-next-line functional/immutable-data
-        sig.value = value;
-    });
-    return sig;
+  const initialValue = Optional.unwrapOr(observable$.getSnapshot(), fallback);
+  const sig = signal(initialValue);
+  observable$.subscribe((value) => {
+    sig.value = value;
+  });
+  return sig;
 }
 
 export { toSignal };

package/dist/to-signal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"to-signal.mjs","sources":["../src/to-signal.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAqDM,SAAU,QAAQ,CACtB,WAA0B,EAC1B,QAAY,EAAA;AAEZ,IAAA,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,WAAW,EAAE,EAAE,QAAQ,CAAC;AAE3E,IAAA,MAAM,GAAG,GAAG,MAAM,CAAoB,YAAY,CAAC;AAEnD,IAAA,WAAW,CAAC,SAAS,CAAC,CAAC,KAAK,KAAI;;AAE9B,QAAA,GAAG,CAAC,KAAK,GAAG,KAAK;AACnB,IAAA,CAAC,CAAC;AAEF,IAAA,OAAO,GAAG;AACZ;;;;"}
+{"version":3,"file":"to-signal.mjs","sources":["../src/to-signal.mts"],"sourcesContent":["import { signal, type ReadonlySignal } from '@preact/signals';\nimport { type InitializedObservable, type Observable } from 'synstate';\nimport { Optional } from 'ts-data-forge';\n\n/**\n * Converts a synstate `InitializedObservable` into a Preact `ReadonlySignal`.\n *\n * The signal automatically stays in sync with the observable. Since the\n * observable has an initial value, the returned signal is guaranteed to hold a\n * value of type `A`.\n *\n * The subscription lives for the lifetime of the observable (until it\n * completes).\n *\n * @example\n * ```ts\n * const count$ = source<number>(0);\n *\n * const countSignal = toSignal(count$);\n *\n * assert.strictEqual(countSignal.value, 0);\n *\n * count$.next(1);\n *\n * assert.strictEqual(countSignal.value, 1);\n *\n * count$.next(42);\n *\n * assert.strictEqual(countSignal.value, 42);\n * ```\n */\nexport function toSignal<A>(\n  observable$: InitializedObservable<A>,\n): ReadonlySignal<A>;\n\n/**\n * Converts a synstate `Observable` (without guaranteed initial value) into a\n * Preact `ReadonlySignal`. The signal value may be `undefined` until the\n * observable emits.\n */\nexport function toSignal<A>(\n  observable$: Observable<A>,\n): ReadonlySignal<A | undefined>;\n\n/**\n * Converts a synstate `Observable` into a Preact `ReadonlySignal` with a\n * fallback value used when the observable has not yet emitted.\n */\nexport function toSignal<A, B = A>(\n  observable$: Observable<A>,\n  fallback: B,\n): ReadonlySignal<A | B>;\n\nexport function toSignal<A, B = A>(\n  observable$: Observable<A>,\n  fallback?: B,\n): ReadonlySignal<A | B | undefined> {\n  const initialValue = Optional.unwrapOr(observable$.getSnapshot(), fallback);\n\n  const sig = signal<A | B | undefined>(initialValue);\n\n  observable$.subscribe((value) => {\n    // eslint-disable-next-line functional/immutable-data\n    sig.value = value;\n  });\n\n  return sig;\n}\n"],"names":[],"mappings":";;;AAqDO,SAAS,QAAA,CACd,aACA,QAAA,EACmC;AACnC,EAAA,MAAM,eAAe,QAAA,CAAS,QAAA,CAAS,WAAA,CAAY,WAAA,IAAe,QAAQ,CAAA;AAE1E,EAAA,MAAM,GAAA,GAAM,OAA0B,YAAY,CAAA;AAElD,EAAA,WAAA,CAAY,SAAA,CAAU,CAAC,KAAA,KAAU;AAE/B,IAAA,GAAA,CAAI,KAAA,GAAQ,KAAA;AAAA,EACd,CAAC,CAAA;AAED,EAAA,OAAO,GAAA;AACT;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate-preact-signals",
-  "version": "0.2.2",
+  "version": "1.0.0",
   "description": "Preact Signals integration for SynState - bridge between synstate observables and @preact/signals",
   "repository": {
     "type": "git",
@@ -27,15 +27,15 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^6.9.6",
-    "ts-type-forge": "^3.1.0",
-    "synstate": "1.0.2"
+    "ts-data-forge": "^14.2.0",
+    "ts-type-forge": "^9.2.0",
+    "synstate": "2.0.0"
   },
   "devDependencies": {
-    "@preact/signals": "2.9.0",
+    "@preact/signals": "2.10.1",
     "@types/argparse": "2.0.17",
-    "argparse": "2.0.1",
-    "preact": "10.29.1"
+    "argparse": "3.0.0",
+    "preact": "10.29.8"
   },
   "peerDependencies": {
     "@preact/signals": ">=1.0.0",
@@ -65,10 +65,9 @@
     "test:cov:ui": "vite preview --outDir ./coverage",
     "test:ui": "pnpm run z:vitest:node --ui",
     "testw": "pnpm run z:vitest:node watch",
-    "tsc": "tsc --noEmit",
-    "tscw": "tsc --noEmit --watch",
-    "type-check": "tsc --noEmit",
-    "update-packages": "pnpm update --latest",
+    "tsc": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "tscw": "node ../../node_modules/typescript-native/bin/tsc --noEmit --watch",
+    "type-check": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
     "z:prettier": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --ignore-path ../../.gitignore --ignore-unknown --no-error-on-unmatched-pattern --write",
     "z:vitest": "vitest --config ./configs/vitest.config.mts",
     "z:vitest:node": "pnpm run z:vitest --project='Node.js'"

package/src/create-boolean-state.mts

@@ -34,7 +34,7 @@ export const createBooleanState = (
   initialState: boolean,
 ): readonly [
   signal: ReadonlySignal<boolean>,
-  Readonly<{
+  utils: Readonly<{
     state: InitializedObservable<boolean>;
     setTrue: () => void;
     setFalse: () => void;

package/src/create-reducer.mts

@@ -43,7 +43,7 @@ export const createReducer = <S, A>(
 ): readonly [
   signal: ReadonlySignal<S>,
   dispatch: (action: A) => S,
-  Readonly<{
+  utils: Readonly<{
     state: InitializedObservable<S>;
     getSnapshot: () => S;
     initialState: S;

package/src/create-state.mts

@@ -45,7 +45,7 @@ export const createState = <S,>(
 ): readonly [
   signal: ReadonlySignal<S>,
   setState: (v: S) => S,
-  Readonly<{
+  utils: Readonly<{
     state: InitializedObservable<S>;
     updateState: (updateFn: (prev: S) => S) => S;
     resetState: () => S;