synstate-preact-signals 0.2.0

package/README.md

@@ -0,0 +1,98 @@
+# synstate-preact-signals
+
+[Preact Signals](https://preactjs.com/guide/v10/signals/) integration for [SynState](https://github.com/noshiro-pf/synstate).
+
+Provides a bidirectional bridge between synstate observables and `@preact/signals`, enabling fine-grained DOM updates without component re-renders.
+
+## Installation
+
+```sh
+npm install synstate-preact-signals synstate preact @preact/signals
+```
+
+## API
+
+### `toSignal(observable$)` — Observable to ReadonlySignal
+
+Converts a synstate observable into a Preact `ReadonlySignal`. The signal stays in sync with the observable and can be embedded directly in JSX.
+
+```tsx
+import type * as Preact from 'preact';
+import { createState } from 'synstate';
+import { toSignal } from 'synstate-preact-signals';
+
+const [count$, setCount] = createState(0);
+
+const countSignal = toSignal<number>(count$);
+
+const Counter = (): Preact.JSX.Element => {
+    // No hooks needed — only this text node updates, not the whole component
+    return (
+        <div>
+            <span>{countSignal}</span>
+            <button
+                onClick={() => {
+                    setCount(countSignal.value + 1);
+                }}
+            >
+                {'+1'}
+            </button>
+        </div>
+    );
+};
+```
+
+### `fromSignal(signal)` — Signal to Observable
+
+Converts a Preact Signal into a synstate observable, allowing you to apply synstate's operator chain.
+
+```tsx
+import { signal } from '@preact/signals';
+import { debounce } from 'synstate';
+import { fromSignal } from 'synstate-preact-signals';
+
+const input = signal('');
+
+const [input$, dispose] = fromSignal(input);
+
+const debouncedInput$ = input$.pipe(debounce(300));
+```
+
+### `createState` / `createBooleanState` / `createReducer`
+
+Signal-returning wrappers for synstate's state creation utilities. Instead of returning a hook (like `synstate-preact-hooks`), these return a `ReadonlySignal`.
+
+```tsx
+import type * as Preact from 'preact';
+import { createState } from 'synstate-preact-signals';
+
+const [countSignal, setCount, { updateState, resetState }] = createState(0);
+
+const Counter = (): Preact.JSX.Element => (
+    <div>
+        <span>{countSignal}</span>
+        <button
+            onClick={() => {
+                updateState((n) => n + 1);
+            }}
+        >
+            {'+1'}
+        </button>
+        <button onClick={resetState}>{'Reset'}</button>
+    </div>
+);
+```
+
+## Comparison with `synstate-preact-hooks`
+
+| Feature              | `synstate-preact-hooks`           | `synstate-preact-signals`    |
+| -------------------- | --------------------------------- | ---------------------------- |
+| Preact dep           | `preact`                          | `preact` + `@preact/signals` |
+| Read value           | `useObservableValue(obs$)` (hook) | `toSignal(obs$)` (signal)    |
+| Re-render scope      | Entire component                  | Only affected DOM nodes      |
+| Hooks required       | Yes                               | No                           |
+| Operator integration | Via hooks                         | Via `fromSignal`             |
+
+## License
+
+Apache-2.0

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

@@ -0,0 +1,39 @@
+import { type ReadonlySignal } from '@preact/signals';
+import { type InitializedObservable } from 'synstate';
+/**
+ * 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);
+ * ```
+ */
+export declare const createBooleanState: (initialState: boolean) => readonly [signal: ReadonlySignal<boolean>, Readonly<{
+    state: InitializedObservable<boolean>;
+    setTrue: () => void;
+    setFalse: () => void;
+    setState: (next: boolean) => boolean;
+    toggle: () => boolean;
+    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
+    resetState: () => boolean;
+    getSnapshot: () => boolean;
+    initialState: boolean;
+}>];
+//# sourceMappingURL=create-boolean-state.d.mts.map

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

@@ -0,0 +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"}

package/dist/create-boolean-state.mjs

@@ -0,0 +1,49 @@
+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,
+        },
+    ];
+};
+
+export { createBooleanState };
+//# sourceMappingURL=create-boolean-state.mjs.map

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

@@ -0,0 +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;;;;"}

package/dist/create-reducer.d.mts

