synstate 3.0.4 → 3.0.6

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