synstate 1.0.2 → 2.0.0

package/src/core/operators/throttle.mts

@@ -117,6 +117,12 @@ class ThrottleObservableClass<A>
     this.#milliSeconds = milliSeconds;
   }
 
+  #resetTimer(): void {
+    if (this.#mut_timerId !== undefined) {
+      clearTimeout(this.#mut_timerId);
+    }
+  }
+
   override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
@@ -140,12 +146,6 @@ class ThrottleObservableClass<A>
     }, this.#milliSeconds);
   }
 
-  #resetTimer(): void {
-    if (this.#mut_timerId !== undefined) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-
   override complete(): void {
     this.#resetTimer();
 

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

@@ -105,6 +105,10 @@ class WithBufferedFromObservableClass<A, B>
     });
   }
 
+  #clearBuffer(): void {
+    this.#mut_bufferedValues = [];
+  }
+
   override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
@@ -118,8 +122,4 @@ class WithBufferedFromObservableClass<A, B>
 
     this.#clearBuffer();
   }
-
-  #clearBuffer(): void {
-    this.#mut_bufferedValues = [];
-  }
 }

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

@@ -51,5 +51,4 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
  */
 export const mapOptional = <O extends UnknownOptional, B>(
   mapFn: (x: Optional.Unwrap<O>) => B,
-): KeepInitialValueOperator<O, Optional<B>> =>
-  map((a) => Optional.map(a, mapFn));
+): KeepInitialValueOperator<O, Optional<B>> => map(Optional.map(mapFn));

package/src/core/predefined/operators/map-result-err.mts

@@ -52,4 +52,4 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
 export const mapResultErr = <R extends UnknownResult, E2>(
   mapFn: (x: Result.UnwrapErr<R>) => E2,
 ): KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>> =>
-  map((a) => Result.mapErr(a, mapFn));
+  map(Result.mapErr(mapFn));

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

@@ -52,4 +52,4 @@ import { type KeepInitialValueOperator } from '../../types/index.mjs';
 export const mapResultOk = <R extends UnknownResult, S2>(
   mapFn: (x: Result.UnwrapOk<R>) => S2,
 ): KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>> =>
-  map((a) => Result.map(a, mapFn));
+  map(Result.map(mapFn));

package/src/core/types/observable-family.mts

