synstate-preact-signals 2.0.0 → 2.0.2

package/dist/create-boolean-state.mjs

@@ -1,35 +1,46 @@
-import { createBooleanState as createBooleanState$1 } from 'synstate';
+import { createBooleanState as createBooleanStateBase, } from 'synstate';
 import { toSignal } from './to-signal.mjs';
 
-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
-    }
-  ];
-};
 
-export { createBooleanState };
-//# sourceMappingURL=create-boolean-state.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const createBooleanState = (initialState) => {
+    const [state, { setTrue, setFalse, setState, toggle, updateState, resetState, getSnapshot, },] = createBooleanStateBase(initialState);
+    const sig = toSignal(state);
+    return [
+        sig,
+        {
+            state,
+            setTrue,
+            setFalse,
+            setState,
+            toggle,
+            updateState,
+            resetState,
+            getSnapshot,
+            initialState,
+        },
+    ];
+};
+//# sourceMappingURL=create-boolean-state.mjs.map

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

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"create-boolean-state.mjs","sourceRoot":"","sources":["../src/create-boolean-state.mts"],"names":[],"mappings":"AACA,OAAO,EAEL,kBAAkB,IAAI,sBAAsB,GAC7C,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,YAAqB,EAcrB,EAAE;IACF,MAAM,CACJ,KAAK,EACL,EACE,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,WAAW,EACX,UAAU,EACV,WAAW,GACZ,EACF,GAAG,sBAAsB,CAAC,YAAY,CAAC,CAAC;IAEzC,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE5B,OAAO;QACL,GAAG;QACH;YACE,KAAK;YACL,OAAO;YACP,QAAQ;YACR,QAAQ;YACR,MAAM;YACN,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;SACb;KACO,CAAC;AACb,CAAC,CAAC"}

package/dist/create-reducer.mjs

@@ -1,14 +1,39 @@
-import { createReducer as createReducer$1 } from 'synstate';
+import { createReducer as createReducerBase, } from 'synstate';
 import { toSignal } from './to-signal.mjs';
 
-const createReducer = (reducer, initialState) => {
-  const [state, dispatch, { getSnapshot }] = createReducer$1(
-    reducer,
-    initialState
-  );
-  const sig = toSignal(state);
-  return [sig, dispatch, { state, getSnapshot, initialState }];
-};
 
-export { createReducer };
-//# sourceMappingURL=create-reducer.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const createReducer = (reducer, initialState) => {
+    const [state, dispatch, { getSnapshot }] = createReducerBase(reducer, initialState);
+    const sig = toSignal(state);
+    return [sig, dispatch, { state, getSnapshot, initialState }];
+};
+//# sourceMappingURL=create-reducer.mjs.map

package/dist/create-reducer.mjs.map

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"create-reducer.mjs","sourceRoot":"","sources":["../src/create-reducer.mts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,IAAI,iBAAiB,GAEnC,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,OAAsB,EACtB,YAAe,EASf,EAAE;IACF,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,CAAC,GAAG,iBAAiB,CAC1D,OAAO,EACP,YAAY,CACb,CAAC;IAEF,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE5B,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC,CAAC;AAC/D,CAAC,CAAC"}

package/dist/create-state.mjs

@@ -1,21 +1,53 @@
-import { createState as createState$1 } from 'synstate';
+import { createState as createStateBase, } from 'synstate';
 import { toSignal } from './to-signal.mjs';
 
-const createState = (initialState) => {
-  const [state, setState, { updateState, resetState, getSnapshot }] = createState$1(initialState);
-  const sig = toSignal(state);
-  return [
-    sig,
-    setState,
-    {
-      state,
-      updateState,
-      resetState,
-      getSnapshot,
-      initialState
-    }
-  ];
-};
 
-export { createState };
-//# sourceMappingURL=create-state.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const createState = (initialState) => {
+    const [state, setState, { updateState, resetState, getSnapshot }] = createStateBase(initialState);
+    const sig = toSignal(state);
+    return [
+        sig,
+        setState,
+        {
+            state,
+            updateState,
+            resetState,
+            getSnapshot,
+            initialState,
+        },
+    ];
+};
+//# sourceMappingURL=create-state.mjs.map

