synstate 2.0.1 → 3.0.0

package/dist/core/operators/with-buffered-from.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,YAAY,yBAAmB,CAAC"}
+{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAEhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,YAAY,yBAAmB,CAAC"}

package/dist/core/operators/with-buffered-from.mjs

@@ -1,20 +1,23 @@
-import { pipe, Optional, Arr } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { Optional, pipe, Arr } from 'ts-data-forge';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 import { maxDepth } from '../utils/max-depth.mjs';
 
 const withBufferedFrom = (observable) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => new WithBufferedFromObservableClass(
+  ((parentObservable) => createWithBufferedFromObservable(
     parentObservable,
     observable
   ))
 );
 const withBuffered = withBufferedFrom;
-class WithBufferedFromObservableClass extends SyncChildObservableClass {
-  #mut_bufferedValues = [];
-  constructor(parentObservable, observable) {
-    super({
+const createWithBufferedFromObservable = (parentObservable, observable) => {
+  let mut_bufferedValues = [];
+  const clearBuffer = () => {
+    mut_bufferedValues = [];
+  };
+  const result = createSyncChildObservable(
+    {
       parents: [parentObservable],
       depth: 1 + maxDepth([parentObservable, observable]),
       initialValue: pipe({
@@ -26,24 +29,21 @@ class WithBufferedFromObservableClass extends SyncChildObservableClass {
           Optional.isNone(me) ? [] : [me.value]
         ])
       ).value
-    });
-    observable.subscribe((value) => {
-      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
-    });
-  }
-  #clearBuffer() {
-    this.#mut_bufferedValues = [];
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return;
+    },
+    ({ setNext }) => (updateToken) => {
+      const sn = parentObservable.getSnapshot();
+      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
+        return;
+      }
+      setNext([sn.value, mut_bufferedValues], updateToken);
+      clearBuffer();
     }
-    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
-    this.#clearBuffer();
-  }
-}
+  );
+  observable.subscribe((value) => {
+    mut_bufferedValues = Arr.toPushed(mut_bufferedValues, value);
+  });
+  return result;
+};
 
 export { withBuffered, withBufferedFrom };
 //# sourceMappingURL=with-buffered-from.mjs.map

