synstate 3.0.3 → 3.0.5

package/src/core/base/circular-dependency.test.mts

@@ -1,4 +1,3 @@
-/* eslint-disable functional/immutable-data */
 import { Optional } from 'ts-data-forge';
 import { combine, merge } from '../combine/index.mjs';
 import { source } from '../create/index.mjs';
@@ -18,7 +17,7 @@ describe('circular dependency detection', () => {
         () => ({}),
       );
 
-      const childA = createSyncChildObservable(
+      const mut_childA = createSyncChildObservable(
         {
           parents: [root],
           initialValue: Optional.some(0),
@@ -28,14 +27,14 @@ describe('circular dependency detection', () => {
 
       const childB = createSyncChildObservable(
         {
-          parents: [childA],
+          parents: [mut_childA],
           initialValue: Optional.some(0),
         },
         createTryUpdateNotImplemented,
       );
 
-      // Mutate childA.parents to create a cycle: childA -> childB -> childA
-      Object.defineProperty(childA, 'parents', {
+      // Mutate mut_childA.parents to create a cycle: mut_childA -> childB -> mut_childA
+      Object.defineProperty(mut_childA, 'parents', {
         value: [childB],
         writable: false,
         configurable: true,
@@ -44,7 +43,7 @@ describe('circular dependency detection', () => {
       expect(() => {
         createSyncChildObservable(
           {
-            parents: [childA],
+            parents: [mut_childA],
             initialValue: Optional.some(0),
           },
           createTryUpdateNotImplemented,
@@ -60,7 +59,7 @@ describe('circular dependency detection', () => {
         () => ({}),
       );
 
-      const childA = createAsyncChildObservable(
+      const mut_childA = createAsyncChildObservable(
         {
           parents: [root],
           initialValue: Optional.some(0),
@@ -70,14 +69,14 @@ describe('circular dependency detection', () => {
 
       const childB = createSyncChildObservable(
         {
-          parents: [childA],
+          parents: [mut_childA],
           initialValue: Optional.some(0),
         },
         createTryUpdateNotImplemented,
       );
 
-      // Create cycle: childA -> childB -> childA
-      Object.defineProperty(childA, 'parents', {
+      // Create cycle: mut_childA -> childB -> mut_childA
+      Object.defineProperty(mut_childA, 'parents', {
         value: [childB],
         writable: false,
         configurable: true,
@@ -86,7 +85,7 @@ describe('circular dependency detection', () => {
       expect(() => {
         createAsyncChildObservable(
           {
-            parents: [childA],
+            parents: [mut_childA],
             initialValue: Optional.some(0),
           },
           createTryUpdateNotImplemented,
@@ -102,7 +101,7 @@ describe('circular dependency detection', () => {
         () => ({}),
       );
 
-      const childA = createSyncChildObservable(
+      const mut_childA = createSyncChildObservable(
         {
           parents: [root],
           initialValue: Optional.some(0),
@@ -112,7 +111,7 @@ describe('circular dependency detection', () => {
 
       const childB = createSyncChildObservable(
         {
-          parents: [childA],
+          parents: [mut_childA],
           initialValue: Optional.some(0),
         },
         createTryUpdateNotImplemented,
@@ -126,8 +125,8 @@ describe('circular dependency detection', () => {
         createTryUpdateNotImplemented,
       );
 
-      // Create cycle: childA -> childC -> childB -> childA
-      Object.defineProperty(childA, 'parents', {
+      // Create cycle: mut_childA -> childC -> childB -> mut_childA
+      Object.defineProperty(mut_childA, 'parents', {
         value: [childC],
         writable: false,
         configurable: true,
@@ -136,7 +135,7 @@ describe('circular dependency detection', () => {
       expect(() => {
         createSyncChildObservable(
           {
-            parents: [childA],
+            parents: [mut_childA],
             initialValue: Optional.some(0),
           },
           createTryUpdateNotImplemented,
@@ -152,7 +151,7 @@ describe('circular dependency detection', () => {
         () => ({}),
       );
 
-      const childA = createSyncChildObservable(
+      const mut_childA = createSyncChildObservable(
         {
           parents: [root],
           initialValue: Optional.some(0),
@@ -160,9 +159,9 @@ describe('circular dependency detection', () => {
         createTryUpdateNotImplemented,
       );
 
-      // Make childA's parents reference childA itself (self-loop)
-      Object.defineProperty(childA, 'parents', {
-        value: [childA],
+      // Make mut_childA's parents reference mut_childA itself (self-loop)
+      Object.defineProperty(mut_childA, 'parents', {
+        value: [mut_childA],
         writable: false,
         configurable: true,
       });
@@ -170,7 +169,7 @@ describe('circular dependency detection', () => {
       expect(() => {
         createSyncChildObservable(
           {
-            parents: [childA],
+            parents: [mut_childA],
             initialValue: Optional.some(0),
           },
           createTryUpdateNotImplemented,

package/src/core/base/create-child-observable.mts

@@ -160,6 +160,7 @@ export const createInitializedSyncChildObservable = <
   return (
     // `getSnapshot` always returns `Some` here: `initialValue` is a `Some` and
     // `setNext` only ever stores a `Some`.
+    // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
     // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     observable as InitializedSyncChildObservable<A, P>
   );
@@ -240,9 +241,13 @@ const hasCircularDependencyFrom = (
   mut_visited: MutableSet<ObservableId>,
   mut_inPath: MutableSet<ObservableId>,
 ): boolean => {
-  if (mut_inPath.has(node.id)) return true;
+  if (mut_inPath.has(node.id)) {
+    return true;
+  }
 
-  if (mut_visited.has(node.id)) return false;
+  if (mut_visited.has(node.id)) {
+    return false;
+  }
 
   mut_visited.add(node.id);
 
@@ -304,7 +309,9 @@ const registerChild = <A,>(
   while (Arr.isNonEmpty(mut_rest)) {
     const p = mut_rest.pop();
 
-    if (p === undefined) break;
+    if (p === undefined) {
+      break;
+    }
 
     if (isManagerObservable(p)) {
       p.addDescendant(child);

package/src/core/base/create-observable-base.mts

@@ -130,7 +130,9 @@ export const createObservableBaseHandle = <A,>(
   };
 
   const completeBase = (): void => {
-    if (mut_isCompleted) return; // terminate only once
+    if (mut_isCompleted) {
+      return; // terminate only once
+    }
 
     // change state
     mut_isCompleted = true;
@@ -220,7 +222,9 @@ export const createManagerObservableParts = <A,>(
   const mut_descendantsIdSet: MutableSet<ObservableId> = new Set();
 
   const addDescendant = <B,>(child: ChildObservable<B>): void => {
-    if (mut_descendantsIdSet.has(child.id)) return;
+    if (mut_descendantsIdSet.has(child.id)) {
+      return;
+    }
 
     mut_descendantsIdSet.add(child.id);
 
@@ -270,7 +274,7 @@ type AssembleObservableArgs<
   Extra extends ReadonlyRecord<string, unknown>,
 > = Readonly<{
   kind: Kind;
-  depth: number;
+  depth: Kind extends 'root' ? 0 : number;
   handle: ObservableBaseHandle<A>;
   tryUpdate: (updateToken: UpdateToken) => void;
   tryComplete: () => void;
@@ -305,7 +309,10 @@ export const assembleObservable = <
   extra,
 }: AssembleObservableArgs<A, Kind, Extra>): Extra &
   ObservableBase<A> &
-  Readonly<{ kind: Kind }> => {
+  Readonly<{
+    kind: Kind;
+    depth: AssembleObservableArgs<A, Kind, Extra>['depth'];
+  }> => {
   function pipe<B>(
     operator: WithInitialValueOperator<A, B>,
   ): InitializedObservable<B>;
@@ -314,6 +321,7 @@ export const assembleObservable = <
 
   function pipe<B>(operator: Operator<A, B>): Observable<B> {
     return operator(
+      // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
       // eslint-disable-next-line total-functions/no-unsafe-type-assertion
       observable as unknown as InitializedObservable<A>,
     );

package/src/core/base/create-root-observable.mts

@@ -47,6 +47,8 @@ export type RootObservableConfig<A> = Readonly<{
  */
 export const createRootObservable = <
   A,
+  // The default is deliberately empty: a root leaf without `init` adds no members.
+  // eslint-disable-next-line @typescript-eslint/no-generated-empty-object-type
   Extension extends ReadonlyRecord<string, unknown> = ReadonlyRecord<
     never,
     never

package/src/core/combine/combine.mts

@@ -74,6 +74,7 @@ import {
 export const combine = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): CombineObservableRefined<OS> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   createCombineObservable(parents) as unknown as CombineObservableRefined<OS>;
 
@@ -113,7 +114,9 @@ const createCombineObservable = <const A extends NonEmptyUnknownList>(
     },
     ({ setNext }) =>
       (updateToken) => {
-        if (parents.every((o) => o.updateToken !== updateToken)) return; // all parents are skipped
+        if (parents.every((o) => o.updateToken !== updateToken)) {
+          return; // all parents are skipped
+        }
 
         // Same shape-preserving chain as the initial value: `Arr.map` (not the
         // native one, which drops the tuple shape) into the uniform
@@ -123,14 +126,16 @@ const createCombineObservable = <const A extends NonEmptyUnknownList>(
           (a) => a.getSnapshot(),
         );
 
-        if (Arr.every(parentValues, Optional.isSome)) {
-          const nextValue: Readonly<{ [K in keyof A]: A[K] }> = Arr.map(
-            parentValues,
-            (a) => a.value,
-          );
-
-          setNext(nextValue, updateToken);
+        if (!Arr.every(parentValues, Optional.isSome)) {
+          return;
         }
+
+        const nextValue: Readonly<{ [K in keyof A]: A[K] }> = Arr.map(
+          parentValues,
+          (a) => a.value,
+        );
+
+        setNext(nextValue, updateToken);
       },
   );
 };

package/src/core/combine/merge.mts

@@ -65,6 +65,7 @@ import {
 export const merge = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): MergeObservableRefined<OS> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   createMergeObservable(parents) as MergeObservableRefined<OS>;
 
@@ -83,9 +84,12 @@ const createMergeObservable = <const P extends NonEmptyUnknownList>(
             o.updateToken === updateToken && Optional.isSome(o.getSnapshot()),
         );
 
-        if (parentToUse === undefined) return;
+        if (parentToUse === undefined) {
+          return;
+        }
 
         const nextValue =
+          // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
           Optional.unwrap(parentToUse.getSnapshot()) as ArrayElement<P>;
 

package/src/core/combine/zip.mts

@@ -67,6 +67,7 @@ import {
 export const zip = <const OS extends NonEmptyTuple<Observable<unknown>>>(
   parents: OS,
 ): ZipObservableRefined<OS> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   createZipObservable(parents) as unknown as ZipObservableRefined<OS>;
 
@@ -110,15 +111,18 @@ const createZipObservable = <const A extends NonEmptyUnknownList>(
           }
         }
 
-        if (queues.every((list) => !list.isEmpty)) {
-          const nextValue =
-            // `Arr.map` has a single result element type, so it reports
-            // `A[number] | undefined` per position rather than `A[P]`.
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            Arr.map(queues, (q) => Optional.unwrap(q.dequeue())) as A;
-
-          setNext(nextValue, updateToken);
+        if (queues.some((list) => list.isEmpty)) {
+          return;
         }
+
+        const nextValue =
+          // `Arr.map` has a single result element type, so it reports
+          // `A[number] | undefined` per position rather than `A[P]`.
+          // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          Arr.map(queues, (q) => Optional.unwrap(q.dequeue())) as A;
+
+        setNext(nextValue, updateToken);
       },
   );
 };

package/src/core/create/from-abortable-promise.mts

@@ -70,6 +70,7 @@ import { type FromPromiseObservable } from '../types/index.mjs';
  * ```
  */
 export const fromAbortablePromise = <A, E = unknown>(
+  // @sumi-expect-error readonly/require-readonly-parameter
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   factory: (signal: AbortSignal) => Promise<A>,
 ): FromPromiseObservable<A, E> => {
@@ -87,12 +88,16 @@ export const fromAbortablePromise = <A, E = unknown>(
 
       promise
         .then((value) => {
-          if (isCompleted()) return;
+          if (isCompleted()) {
+            return;
+          }
 
           startUpdate(Result.ok(value));
         })
         .catch((error: unknown) => {
-          if (isCompleted()) return;
+          if (isCompleted()) {
+            return;
+          }
 
           // Silently ignore AbortError — it means the observable was
           // intentionally completed (e.g., by switchMap).
@@ -102,6 +107,7 @@ export const fromAbortablePromise = <A, E = unknown>(
 
           startUpdate(
             Result.err(
+              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
               // eslint-disable-next-line total-functions/no-unsafe-type-assertion
               error as E,
             ),

package/src/core/create/from-promise.mts

@@ -57,15 +57,20 @@ export const fromPromise = <A, E = unknown>(
     ({ startUpdate, isCompleted, complete }) => {
       promise
         .then((value) => {
-          if (isCompleted()) return;
+          if (isCompleted()) {
+            return;
+          }
 
           startUpdate(Result.ok(value));
         })
         .catch((error: unknown) => {
-          if (isCompleted()) return;
+          if (isCompleted()) {
+            return;
+          }
 
           startUpdate(
             Result.err(
+              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
               // eslint-disable-next-line total-functions/no-unsafe-type-assertion
               error as E,
             ),

package/src/core/create/from-subscribable.mts

@@ -76,6 +76,7 @@ export const fromSubscribable = <A, E = unknown>(
         (error?: unknown) => {
           startUpdate(
             Result.err(
+              // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
               // eslint-disable-next-line total-functions/no-unsafe-type-assertion
               error as E,
             ),

package/src/core/create/just.mts

@@ -39,6 +39,7 @@ export const just = <const A,>(value: A): InitializedRootObservable<A> => {
 
   obs.complete();
 
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   return obs as InitializedRootObservable<A>;
 };

package/src/core/create/source.mts

@@ -59,7 +59,9 @@ export function source<const A>(...args: readonly A[]): SourceObservable<A> {
     },
     ({ startUpdate, isCompleted }) => ({
       next: (nextValue: A) => {
-        if (isCompleted()) return;
+        if (isCompleted()) {
+          return;
+        }
 
         startUpdate(nextValue);
       },

package/src/core/operators/audit.mts

@@ -104,6 +104,7 @@ import {
 export const audit = <A,>(
   milliSeconds: number,
 ): KeepInitialValueOperator<A, A> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createAuditObservable(
@@ -147,7 +148,9 @@ const createAuditObservable = <A,>(
         mut_timerId = setTimeout(() => {
           const sn = parentObservable.getSnapshot();
 
-          if (Optional.isNone(sn)) return;
+          if (Optional.isNone(sn)) {
+            return;
+          }
 
           startUpdate(sn.value);
 

package/src/core/operators/debounce.mts

@@ -95,6 +95,7 @@ import {
 export const debounce = <A,>(
   milliSeconds: number,
 ): KeepInitialValueOperator<A, A> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createDebounceObservable(
@@ -135,7 +136,9 @@ const createDebounceObservable = <A,>(
 
         // set timer
         mut_timerId = setTimeout(() => {
-          if (Optional.isNone(sn)) return;
+          if (Optional.isNone(sn)) {
+            return;
+          }
 
           startUpdate(sn.value);
         }, milliSeconds);

package/src/core/operators/map.mts

@@ -50,6 +50,7 @@ import { withInitialValue } from './with-initial-value.mjs';
 export const map = <A, B>(
   mapFn: (x: A, index: SafeUint | -1) => B,
 ): KeepInitialValueOperator<A, B> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createMapObservable(parentObservable, mapFn)) as KeepInitialValueOperator<

package/src/core/operators/skip-if-no-change.mts

@@ -70,6 +70,7 @@ import {
 export const skipIfNoChange = <A,>(
   eq: (x: A, y: A) => boolean = (x, y) => Object.is(x, y),
 ): KeepInitialValueOperator<A, A> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createSkipIfNoChangeObservable(

package/src/core/operators/take-until.mts

@@ -57,6 +57,7 @@ import {
 export const takeUntil = <A,>(
   notifier: Observable<unknown>,
 ): KeepInitialValueOperator<A, A> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createTakeUntilObservable(

package/src/core/operators/throttle.mts

@@ -88,6 +88,7 @@ import {
 export const throttle = <A,>(
   milliSeconds: number,
 ): KeepInitialValueOperator<A, A> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createThrottleObservable(

package/src/core/operators/with-buffered-from.mts

@@ -63,6 +63,7 @@ import { maxDepth } from '../utils/index.mjs';
 export const withBufferedFrom = <A, B>(
   observable: Observable<B>,
 ): KeepInitialValueOperator<A, readonly [A, readonly B[]]> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
     createWithBufferedFromObservable(

package/src/core/operators/with-current-value-from.mts

@@ -106,7 +106,9 @@ const createWithCurrentValueFromObservable = <A, B>(
 
         const curr = observable.getSnapshot();
 
-        if (Optional.isNone(curr)) return; // skip update
+        if (Optional.isNone(curr)) {
+          return; // skip update
+        }
 
         setNext([ps.value, curr.value], updateToken);
       },

package/src/core/predefined/operators/unwrap-optional.mts

@@ -46,5 +46,6 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
 export const unwrapOptional = <
   O extends UnknownOptional,
 >(): KeepInitialValueOperator<O, Optional.Unwrap<O> | undefined> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   map(Optional.unwrap as Fn<O, Optional.Unwrap<O> | undefined>);

package/src/core/predefined/operators/unwrap-result-ok.mts

@@ -46,5 +46,6 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
 export const unwrapResultOk = <
   R extends UnknownResult,
 >(): KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   map(Result.unwrapOk as Fn<R, Result.UnwrapOk<R> | undefined>);

package/src/core/types/observable.mts

@@ -23,7 +23,7 @@ type CreateObservableType<A, Kind extends ObservableKind> = Readonly<{
   kind: Kind;
 
   // reactive dependency tree structure
-  depth: ObservableKind extends 'root' ? 0 : number;
+  depth: Kind extends 'root' ? 0 : number;
   addChild: <B>(child: ChildObservable<B>) => void;
 
   // state
@@ -193,6 +193,16 @@ expectType<keyof AsyncChildObservable<unknown>, 'addDescendant'>('>=');
 
 expectType<keyof RootObservable<unknown>, 'addDescendant'>('>=');
 
+expectType<RootObservable<unknown>['depth'], 0>('=');
+
+expectType<InitializedRootObservable<unknown>['depth'], 0>('=');
+
+expectType<SyncChildObservable<unknown>['depth'], number>('=');
+
+expectType<AsyncChildObservable<unknown>['depth'], number>('=');
+
+expectType<ObservableBase<unknown>['depth'], number>('=');
+
 expectType<Unwrap<Wrap<readonly [1, 2, 3]>>, readonly [1, 2, 3]>('=');
 
 expectType<number, ObservableValue<Observable<number>>>('<=');

package/src/core/types/timer.mts

@@ -1,11 +1,2 @@
-/**
- * Timer handle for Node.js / browser compatibility.
- *
- * Defined by what `clearTimeout` accepts rather than by what `setTimeout`
- * returns. The two are not the same type under the strict standard library:
- * `setTimeout` there returns `{} | null`, which `clearTimeout`'s
- * `number | undefined` parameter rejects. Every use of this type here is a
- * handle on its way to `clearTimeout` / `clearInterval`, so the consumer's
- * side is the one that has to fit.
- */
-export type TimerId = NonNullable<Parameters<typeof clearTimeout>[0]>;
+// Timer types for Node.js/Browser compatibility
+export type TimerId = ReturnType<typeof setTimeout>;

package/src/core/utils/id-maker.mts

@@ -8,6 +8,7 @@ function* idMaker<T extends symbol>(): Generator<T, T, T> {
   let mut_i = 0;
 
   while (true) {
+    // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
     // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     yield Symbol(mut_i.toString()) as T;
 

package/src/core/utils/utils.mts

@@ -34,9 +34,13 @@ export const binarySearch = <N extends number>(
   while (mut_left <= mut_right) {
     const curr = sortedArray[mut_mid];
 
-    if (x === curr) break;
+    if (x === curr) {
+      break;
+    }
 
-    if (curr === undefined) break;
+    if (curr === undefined) {
+      break;
+    }
 
     if (curr > x) {
       mut_right = SafeInt.sub(mut_mid, 1);
@@ -47,6 +51,7 @@ export const binarySearch = <N extends number>(
     mut_mid = SafeInt.add(mut_left, halfInt(SafeInt.sub(mut_right, mut_left)));
   }
 
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   return mut_mid as NegativeInt32 | Uint32;
 };