package/dist/create-state.mjs.map

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"create-state.mjs","sourceRoot":"","sources":["../src/create-state.mts"],"names":[],"mappings":"AACA,OAAO,EACL,WAAW,IAAI,eAAe,GAE/B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,YAAe,EAWf,EAAE;IACF,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,GAC/D,eAAe,CAAC,YAAY,CAAC,CAAC;IAEhC,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE5B,OAAO;QACL,GAAG;QACH,QAAQ;QACR;YACE,KAAK;YACL,WAAW;YACX,UAAU;YACV,WAAW;YACX,YAAY;SACb;KACO,CAAC;AACb,CAAC,CAAC"}

package/dist/from-signal.mjs

@@ -1,13 +1,48 @@
 import { effect } from '@preact/signals';
 import { source } from 'synstate';
 
-const fromSignal = (sig) => {
-  const src = source(sig.value);
-  const dispose = effect(() => {
-    src.next(sig.value);
-  });
-  return [src, dispose];
-};
 
-export { fromSignal };
-//# sourceMappingURL=from-signal.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const fromSignal = (
+
+sig) => {
+    const src = source(sig.value);
+    const dispose = effect(() => {
+        src.next(sig.value);
+    });
+    return [src, dispose];
+};
+//# sourceMappingURL=from-signal.mjs.map

package/dist/from-signal.mjs.map

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"from-signal.mjs","sourceRoot":"","sources":["../src/from-signal.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAoC,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAoC,MAAM,UAAU,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;AACxB,8EAA8E;AAC9E,GAAkC,EAIlC,EAAE;IACF,MAAM,GAAG,GAAG,MAAM,CAAI,GAAG,CAAC,KAAK,CAAC,CAAC;IAEjC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,EAAE;QAC1B,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC,CAAC,CAAC;IAEH,OAAO,CAAC,GAAG,EAAE,OAAO,CAAU,CAAC;AACjC,CAAC,CAAC"}

package/dist/index.mjs

@@ -1,7 +1,7 @@
-export { createBooleanState } from './create-boolean-state.mjs';
-export { createReducer } from './create-reducer.mjs';
-export { createState } from './create-state.mjs';
-export { fromSignal } from './from-signal.mjs';
-export { attachIndex, audit, collectToArray, combine, combineLatest, counter, createEventEmitter, createValueEmitter, debounce, distinctUntilChanged, filter, flatMap, fromAbortablePromise, fromPromise, fromSubscribable, getKey, isChildObservable, isManagerObservable, isRootObservable, just, map, mapOptional, mapResultErr, mapResultOk, mapTo, merge, mergeMap, pairwise, pluck, scan, skip, skipIfNoChange, skipUntil, skipWhile, source, switchMap, take, takeUntil, takeWhile, throttle, timer, unwrapOptional, unwrapResultErr, unwrapResultOk, withBuffered, withBufferedFrom, withCurrentValueFrom, withIndex, withInitialValue, withLatestFrom, zip } from 'synstate';
-export { toSignal } from './to-signal.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './create-boolean-state.mjs';
+export * from './create-reducer.mjs';
+export * from './create-state.mjs';
+export * from './from-signal.mjs';
+export * from './synstate.mjs';
+export * from './to-signal.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC"}

package/dist/synstate.mjs

@@ -1,2 +1,2 @@
-export { attachIndex, audit, collectToArray, combine, combineLatest, counter, createEventEmitter, createValueEmitter, debounce, distinctUntilChanged, filter, flatMap, fromAbortablePromise, fromPromise, fromSubscribable, getKey, isChildObservable, isManagerObservable, isRootObservable, just, map, mapOptional, mapResultErr, mapResultOk, mapTo, merge, mergeMap, pairwise, pluck, scan, skip, skipIfNoChange, skipUntil, skipWhile, source, switchMap, take, takeUntil, takeWhile, throttle, timer, unwrapOptional, unwrapResultErr, unwrapResultOk, withBuffered, withBufferedFrom, withCurrentValueFrom, withIndex, withInitialValue, withLatestFrom, zip } from 'synstate';
-//# sourceMappingURL=synstate.mjs.map
+export { attachIndex, audit, collectToArray, combine, combineLatest, counter, createEventEmitter, createValueEmitter, debounce, distinctUntilChanged, filter, flatMap, fromAbortablePromise, fromPromise, fromSubscribable, getKey, isChildObservable, isManagerObservable, isRootObservable, just, map, mapOptional, mapResultErr, mapResultOk, mapTo, merge, mergeMap, pairwise, pluck, scan, skip, skipIfNoChange, skipUntil, skipWhile, source, switchMap, take, takeUntil, takeWhile, throttle, timer, unwrapOptional, unwrapResultErr, unwrapResultOk, withBuffered, withBufferedFrom, withCurrentValueFrom, withIndex, withInitialValue, withLatestFrom, zip, } from 'synstate';
+//# sourceMappingURL=synstate.mjs.map