@@ -0,0 +1,39 @@
+import { type ReadonlySignal } from '@preact/signals';
+import { type InitializedObservable } from 'synstate';
+/**
+ * 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);
+ * ```
+ */
+export declare const createReducer: <S, A>(reducer: Reducer<S, A>, initialState: S) => readonly [signal: ReadonlySignal<S>, dispatch: (action: A) => S, Readonly<{
+    state: InitializedObservable<S>;
+    getSnapshot: () => S;
+    initialState: S;
+}>];
+//# sourceMappingURL=create-reducer.d.mts.map

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

@@ -0,0 +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;AAGlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/create-reducer.mjs

@@ -0,0 +1,42 @@
+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 }];
+};
+
+export { createReducer };
+//# sourceMappingURL=create-reducer.mjs.map

package/dist/create-reducer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-reducer.mjs","sources":["../src/create-reducer.mts"],"sourcesContent":[null],"names":["createReducerBase"],"mappings":";;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;"}

package/dist/create-state.d.mts

@@ -0,0 +1,45 @@
+import { type ReadonlySignal } from '@preact/signals';
+import { type InitializedObservable } from 'synstate';
+/**
+ * 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);
+ * ```
+ */
+export declare const createState: <S>(initialState: S) => readonly [signal: ReadonlySignal<S>, setState: (v: S) => S, Readonly<{
+    state: InitializedObservable<S>;
+    updateState: (updateFn: (prev: S) => S) => S;
+    resetState: () => S;
+    getSnapshot: () => S;
+    initialState: S;
+}>];
+//# sourceMappingURL=create-state.d.mts.map

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

@@ -0,0 +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"}

package/dist/create-state.mjs

@@ -0,0 +1,56 @@
+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,
+        },
+    ];
+};
+
+export { createState };
+//# sourceMappingURL=create-state.mjs.map

package/dist/create-state.mjs.map

@@ -0,0 +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;;;;"}

package/dist/from-signal.d.mts