@@ -1,7 +1,8 @@
 import { expectType, type Result } from 'ts-data-forge';
 import {
   type ArrayElement,
-  type NonEmptyArray,
+  type FixedLengthTuple,
+  type NonEmptyTuple,
   type SafeUint,
 } from 'ts-type-forge';
 import {
@@ -63,8 +64,8 @@ export type ScanOperatorObservable<A, B> = InitializedSyncChildObservable<
 namespace SynStateInternals {
   type Cast<A> = A extends NonEmptyUnknownList ? A : never;
 
-  type EveryInitialized<OS extends NonEmptyArray<Observable<unknown>>> =
-    OS extends NonEmptyArray<InitializedObservable<unknown>> ? true : false;
+  type EveryInitialized<OS extends NonEmptyTuple<Observable<unknown>>> =
+    OS extends NonEmptyTuple<InitializedObservable<unknown>> ? true : false;
 
   type IsInitialized<O> = readonly [O] extends readonly [
     InitializedObservable<unknown>,
@@ -83,7 +84,7 @@ namespace SynStateInternals {
     // union distribution
     LogicalValue<OS extends OS ? IsInitialized<OS> : never>;
 
-  type SomeInitialized<OS extends NonEmptyArray<Observable<unknown>>> =
+  type SomeInitialized<OS extends NonEmptyTuple<Observable<unknown>>> =
     SomeInitializedImpl<OS[number]>;
 
   expectType<EveryInitialized<readonly [Observable<1>]>, false>('=');
@@ -125,7 +126,7 @@ namespace SynStateInternals {
     SyncChildObservable<A, A>;
 
   export type CombineObservableRefinedImpl<
-    OS extends NonEmptyArray<Observable<unknown>>,
+    OS extends NonEmptyTuple<Observable<unknown>>,
   > =
     EveryInitialized<OS> extends true
       ? InitializedCombineObservableImpl<Cast<Unwrap<OS>>>
@@ -138,7 +139,7 @@ namespace SynStateInternals {
     SyncChildObservable<A, A>;
 
   export type ZipObservableRefinedImpl<
-    OS extends NonEmptyArray<Observable<unknown>>,
+    OS extends NonEmptyTuple<Observable<unknown>>,
   > =
     EveryInitialized<OS> extends true
       ? InitializedZipObservableImpl<Cast<Unwrap<OS>>>
@@ -151,7 +152,7 @@ namespace SynStateInternals {
     SyncChildObservable<ArrayElement<P>, P>;
 
   export type MergeObservableRefinedImpl<
-    OS extends NonEmptyArray<Observable<unknown>>,
+    OS extends NonEmptyTuple<Observable<unknown>>,
   > =
     SomeInitialized<OS> extends true
       ? InitializedMergeObservableImpl<Cast<Unwrap<OS>>>
@@ -162,27 +163,27 @@ export type CombineObservable<A extends NonEmptyUnknownList> =
   SynStateInternals.CombineObservableImpl<A>;
 
 export type CombineObservableRefined<
-  OS extends NonEmptyArray<Observable<unknown>>,
+  OS extends NonEmptyTuple<Observable<unknown>>,
 > = SynStateInternals.CombineObservableRefinedImpl<OS>;
 
 export type ZipObservable<A extends NonEmptyUnknownList> =
   SynStateInternals.ZipObservableImpl<A>;
 
 export type ZipObservableRefined<
-  OS extends NonEmptyArray<Observable<unknown>>,
+  OS extends NonEmptyTuple<Observable<unknown>>,
 > = SynStateInternals.ZipObservableRefinedImpl<OS>;
 
 export type MergeObservable<A extends NonEmptyUnknownList> =
   SynStateInternals.MergeObservableImpl<A>;
 
 export type MergeObservableRefined<
-  OS extends NonEmptyArray<Observable<unknown>>,
+  OS extends NonEmptyTuple<Observable<unknown>>,
 > = SynStateInternals.MergeObservableRefinedImpl<OS>;
 
 export type MapOperatorObservable<A, B> = SyncChildObservable<B, readonly [A]>;
 
 export type PairwiseOperatorObservable<A> = SyncChildObservable<
-  readonly [A, A],
+  FixedLengthTuple<2, A>,
   readonly [A]
 >;
 

package/src/core/types/observable.mts

@@ -1,5 +1,5 @@
 import { expectType, type Optional, type Some } from 'ts-data-forge';
-import { type StrictOmit } from 'ts-type-forge';
+import { type FixedLengthTuple, type StrictOmit } from 'ts-type-forge';
 import { type ObservableId, type UpdateToken } from './id.mjs';
 import { type ObservableKind } from './observable-kind.mjs';
 import { type NonEmptyUnknownList, type Subscription } from './types.mjs';
@@ -128,9 +128,7 @@ export type InitializedRootObservable<A> =
   ObservableTypeConverter.ToInitialized<A, RootObservable<A>>;
 
 export type Observable<A> =
-  | AsyncChildObservable<A>
-  | RootObservable<A>
-  | SyncChildObservable<A>;
+  AsyncChildObservable<A> | RootObservable<A> | SyncChildObservable<A>;
 
 export type InitializedObservable<A> =
   | InitializedAsyncChildObservable<A>
@@ -209,11 +207,11 @@ expectType<
 expectType<number, ObservableValue<Observable<string>>>('!<=');
 
 expectType<
-  readonly [Observable<number>, Observable<number>],
-  Wrap<readonly [number, number]>
+  FixedLengthTuple<2, Observable<number>>,
+  Wrap<FixedLengthTuple<2, number>>
 >('<=');
 
 expectType<
   readonly [Observable<number>, Observable<string>],
-  Wrap<readonly [number, number]>
+  Wrap<FixedLengthTuple<2, number>>
 >('!<=');

package/src/core/types/types.mts

@@ -1,10 +1,11 @@
 import { expectType, type Queue } from 'ts-data-forge';
+import { type NonEmptyTuple } from 'ts-type-forge';
 
 export type TupleToQueueTuple<T extends readonly unknown[]> = Readonly<{
   [P in keyof T]: Queue<T[P]>;
 }>;
 
-export type NonEmptyUnknownList = readonly [unknown, ...unknown[]];
+export type NonEmptyUnknownList = NonEmptyTuple<unknown>;
 
 export type Subscriber<A> = Readonly<{
   onNext: (v: A) => void;

package/src/core/utils/max-depth.mts

@@ -3,5 +3,9 @@ import { type Observable } from '../types/index.mjs';
 
 export const maxDepth = (parents: readonly Observable<unknown>[]): number =>
   pipe(Arr.maxBy(parents, (p) => p.depth))
-    .mapOptional((o) => o.depth)
+    // Explicit return type + non-curried `Optional.unwrapOr` call: TypeScript
+    // 7 (native)'s inference for this chained generic call resolves to
+    // `unknown` without them, even though TypeScript <= 6.0's checker
+    // resolves this fine.
+    .mapOptional((o): number => o.depth)
     .map(Optional.unwrapOr(0)).value;

package/src/core/utils/utils.mts

@@ -15,7 +15,7 @@ export const binarySearch = <N extends number>(
 ): NegativeInt32 | Uint32 => {
   const uint32Result = asUint32(0);
 
-  if (Arr.isArrayOfLength(sortedArray, 0)) {
+  if (Arr.isEmpty(sortedArray)) {
     return uint32Result;
   }
 

package/src/utils/create-boolean-state.mts

@@ -34,7 +34,7 @@ export const createBooleanState = (
   initialState: boolean,
 ): readonly [
   state: InitializedObservable<boolean>,
-  Readonly<{
+  utils: Readonly<{
     setTrue: () => void;
     setFalse: () => void;
     setState: (next: boolean) => boolean;

package/src/utils/create-reducer.mts

@@ -50,7 +50,7 @@ export const createReducer = <S, A>(
 ): readonly [
   state: InitializedObservable<S>,
   dispatch: (action: A) => S,
-  Readonly<{
+  utils: Readonly<{
     getSnapshot: () => S;
     initialState: S;
   }>,

package/src/utils/create-state.mts

@@ -60,7 +60,7 @@ export const createState = <S,>(
 ): readonly [
   state: InitializedObservable<S>,
   setState: (v: S) => S,
-  Readonly<{
+  utils: Readonly<{
     updateState: (updateFn: (prev: S) => S) => S;
     resetState: () => S;
     getSnapshot: () => S;