package/dist/synstate.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"synstate.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"synstate.mjs","sourceRoot":"","sources":["../src/synstate.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,EACL,cAAc,EACd,OAAO,EACP,aAAa,EACb,OAAO,EACP,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,oBAAoB,EACpB,MAAM,EACN,OAAO,EACP,oBAAoB,EACpB,WAAW,EACX,gBAAgB,EAChB,MAAM,EACN,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,IAAI,EACJ,GAAG,EACH,WAAW,EACX,YAAY,EACZ,WAAW,EACX,KAAK,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,cAAc,EACd,SAAS,EACT,SAAS,EACT,MAAM,EACN,SAAS,EACT,IAAI,EACJ,SAAS,EACT,SAAS,EACT,QAAQ,EACR,KAAK,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,GAAG,GACJ,MAAM,UAAU,CAAC"}

package/dist/to-signal.mjs

@@ -1,14 +1,12 @@
 import { signal } from '@preact/signals';
 import { Optional } from 'ts-data-forge';
+export function toSignal(observable$, fallback) {
+    const initialValue = Optional.unwrapOr(observable$.getSnapshot(), fallback);
+    const sig = signal(initialValue);
+    observable$.subscribe((value) => {
 
-function toSignal(observable$, fallback) {
-  const initialValue = Optional.unwrapOr(observable$.getSnapshot(), fallback);
-  const sig = signal(initialValue);
-  observable$.subscribe((value) => {
-    sig.value = value;
-  });
-  return sig;
+        sig.value = value;
+    });
+    return sig;
 }
-
-export { toSignal };
-//# sourceMappingURL=to-signal.mjs.map
+//# sourceMappingURL=to-signal.mjs.map

package/dist/to-signal.mjs.map

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"to-signal.mjs","sourceRoot":"","sources":["../src/to-signal.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAuB,MAAM,iBAAiB,CAAC;AAE9D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAmDzC,MAAM,UAAU,QAAQ,CACtB,WAA0B,EAC1B,QAAY;IAEZ,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,WAAW,EAAE,EAAE,QAAQ,CAAC,CAAC;IAE5E,MAAM,GAAG,GAAG,MAAM,CAAoB,YAAY,CAAC,CAAC;IAEpD,WAAW,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;QAC9B,qDAAqD;QACrD,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,OAAO,GAAG,CAAC;AACb,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate-preact-signals",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Preact Signals integration for SynState - bridge between synstate observables and @preact/signals",
   "repository": {
     "type": "git",
@@ -28,24 +28,23 @@
     "LICENSE"
   ],
   "dependencies": {
-    "synstate": "3.0.0",
-    "ts-data-forge": "^14.5.0",
+    "synstate": "3.0.2",
+    "ts-data-forge": "^14.7.0",
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
     "@preact/signals": "2.11.1",
     "@vitest/browser-playwright": "4.1.11",
-    "eslint-config-typed": "5.10.0",
-    "eslint-plugin-ts-data-forge": "0.5.1",
-    "eslint-plugin-ts-fortress": "1.0.5",
-    "eslint-plugin-ts-type-forge": "0.7.1",
+    "eslint-config-typed": "5.11.6",
+    "eslint-plugin-ts-data-forge": "0.7.3",
+    "eslint-plugin-ts-fortress": "1.2.2",
+    "eslint-plugin-ts-type-forge": "0.8.3",
     "playwright": "1.62.1",
     "preact": "10.29.8",
     "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
-    "rollup": "4.62.4",
-    "ts-repo-utils": "10.3.2"
+    "ts-repo-utils": "10.6.1"
   },
   "peerDependencies": {
     "@preact/signals": ">=1.0.0",