@@ -0,0 +1,40 @@
+import { type ReadonlySignal, type Signal } from '@preact/signals';
+import { type InitializedSourceObservable } 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
+ * ```
+ */
+export declare const fromSignal: <A>(sig: ReadonlySignal<A> | Signal<A>) => readonly [observable: InitializedSourceObservable<A>, dispose: () => void];
+//# sourceMappingURL=from-signal.d.mts.map

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

@@ -0,0 +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"}

package/dist/from-signal.mjs

@@ -0,0 +1,51 @@
+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];
+};
+
+export { fromSignal };
+//# sourceMappingURL=from-signal.mjs.map

package/dist/from-signal.mjs.map

@@ -0,0 +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;;;;"}

package/dist/globals.d.mts

@@ -0,0 +1 @@
+/// <reference types="ts-type-forge" />

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+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.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","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/index.mjs

@@ -0,0 +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 { AsyncChildObservableClass, InitializedSyncChildObservableClass, ObservableBaseClass, RootObservableClass, SyncChildObservableClass, 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

package/dist/index.mjs.map

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

package/dist/synstate.d.mts

@@ -0,0 +1,2 @@
+export { AsyncChildObservableClass, InitializedSyncChildObservableClass, ObservableBaseClass, RootObservableClass, SyncChildObservableClass, 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.d.mts.map

package/dist/synstate.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synstate.d.mts","sourceRoot":"","sources":["../src/synstate.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,mCAAmC,EACnC,mBAAmB,EACnB,mBAAmB,EACnB,wBAAwB,EACxB,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/synstate.mjs

@@ -0,0 +1,2 @@
+export { AsyncChildObservableClass, InitializedSyncChildObservableClass, ObservableBaseClass, RootObservableClass, SyncChildObservableClass, 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

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

package/dist/to-signal.d.mts

@@ -0,0 +1,42 @@
+import { type ReadonlySignal } from '@preact/signals';
+import { type InitializedObservable, type Observable } from 'synstate';
+/**
+ * Converts a synstate `InitializedObservable` into a Preact `ReadonlySignal`.
+ *
+ * The signal automatically stays in sync with the observable. Since the
+ * observable has an initial value, the returned signal is guaranteed to hold a
+ * value of type `A`.
+ *
+ * The subscription lives for the lifetime of the observable (until it
+ * completes).
+ *
+ * @example
+ * ```ts
+ * const count$ = source<number>(0);
+ *
+ * const countSignal = toSignal(count$);
+ *
+ * assert.strictEqual(countSignal.value, 0);
+ *
+ * count$.next(1);
+ *
+ * assert.strictEqual(countSignal.value, 1);
+ *
+ * count$.next(42);
+ *
+ * assert.strictEqual(countSignal.value, 42);
+ * ```
+ */
+export declare function toSignal<A>(observable$: InitializedObservable<A>): ReadonlySignal<A>;
+/**
+ * Converts a synstate `Observable` (without guaranteed initial value) into a
+ * Preact `ReadonlySignal`. The signal value may be `undefined` until the
+ * observable emits.
+ */
+export declare function toSignal<A>(observable$: Observable<A>): ReadonlySignal<A | undefined>;
+/**
+ * Converts a synstate `Observable` into a Preact `ReadonlySignal` with a
+ * fallback value used when the observable has not yet emitted.
+ */
+export declare function toSignal<A, B = A>(observable$: Observable<A>, fallback: B): ReadonlySignal<A | B>;
+//# sourceMappingURL=to-signal.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-signal.d.mts","sourceRoot":"","sources":["../src/to-signal.mts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,WAAW,EAAE,qBAAqB,CAAC,CAAC,CAAC,GACpC,cAAc,CAAC,CAAC,CAAC,CAAC;AAErB;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,GACzB,cAAc,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAEjC;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAC/B,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,EAC1B,QAAQ,EAAE,CAAC,GACV,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC"}

package/dist/to-signal.mjs

@@ -0,0 +1,15 @@
+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;
+}
+
+export { toSignal };
+//# sourceMappingURL=to-signal.mjs.map

package/dist/to-signal.mjs.map

@@ -0,0 +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;;;;"}

package/dist/tsconfig.json

@@ -0,0 +1 @@
+{"include":["."]}

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import './globals.d.mts';
+export * from './entry-point.mjs';

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "synstate-preact-signals",
+  "version": "0.2.0",
+  "description": "Preact Signals integration for SynState - bridge between synstate observables and @preact/signals",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noshiro-pf/synstate.git"
+  },
+  "license": "Apache-2.0",
+  "author": "noshiro-pf <noshiro.pf@gmail.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "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": "run-s doc:embed doc:embed:jsdoc",
+    "doc:embed": "tsx ./scripts/cmd/embed-examples.mts",
+    "doc:embed:jsdoc": "tsx ./scripts/cmd/embed-examples-in-jsdoc.mts",
+    "fmt": "format-uncommitted",
+    "fmt:full": "pnpm run z:prettier .",
+    "gen:re-export": "run-s gen:re-export:script fmt",
+    "gen:re-export:script": "tsx ./scripts/cmd/generate-re-export-script.mts",
+    "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",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "pnpm run z:vitest:node run",
+    "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: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",
+    "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'"
+  },
+  "dependencies": {
+    "synstate": "workspace:*",
+    "ts-data-forge": "^6.8.0"
+  },
+  "devDependencies": {
+    "@preact/signals": "^2.8.2",
+    "@types/argparse": "^2.0.17",
+    "argparse": "^2.0.1",
+    "preact": "^10.29.0"
+  },
+  "peerDependencies": {
+    "@preact/signals": ">=1.0.0",
+    "preact": ">=10.0.0"
+  }
+}

package/src/create-boolean-state.mts

@@ -0,0 +1,78 @@
+import { type ReadonlySignal } from '@preact/signals';
+import {
+  type InitializedObservable,
+  createBooleanState as createBooleanStateBase,
+} 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);
+ * ```
+ */
+export const createBooleanState = (
+  initialState: boolean,
+): readonly [
+  signal: ReadonlySignal<boolean>,
+  Readonly<{
+    state: InitializedObservable<boolean>;
+    setTrue: () => void;
+    setFalse: () => void;
+    setState: (next: boolean) => boolean;
+    toggle: () => boolean;
+    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
+    resetState: () => boolean;
+    getSnapshot: () => boolean;
+    initialState: boolean;
+  }>,
+] => {
+  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,
+    },
+  ] as const;
+};

package/src/create-reducer.mts

