synstate 3.0.4 → 3.0.5

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/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;
 };