package/dist/core/operators/with-buffered-from.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":["import { Arr, Optional, pipe } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type UpdateToken,\n  type WithBufferedFromOperatorObservable,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\n\n/**\n * Buffers values from the source observable and emits them along with the parent value\n * when the parent emits. The buffer is cleared after each emission.\n *\n * @template A - The type of values from the parent observable\n * @template B - The type of values from the source observable\n * @param observable - The observable whose values will be buffered\n * @returns An operator that emits tuples of [parentValue, bufferedValues]\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  data$       d1    d2    d3    d4    d5    d6    d7    d8\n * //  trigger$                T1                T2                T3\n * //  result$                 [T1,[d1,d2,d3]]   [T2,[d4,d5,d6]]   [T3,[d7,d8]]\n * //\n * //  Explanation:\n * //  - withBufferedFrom collects values from the source observable\n * //  - When the trigger emits, it emits a tuple of [triggerValue, bufferedValues]\n * //  - Buffer is cleared after each emission\n * //  - Useful for batching data collection triggered by events\n *\n * const data$ = source<string>();\n *\n * const trigger$ = source<number>();\n *\n * const result$ = trigger$.pipe(withBufferedFrom(data$));\n *\n * const valueHistory: (readonly [number, readonly string[]])[] = [];\n *\n * result$.subscribe(([triggerValue, bufferedData]) => {\n *   valueHistory.push([triggerValue, bufferedData]);\n * });\n *\n * data$.next('A');\n *\n * data$.next('B');\n *\n * trigger$.next(1);\n *\n * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);\n *\n * data$.next('C');\n *\n * trigger$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, ['A', 'B']],\n *   [2, ['C']],\n * ]);\n * ```\n */\nexport const withBufferedFrom = <A, B>(\n  observable: Observable<B>,\n): KeepInitialValueOperator<A, readonly [A, readonly B[]]> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new WithBufferedFromObservableClass(\n      parentObservable,\n      observable,\n    )) as KeepInitialValueOperator<A, readonly [A, readonly B[]]>;\n\n/**\n * Alias for `withBufferedFrom`.\n * @see withBufferedFrom\n */\nexport const withBuffered = withBufferedFrom;\n\nclass WithBufferedFromObservableClass<A, B>\n  extends SyncChildObservableClass<readonly [A, readonly B[]], readonly [A]>\n  implements WithBufferedFromOperatorObservable<A, B>\n{\n  #mut_bufferedValues: readonly B[] = [];\n\n  constructor(parentObservable: Observable<A>, observable: Observable<B>) {\n    super({\n      parents: [parentObservable],\n      depth: 1 + maxDepth([parentObservable, observable]),\n      initialValue: pipe({\n        par: parentObservable.getSnapshot(),\n        me: observable.getSnapshot(),\n      }).map(({ par, me }) =>\n        Optional.isNone(par)\n          ? Optional.none\n          : Optional.some([\n              par.value,\n              Optional.isNone(me) ? [] : [me.value],\n            ] as const),\n      ).value,\n    });\n\n    observable.subscribe((value) => {\n      this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);\n    });\n  }\n\n  #clearBuffer(): void {\n    this.#mut_bufferedValues = [];\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);\n\n    this.#clearBuffer();\n  }\n}\n"],"names":[],"mappings":";;;;;AA+DO,MAAM,mBAAmB,CAC9B,UAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,+BAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAMG,MAAM,YAAA,GAAe;AAE5B,MAAM,wCACI,wBAAA,CAEV;AAAA,EACE,sBAAoC,EAAC;AAAA,EAErC,WAAA,CAAY,kBAAiC,UAAA,EAA2B;AACtE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,OAAO,CAAA,GAAI,QAAA,CAAS,CAAC,gBAAA,EAAkB,UAAU,CAAC,CAAA;AAAA,MAClD,cAAc,IAAA,CAAK;AAAA,QACjB,GAAA,EAAK,iBAAiB,WAAA,EAAY;AAAA,QAClC,EAAA,EAAI,WAAW,WAAA;AAAY,OAC5B,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,EAAE,GAAA,EAAK,EAAA,EAAG,KAChB,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,GACf,QAAA,CAAS,IAAA,GACT,QAAA,CAAS,IAAA,CAAK;AAAA,UACZ,GAAA,CAAI,KAAA;AAAA,UACJ,QAAA,CAAS,OAAO,EAAE,CAAA,GAAI,EAAC,GAAI,CAAC,GAAG,KAAK;AAAA,SAC5B;AAAA,OAChB,CAAE;AAAA,KACH,CAAA;AAED,IAAA,UAAA,CAAW,SAAA,CAAU,CAAC,KAAA,KAAU;AAC9B,MAAA,IAAA,CAAK,mBAAA,GAAsB,GAAA,CAAI,QAAA,CAAS,IAAA,CAAK,qBAAqB,KAAK,CAAA;AAAA,IACzE,CAAC,CAAA;AAAA,EACH;AAAA,EAEA,YAAA,GAAqB;AACnB,IAAA,IAAA,CAAK,sBAAsB,EAAC;AAAA,EAC9B;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,QAAQ,CAAC,EAAA,CAAG,OAAO,IAAA,CAAK,mBAAmB,GAAG,WAAW,CAAA;AAE9D,IAAA,IAAA,CAAK,YAAA,EAAa;AAAA,EACpB;AACF;;;;"}
+{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":["import { Arr, Optional, pipe } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type WithBufferedFromOperatorObservable,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\n\n/**\n * Buffers values from the source observable and emits them along with the parent value\n * when the parent emits. The buffer is cleared after each emission.\n *\n * @template A - The type of values from the parent observable\n * @template B - The type of values from the source observable\n * @param observable - The observable whose values will be buffered\n * @returns An operator that emits tuples of [parentValue, bufferedValues]\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  data$       d1    d2    d3    d4    d5    d6    d7    d8\n * //  trigger$                T1                T2                T3\n * //  result$                 [T1,[d1,d2,d3]]   [T2,[d4,d5,d6]]   [T3,[d7,d8]]\n * //\n * //  Explanation:\n * //  - withBufferedFrom collects values from the source observable\n * //  - When the trigger emits, it emits a tuple of [triggerValue, bufferedValues]\n * //  - Buffer is cleared after each emission\n * //  - Useful for batching data collection triggered by events\n *\n * const data$ = source<string>();\n *\n * const trigger$ = source<number>();\n *\n * const result$ = trigger$.pipe(withBufferedFrom(data$));\n *\n * const valueHistory: (readonly [number, readonly string[]])[] = [];\n *\n * result$.subscribe(([triggerValue, bufferedData]) => {\n *   valueHistory.push([triggerValue, bufferedData]);\n * });\n *\n * data$.next('A');\n *\n * data$.next('B');\n *\n * trigger$.next(1);\n *\n * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);\n *\n * data$.next('C');\n *\n * trigger$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, ['A', 'B']],\n *   [2, ['C']],\n * ]);\n * ```\n */\nexport const withBufferedFrom = <A, B>(\n  observable: Observable<B>,\n): KeepInitialValueOperator<A, readonly [A, readonly B[]]> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    createWithBufferedFromObservable(\n      parentObservable,\n      observable,\n    )) as KeepInitialValueOperator<A, readonly [A, readonly B[]]>;\n\n/**\n * Alias for `withBufferedFrom`.\n * @see withBufferedFrom\n */\nexport const withBuffered = withBufferedFrom;\n\nconst createWithBufferedFromObservable = <A, B>(\n  parentObservable: Observable<A>,\n  observable: Observable<B>,\n): WithBufferedFromOperatorObservable<A, B> => {\n  let mut_bufferedValues: readonly B[] = [];\n\n  const clearBuffer = (): void => {\n    mut_bufferedValues = [];\n  };\n\n  const result = createSyncChildObservable<\n    readonly [A, readonly B[]],\n    readonly [A]\n  >(\n    {\n      parents: [parentObservable],\n      depth: 1 + maxDepth([parentObservable, observable]),\n      initialValue: pipe({\n        par: parentObservable.getSnapshot(),\n        me: observable.getSnapshot(),\n      }).map(({ par, me }) =>\n        Optional.isNone(par)\n          ? Optional.none\n          : Optional.some([\n              par.value,\n              Optional.isNone(me) ? [] : [me.value],\n            ] as const),\n      ).value,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext([sn.value, mut_bufferedValues], updateToken);\n\n        clearBuffer();\n      },\n  );\n\n  observable.subscribe((value) => {\n    mut_bufferedValues = Arr.toPushed(mut_bufferedValues, value);\n  });\n\n  return result;\n};\n"],"names":[],"mappings":";;;;;AA8DO,MAAM,mBAAmB,CAC9B,UAAA;AAAA;AAAA,GAGC,CAAC,gBAAA,KACA,gCAAA;AAAA,IACE,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAMG,MAAM,YAAA,GAAe;AAE5B,MAAM,gCAAA,GAAmC,CACvC,gBAAA,EACA,UAAA,KAC6C;AAC7C,EAAA,IAAI,qBAAmC,EAAC;AAExC,EAAA,MAAM,cAAc,MAAY;AAC9B,IAAA,kBAAA,GAAqB,EAAC;AAAA,EACxB,CAAA;AAEA,EAAA,MAAM,MAAA,GAAS,yBAAA;AAAA,IAIb;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,OAAO,CAAA,GAAI,QAAA,CAAS,CAAC,gBAAA,EAAkB,UAAU,CAAC,CAAA;AAAA,MAClD,cAAc,IAAA,CAAK;AAAA,QACjB,GAAA,EAAK,iBAAiB,WAAA,EAAY;AAAA,QAClC,EAAA,EAAI,WAAW,WAAA;AAAY,OAC5B,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,EAAE,GAAA,EAAK,EAAA,EAAG,KAChB,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,GACf,QAAA,CAAS,IAAA,GACT,QAAA,CAAS,IAAA,CAAK;AAAA,UACZ,GAAA,CAAI,KAAA;AAAA,UACJ,QAAA,CAAS,OAAO,EAAE,CAAA,GAAI,EAAC,GAAI,CAAC,GAAG,KAAK;AAAA,SAC5B;AAAA,OAChB,CAAE;AAAA,KACJ;AAAA,IACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,OAAA,CAAQ,CAAC,EAAA,CAAG,KAAA,EAAO,kBAAkB,GAAG,WAAW,CAAA;AAEnD,MAAA,WAAA,EAAY;AAAA,IACd;AAAA,GACJ;AAEA,EAAA,UAAA,CAAW,SAAA,CAAU,CAAC,KAAA,KAAU;AAC9B,IAAA,kBAAA,GAAqB,GAAA,CAAI,QAAA,CAAS,kBAAA,EAAoB,KAAK,CAAA;AAAA,EAC7D,CAAC,CAAA;AAED,EAAA,OAAO,MAAA;AACT,CAAA;;;;"}

package/dist/core/operators/with-current-value-from.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEyB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,6BAAuB,CAAC"}
+{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAEhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEsB,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,cAAc,6BAAuB,CAAC"}

package/dist/core/operators/with-current-value-from.mjs

@@ -1,36 +1,31 @@
-import { pipe, Optional } from 'ts-data-forge';
-import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { Optional, pipe } from 'ts-data-forge';
+import { createSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 import { maxDepth } from '../utils/max-depth.mjs';
 
-const withCurrentValueFrom = (observable) => (parentObservable) => new WithCurrentValueFromObservableClass(parentObservable, observable);
+const withCurrentValueFrom = (observable) => (parentObservable) => createWithCurrentValueFromObservable(parentObservable, observable);
 const withLatestFrom = withCurrentValueFrom;
-class WithCurrentValueFromObservableClass extends SyncChildObservableClass {
-  #observable;
-  constructor(parentObservable, observable) {
-    super({
-      parents: [parentObservable],
-      depth: 1 + maxDepth([parentObservable, observable]),
-      initialValue: pipe({
-        par: parentObservable.getSnapshot(),
-        me: observable.getSnapshot()
-      }).map(
-        ({ me, par }) => Optional.isNone(par) || Optional.isNone(me) ? Optional.none : Optional.some([par.value, me.value])
-      ).value
-    });
-    this.#observable = observable;
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const ps = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(ps)) {
+const createWithCurrentValueFromObservable = (parentObservable, observable) => createSyncChildObservable(
+  {
+    parents: [parentObservable],
+    depth: 1 + maxDepth([parentObservable, observable]),
+    initialValue: pipe({
+      par: parentObservable.getSnapshot(),
+      me: observable.getSnapshot()
+    }).map(
+      ({ me, par }) => Optional.isNone(par) || Optional.isNone(me) ? Optional.none : Optional.some([par.value, me.value])
+    ).value
+  },
+  ({ setNext }) => (updateToken) => {
+    const ps = parentObservable.getSnapshot();
+    if (parentObservable.updateToken !== updateToken || Optional.isNone(ps)) {
       return;
     }
-    const curr = this.#observable.getSnapshot();
+    const curr = observable.getSnapshot();
     if (Optional.isNone(curr)) return;
-    this.setNext([ps.value, curr.value], updateToken);
+    setNext([ps.value, curr.value], updateToken);
   }
-}
+);
 
 export { withCurrentValueFrom, withLatestFrom };
 //# sourceMappingURL=with-current-value-from.mjs.map

package/dist/core/operators/with-current-value-from.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-current-value-from.mjs","sources":["../../../src/core/operators/with-current-value-from.mts"],"sourcesContent":["import { Optional, pipe } from 'ts-data-forge';\nimport { SyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type UpdateToken,\n  type WithCurrentValueFromOperatorObservable,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\n\n/**\n * Samples the current value from another observable each time the source emits.\n * Emits a tuple of [sourceValue, sampledValue].\n *\n * @template A - The type of values from the source observable\n * @template B - The type of values from the sampled observable\n * @param observable - The observable to sample from\n * @returns An operator that emits tuples of source and sampled values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  name$     \"Alice\"           \"Bob\"               \"Charlie\"\n * //  age$                25              30\n * //  result$   (skip)          [\"Bob\",25]           [\"Charlie\",30]\n * //\n * //  Explanation:\n * //  - withCurrentValueFrom samples the current value from another observable\n * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits\n * //  - Does NOT emit when the sampled observable (age$) emits\n * //  - Does not emit until both observables have emitted at least once\n * //  - \"Alice\" is skipped because age$ hasn't emitted yet\n *\n * const name$ = source<string>();\n *\n * const age$ = source<number>();\n *\n * const result$ = name$.pipe(withCurrentValueFrom(age$));\n *\n * const valueHistory: (readonly [string, number])[] = [];\n *\n * result$.subscribe(([name_, currentAge]) => {\n *   valueHistory.push([name_, currentAge]);\n * });\n *\n * name$.next('Alice'); // nothing logged (age$ hasn't emitted)\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * age$.next(25);\n *\n * name$.next('Bob'); // logs: Bob is 25 years old\n *\n * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);\n *\n * age$.next(30);\n *\n * name$.next('Charlie'); // logs: Charlie is 30 years old\n *\n * assert.deepStrictEqual(valueHistory, [\n *   ['Bob', 25],\n *   ['Charlie', 30],\n * ]);\n * ```\n */\nexport const withCurrentValueFrom =\n  <A, B>(\n    observable: Observable<B>,\n  ): DropInitialValueOperator<A, readonly [A, B]> =>\n  (parentObservable) =>\n    new WithCurrentValueFromObservableClass(parentObservable, observable);\n\n/**\n * Alias for `withCurrentValueFrom`.\n * @see withCurrentValueFrom\n */\nexport const withLatestFrom = withCurrentValueFrom;\n\nclass WithCurrentValueFromObservableClass<A, B>\n  extends SyncChildObservableClass<readonly [A, B], readonly [A]>\n  implements WithCurrentValueFromOperatorObservable<A, B>\n{\n  readonly #observable: Observable<B>;\n\n  constructor(parentObservable: Observable<A>, observable: Observable<B>) {\n    super({\n      parents: [parentObservable],\n      depth: 1 + maxDepth([parentObservable, observable]),\n      initialValue: pipe({\n        par: parentObservable.getSnapshot(),\n        me: observable.getSnapshot(),\n      }).map(({ me, par }) =>\n        Optional.isNone(par) || Optional.isNone(me)\n          ? Optional.none\n          : Optional.some([par.value, me.value] as const),\n      ).value,\n    });\n\n    this.#observable = observable;\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const ps = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(ps)) {\n      return; // skip update\n    }\n\n    const curr = this.#observable.getSnapshot();\n\n    if (Optional.isNone(curr)) return; // skip update\n\n    this.setNext([ps.value, curr.value], updateToken);\n  }\n}\n"],"names":[],"mappings":";;;;;AAkEO,MAAM,oBAAA,GACX,CACE,UAAA,KAEF,CAAC,qBACC,IAAI,mCAAA,CAAoC,kBAAkB,UAAU;AAMjE,MAAM,cAAA,GAAiB;AAE9B,MAAM,4CACI,wBAAA,CAEV;AAAA,EACW,WAAA;AAAA,EAET,WAAA,CAAY,kBAAiC,UAAA,EAA2B;AACtE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,OAAO,CAAA,GAAI,QAAA,CAAS,CAAC,gBAAA,EAAkB,UAAU,CAAC,CAAA;AAAA,MAClD,cAAc,IAAA,CAAK;AAAA,QACjB,GAAA,EAAK,iBAAiB,WAAA,EAAY;AAAA,QAClC,EAAA,EAAI,WAAW,WAAA;AAAY,OAC5B,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,EAAE,EAAA,EAAI,GAAA,OACZ,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,IAAK,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,GACtC,QAAA,CAAS,OACT,QAAA,CAAS,IAAA,CAAK,CAAC,GAAA,CAAI,KAAA,EAAO,EAAA,CAAG,KAAK,CAAU;AAAA,OAClD,CAAE;AAAA,KACH,CAAA;AAED,IAAA,IAAA,CAAK,WAAA,GAAc,UAAA;AAAA,EACrB;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,WAAA,CAAY,WAAA,EAAY;AAE1C,IAAA,IAAI,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA,EAAG;AAE3B,IAAA,IAAA,CAAK,QAAQ,CAAC,EAAA,CAAG,OAAO,IAAA,CAAK,KAAK,GAAG,WAAW,CAAA;AAAA,EAClD;AACF;;;;"}
+{"version":3,"file":"with-current-value-from.mjs","sources":["../../../src/core/operators/with-current-value-from.mts"],"sourcesContent":["import { Optional, pipe } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type WithCurrentValueFromOperatorObservable,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\n\n/**\n * Samples the current value from another observable each time the source emits.\n * Emits a tuple of [sourceValue, sampledValue].\n *\n * @template A - The type of values from the source observable\n * @template B - The type of values from the sampled observable\n * @param observable - The observable to sample from\n * @returns An operator that emits tuples of source and sampled values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  name$     \"Alice\"           \"Bob\"               \"Charlie\"\n * //  age$                25              30\n * //  result$   (skip)          [\"Bob\",25]           [\"Charlie\",30]\n * //\n * //  Explanation:\n * //  - withCurrentValueFrom samples the current value from another observable\n * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits\n * //  - Does NOT emit when the sampled observable (age$) emits\n * //  - Does not emit until both observables have emitted at least once\n * //  - \"Alice\" is skipped because age$ hasn't emitted yet\n *\n * const name$ = source<string>();\n *\n * const age$ = source<number>();\n *\n * const result$ = name$.pipe(withCurrentValueFrom(age$));\n *\n * const valueHistory: (readonly [string, number])[] = [];\n *\n * result$.subscribe(([name_, currentAge]) => {\n *   valueHistory.push([name_, currentAge]);\n * });\n *\n * name$.next('Alice'); // nothing logged (age$ hasn't emitted)\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * age$.next(25);\n *\n * name$.next('Bob'); // logs: Bob is 25 years old\n *\n * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);\n *\n * age$.next(30);\n *\n * name$.next('Charlie'); // logs: Charlie is 30 years old\n *\n * assert.deepStrictEqual(valueHistory, [\n *   ['Bob', 25],\n *   ['Charlie', 30],\n * ]);\n * ```\n */\nexport const withCurrentValueFrom =\n  <A, B>(\n    observable: Observable<B>,\n  ): DropInitialValueOperator<A, readonly [A, B]> =>\n  (parentObservable) =>\n    createWithCurrentValueFromObservable(parentObservable, observable);\n\n/**\n * Alias for `withCurrentValueFrom`.\n * @see withCurrentValueFrom\n */\nexport const withLatestFrom = withCurrentValueFrom;\n\nconst createWithCurrentValueFromObservable = <A, B>(\n  parentObservable: Observable<A>,\n  observable: Observable<B>,\n): WithCurrentValueFromOperatorObservable<A, B> =>\n  createSyncChildObservable<readonly [A, B], readonly [A]>(\n    {\n      parents: [parentObservable],\n      depth: 1 + maxDepth([parentObservable, observable]),\n      initialValue: pipe({\n        par: parentObservable.getSnapshot(),\n        me: observable.getSnapshot(),\n      }).map(({ me, par }) =>\n        Optional.isNone(par) || Optional.isNone(me)\n          ? Optional.none\n          : Optional.some([par.value, me.value] as const),\n      ).value,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const ps = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(ps)\n        ) {\n          return; // skip update\n        }\n\n        const curr = observable.getSnapshot();\n\n        if (Optional.isNone(curr)) return; // skip update\n\n        setNext([ps.value, curr.value], updateToken);\n      },\n  );\n"],"names":[],"mappings":";;;;;AAiEO,MAAM,uBACX,CACE,UAAA,KAEF,CAAC,gBAAA,KACC,oCAAA,CAAqC,kBAAkB,UAAU;AAM9D,MAAM,cAAA,GAAiB;AAE9B,MAAM,oCAAA,GAAuC,CAC3C,gBAAA,EACA,UAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,OAAO,CAAA,GAAI,QAAA,CAAS,CAAC,gBAAA,EAAkB,UAAU,CAAC,CAAA;AAAA,IAClD,cAAc,IAAA,CAAK;AAAA,MACjB,GAAA,EAAK,iBAAiB,WAAA,EAAY;AAAA,MAClC,EAAA,EAAI,WAAW,WAAA;AAAY,KAC5B,CAAA,CAAE,GAAA;AAAA,MAAI,CAAC,EAAE,EAAA,EAAI,GAAA,OACZ,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,IAAK,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,GACtC,QAAA,CAAS,OACT,QAAA,CAAS,IAAA,CAAK,CAAC,GAAA,CAAI,KAAA,EAAO,EAAA,CAAG,KAAK,CAAU;AAAA,KAClD,CAAE;AAAA,GACJ;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,IAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,IAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,IAAA,GAAO,WAAW,WAAA,EAAY;AAEpC,IAAA,IAAI,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA,EAAG;AAE3B,IAAA,OAAA,CAAQ,CAAC,EAAA,CAAG,KAAA,EAAO,IAAA,CAAK,KAAK,GAAG,WAAW,CAAA;AAAA,EAC7C;AACJ,CAAA;;;;"}

package/dist/core/operators/with-initial-value.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-initial-value.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-initial-value.mts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAEO,CAAC"}
+{"version":3,"file":"with-initial-value.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-initial-value.mts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,wBAAwB,EAE9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAEI,CAAC"}

package/dist/core/operators/with-initial-value.mjs

@@ -1,24 +1,21 @@
 import { Optional } from 'ts-data-forge';
-import { InitializedSyncChildObservableClass } from '../class/child-observable-class.mjs';
+import { createInitializedSyncChildObservable } from '../base/create-child-observable.mjs';
 import '../utils/id-maker.mjs';
 
-const withInitialValue = (initialValue) => (parentObservable) => new WithInitialValueObservableClass(parentObservable, initialValue);
-class WithInitialValueObservableClass extends InitializedSyncChildObservableClass {
-  constructor(parentObservable, initialValue) {
-    super({
-      parents: [parentObservable],
-      initialValue: Optional.some(initialValue)
-    });
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+const withInitialValue = (initialValue) => (parentObservable) => createWithInitialValueObservable(parentObservable, initialValue);
+const createWithInitialValueObservable = (parentObservable, initialValue) => createInitializedSyncChildObservable(
+  {
+    parents: [parentObservable],
+    initialValue: Optional.some(initialValue)
+  },
+  ({ setNext }) => (updateToken) => {
+    const sn = parentObservable.getSnapshot();
+    if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
       return;
     }
-    this.setNext(sn.value, updateToken);
+    setNext(sn.value, updateToken);
   }
-}
+);
 
 export { withInitialValue };
 //# sourceMappingURL=with-initial-value.mjs.map

package/dist/core/operators/with-initial-value.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-initial-value.mjs","sources":["../../../src/core/operators/with-initial-value.mts"],"sourcesContent":["import { expectType, Optional } from 'ts-data-forge';\nimport { InitializedSyncChildObservableClass } from '../class/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type InitializedObservable,\n  type Observable,\n  type UpdateToken,\n  type WithInitialValueOperator,\n  type WithInitialValueOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Provides an initial value for an observable that doesn't have one.\n * The resulting observable will immediately emit the initial value upon subscription,\n * and then emit all subsequent values from the source.\n *\n * @template A - The type of values from the source\n * @template I - The type of the initial value (defaults to A)\n * @param initialValue - The initial value to emit\n * @returns An operator that sets the initial value\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$             1    2    3\n * //  withInitial$ 0   1    2    3\n * //               ^\n * //               initial value\n * //\n * //  Explanation:\n * //  - withInitialValue provides an initial value before the source emits\n * //  - Converts an uninitialized observable to an initialized one\n * //  - Useful when you need a default value immediately\n *\n * const num$ = source<number>();\n *\n * const initialized$ = num$.pipe(withInitialValue(0));\n *\n * const valueHistory: number[] = [];\n *\n * initialized$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [0, 1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 2]);\n * ```\n */\nexport const withInitialValue =\n  <A, I = A>(initialValue: I): WithInitialValueOperator<A, A | I> =>\n  (parentObservable) =>\n    new WithInitialValueObservableClass(parentObservable, initialValue);\n\nclass WithInitialValueObservableClass<A, I>\n  extends InitializedSyncChildObservableClass<A | I, readonly [A]>\n  implements WithInitialValueOperatorObservable<A, I>\n{\n  constructor(parentObservable: Observable<A>, initialValue: I) {\n    super({\n      parents: [parentObservable],\n      initialValue: Optional.some(initialValue),\n    });\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    this.setNext(sn.value, updateToken);\n  }\n}\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const s = source<number>();\n\n    const _d: InitializedObservable<number> = s.pipe(withInitialValue(0));\n\n    expectType<typeof _d, InitializedObservable<number>>('=');\n  }\n}\n"],"names":[],"mappings":";;;;AAwDO,MAAM,gBAAA,GACX,CAAW,YAAA,KACX,CAAC,qBACC,IAAI,+BAAA,CAAgC,kBAAkB,YAAY;AAEtE,MAAM,wCACI,mCAAA,CAEV;AAAA,EACE,WAAA,CAAY,kBAAiC,YAAA,EAAiB;AAC5D,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,YAAY;AAAA,KACzC,CAAA;AAAA,EAAA;AACH,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IAAA;AAGF,IAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,WAAW,CAAA;AAAA,EAAA;AAEtC;;;;"}
+{"version":3,"file":"with-initial-value.mjs","sources":["../../../src/core/operators/with-initial-value.mts"],"sourcesContent":["import { expectType, Optional } from 'ts-data-forge';\nimport { createInitializedSyncChildObservable } from '../base/index.mjs';\nimport { source } from '../create/index.mjs';\nimport {\n  type InitializedObservable,\n  type Observable,\n  type WithInitialValueOperator,\n  type WithInitialValueOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Provides an initial value for an observable that doesn't have one.\n * The resulting observable will immediately emit the initial value upon subscription,\n * and then emit all subsequent values from the source.\n *\n * @template A - The type of values from the source\n * @template I - The type of the initial value (defaults to A)\n * @param initialValue - The initial value to emit\n * @returns An operator that sets the initial value\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$             1    2    3\n * //  withInitial$ 0   1    2    3\n * //               ^\n * //               initial value\n * //\n * //  Explanation:\n * //  - withInitialValue provides an initial value before the source emits\n * //  - Converts an uninitialized observable to an initialized one\n * //  - Useful when you need a default value immediately\n *\n * const num$ = source<number>();\n *\n * const initialized$ = num$.pipe(withInitialValue(0));\n *\n * const valueHistory: number[] = [];\n *\n * initialized$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [0, 1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 2]);\n * ```\n */\nexport const withInitialValue =\n  <A, I = A>(initialValue: I): WithInitialValueOperator<A, A | I> =>\n  (parentObservable) =>\n    createWithInitialValueObservable(parentObservable, initialValue);\n\nconst createWithInitialValueObservable = <A, I>(\n  parentObservable: Observable<A>,\n  initialValue: I,\n): WithInitialValueOperatorObservable<A, I> =>\n  createInitializedSyncChildObservable<A | I, readonly [A]>(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.some(initialValue),\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext(sn.value, updateToken);\n      },\n  );\n\nif (import.meta.vitest !== undefined) {\n  test('type test', () => {\n    expect(1).toBe(1); // dummy\n  });\n\n  {\n    const s = source<number>();\n\n    const _d: InitializedObservable<number> = s.pipe(withInitialValue(0));\n\n    expectType<typeof _d, InitializedObservable<number>>('=');\n  }\n}\n"],"names":[],"mappings":";;;;AAuDO,MAAM,mBACX,CAAW,YAAA,KACX,CAAC,gBAAA,KACC,gCAAA,CAAiC,kBAAkB,YAAY;AAEnE,MAAM,gCAAA,GAAmC,CACvC,gBAAA,EACA,YAAA,KAEA,oCAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,YAAY;AAAA,GAC1C;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,IAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,IAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,MAAA;AAAA,IAAA;AAGF,IAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,EAAA;AAEnC,CAAA;;;;"}

package/dist/entry-point.mjs

@@ -1,6 +1,3 @@
-export { AsyncChildObservableClass, InitializedSyncChildObservableClass, SyncChildObservableClass } from './core/class/child-observable-class.mjs';
-export { ObservableBaseClass } from './core/class/observable-base-class.mjs';
-export { RootObservableClass } from './core/class/root-observable-class.mjs';
 export { combine, combineLatest } from './core/combine/combine.mjs';
 export { merge } from './core/combine/merge.mjs';
 export { zip } from './core/combine/zip.mjs';

package/dist/entry-point.mjs.map

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

package/dist/index.mjs

@@ -1,6 +1,3 @@
-export { AsyncChildObservableClass, InitializedSyncChildObservableClass, SyncChildObservableClass } from './core/class/child-observable-class.mjs';
-export { ObservableBaseClass } from './core/class/observable-base-class.mjs';
-export { RootObservableClass } from './core/class/root-observable-class.mjs';
 export { combine, combineLatest } from './core/combine/combine.mjs';
 export { merge } from './core/combine/merge.mjs';
 export { zip } from './core/combine/zip.mjs';

package/dist/index.mjs.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -19,8 +19,8 @@
       }
     }
   },
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "files": [
     "src",
     "dist",
@@ -29,33 +29,40 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.2.1",
-    "ts-type-forge": "^9.2.1"
+    "ts-data-forge": "^14.5.0",
+    "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
     "@reduxjs/toolkit": "2.12.0",
-    "@rollup/plugin-replace": "6.0.3",
-    "@rollup/plugin-strip": "3.0.4",
     "@types/react": "19.2.18",
+    "@vitest/browser-playwright": "4.1.11",
     "argparse": "3.0.0",
+    "eslint-config-typed": "5.10.0",
+    "eslint-plugin-ts-data-forge": "0.5.1",
+    "eslint-plugin-ts-fortress": "1.0.5",
+    "eslint-plugin-ts-type-forge": "0.7.1",
     "jotai": "2.20.2",
-    "mobx": "7.0.0",
+    "mobx": "7.0.3",
+    "playwright": "1.62.1",
     "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.2.8",
     "rollup": "4.62.4",
-    "rollup-plugin-esbuild": "6.2.1",
     "rxjs": "7.8.2",
+    "synstate-react-hooks": "3.0.0",
+    "synstate-react-hooks-compat": "3.0.0",
+    "ts-repo-utils": "10.3.2",
     "valtio": "2.3.2",
-    "zustand": "5.0.14",
-    "eslint-config-typed": "5.8.5",
-    "eslint-plugin-ts-data-forge": "0.4.4",
-    "eslint-plugin-ts-fortress": "1.0.1",
-    "eslint-plugin-ts-type-forge": "0.6.3",
-    "synstate-react-hooks": "2.0.1",
-    "synstate-react-hooks-compat": "2.0.1",
-    "ts-repo-utils": "10.2.0"
+    "zustand": "5.0.15"
+  },
+  "engines": {
+    "node": ">=22.22.2",
+    "pnpm": ">=9.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "benchmark": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/run-benchmark.mts",
@@ -73,7 +80,7 @@
     "fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
     "fmt:full": "pnpm run z:prettier .",
     "gi": "run-s gi:src fmt",
-    "gi:src": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/gen-index-ts.mts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude \"core/utils/**\"",
+    "gi:src": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/gen-index-ts.mts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude \"core/base/**\" --exclude \"core/utils/**\"",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "pnpm run z:vitest:node run",

package/src/core/{class → base}/circular-dependency-comparison.test.mts

@@ -8,32 +8,39 @@
  *   only at read time as a `Maximum call stack size exceeded` error.
  */
 /* eslint-disable functional/immutable-data */
-/* eslint-disable no-new */
 import { type Atom, atom, createStore } from 'jotai';
 import { BehaviorSubject, combineLatest, map as rxMap } from 'rxjs';
 import { Optional } from 'ts-data-forge';
 import { combine } from '../combine/index.mjs';
 import { source } from '../create/index.mjs';
 import { map } from '../operators/index.mjs';
-import { SyncChildObservableClass } from './child-observable-class.mjs';
-import { RootObservableClass } from './root-observable-class.mjs';
+import { createSyncChildObservable } from './create-child-observable.mjs';
+import { createTryUpdateNotImplemented } from './create-observable-base.mjs';
+import { createRootObservable } from './create-root-observable.mjs';
 
 describe('circular dependency comparison', () => {
   describe('SynState', () => {
     test('detects cycle at construction time with a clear error message', () => {
-      const root = new RootObservableClass({
-        initialValue: Optional.some(0),
-      });
+      const root = createRootObservable(
+        { initialValue: Optional.some(0) },
+        () => ({}),
+      );
 
-      const childA = new SyncChildObservableClass({
-        parents: [root],
-        initialValue: Optional.some(0),
-      });
+      const childA = createSyncChildObservable(
+        {
+          parents: [root],
+          initialValue: Optional.some(0),
+        },
+        createTryUpdateNotImplemented,
+      );
 
-      const childB = new SyncChildObservableClass({
-        parents: [childA],
-        initialValue: Optional.some(0),
-      });
+      const childB = createSyncChildObservable(
+        {
+          parents: [childA],
+          initialValue: Optional.some(0),
+        },
+        createTryUpdateNotImplemented,
+      );
 
       // Simulate a cycle: childA → childB → childA
       // In normal usage this is impossible — the check runs in every
@@ -45,10 +52,13 @@ describe('circular dependency comparison', () => {
       });
 
       expect(() => {
-        new SyncChildObservableClass({
-          parents: [childA],
-          initialValue: Optional.some(0),
-        });
+        createSyncChildObservable(
+          {
+            parents: [childA],
+            initialValue: Optional.some(0),
+          },
+          createTryUpdateNotImplemented,
+        );
       }).toThrow(
         'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',
       );