@@ -0,0 +1,59 @@
+import { type ReadonlySignal } from '@preact/signals';
+import {
+  createReducer as createReducerBase,
+  type InitializedObservable,
+} 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);
+ * ```
+ */
+export const createReducer = <S, A>(
+  reducer: Reducer<S, A>,
+  initialState: S,
+): readonly [
+  signal: ReadonlySignal<S>,
+  dispatch: (action: A) => S,
+  Readonly<{
+    state: InitializedObservable<S>;
+    getSnapshot: () => S;
+    initialState: S;
+  }>,
+] => {
+  const [state, dispatch, { getSnapshot }] = createReducerBase(
+    reducer,
+    initialState,
+  );
+
+  const sig = toSignal(state);
+
+  return [sig, dispatch, { state, getSnapshot, initialState }];
+};

package/src/create-state.mts

@@ -0,0 +1,72 @@
+import { type ReadonlySignal } from '@preact/signals';
+import {
+  createState as createStateBase,
+  type InitializedObservable,
+} 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);
+ * ```
+ */
+export const createState = <S,>(
+  initialState: S,
+): readonly [
+  signal: ReadonlySignal<S>,
+  setState: (v: S) => S,
+  Readonly<{
+    state: InitializedObservable<S>;
+    updateState: (updateFn: (prev: S) => S) => S;
+    resetState: () => S;
+    getSnapshot: () => S;
+    initialState: S;
+  }>,
+] => {
+  const [state, setState, { updateState, resetState, getSnapshot }] =
+    createStateBase(initialState);
+
+  const sig = toSignal(state);
+
+  return [
+    sig,
+    setState,
+    {
+      state,
+      updateState,
+      resetState,
+      getSnapshot,
+      initialState,
+    },
+  ] as const;
+};

package/src/from-signal.mts

@@ -0,0 +1,54 @@
+import { effect, type ReadonlySignal, type Signal } from '@preact/signals';
+import { source, type InitializedSourceObservable } 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
+ * ```
+ */
+export const fromSignal = <A,>(
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sig: ReadonlySignal<A> | Signal<A>,
+): readonly [
+  observable: InitializedSourceObservable<A>,
+  dispose: () => void,
+] => {
+  const src = source<A>(sig.value);
+
+  const dispose = effect(() => {
+    src.next(sig.value);
+  });
+
+  return [src, dispose] as const;
+};

package/src/globals.d.mts

@@ -0,0 +1 @@
+/// <reference types="ts-type-forge" />

package/src/index.mts

@@ -0,0 +1,6 @@
+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';

package/src/synstate.mts

@@ -0,0 +1,58 @@
+export {
+  AsyncChildObservableClass,
+  InitializedSyncChildObservableClass,
+  ObservableBaseClass,
+  RootObservableClass,
+  SyncChildObservableClass,
+  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';

package/src/to-signal.mts

@@ -0,0 +1,68 @@
+import { signal, type ReadonlySignal } from '@preact/signals';
+import { type InitializedObservable, type Observable } from 'synstate';
+import { Optional } from 'ts-data-forge';
+
+/**
+ * Converts a synstate `InitializedObservable` into a Preact `ReadonlySignal`.
+ *
+ * The signal automatically stays in sync with the observable. Since the
+ * observable has an initial value, the returned signal is guaranteed to hold a
+ * value of type `A`.
+ *
+ * The subscription lives for the lifetime of the observable (until it
+ * completes).
+ *
+ * @example
+ * ```ts
+ * const count$ = source<number>(0);
+ *
+ * const countSignal = toSignal(count$);
+ *
+ * assert.strictEqual(countSignal.value, 0);
+ *
+ * count$.next(1);
+ *
+ * assert.strictEqual(countSignal.value, 1);
+ *
+ * count$.next(42);
+ *
+ * assert.strictEqual(countSignal.value, 42);
+ * ```
+ */
+export function toSignal<A>(
+  observable$: InitializedObservable<A>,
+): ReadonlySignal<A>;
+
+/**
+ * Converts a synstate `Observable` (without guaranteed initial value) into a
+ * Preact `ReadonlySignal`. The signal value may be `undefined` until the
+ * observable emits.
+ */
+export function toSignal<A>(
+  observable$: Observable<A>,
+): ReadonlySignal<A | undefined>;
+
+/**
+ * Converts a synstate `Observable` into a Preact `ReadonlySignal` with a
+ * fallback value used when the observable has not yet emitted.
+ */
+export function toSignal<A, B = A>(
+  observable$: Observable<A>,
+  fallback: B,
+): ReadonlySignal<A | B>;
+
+export function toSignal<A, B = A>(
+  observable$: Observable<A>,
+  fallback?: B,
+): ReadonlySignal<A | B | undefined> {
+  const initialValue = Optional.unwrapOr(observable$.getSnapshot(), fallback);
+
+  const sig = signal<A | B | undefined>(initialValue);
+
+  observable$.subscribe((value) => {
+    // eslint-disable-next-line functional/immutable-data
+    sig.value = value;
+  });
+
+  return sig;
+}