synstate 2.0.2 → 3.0.0

package/README.md

@@ -9,7 +9,7 @@
 [![npm version](https://img.shields.io/npm/v/synstate.svg)](https://www.npmjs.com/package/synstate)
 [![npm downloads](https://img.shields.io/npm/dm/synstate.svg)](https://www.npmjs.com/package/synstate)
 [![License](https://img.shields.io/npm/l/synstate.svg)](https://github.com/noshiro-pf/mono/blob/main/libs/synstate/LICENSE)
-[![codecov](https://codecov.io/gh/noshiro-pf/mono/graph/badge.svg)](https://codecov.io/gh/noshiro-pf/mono)
+[![codecov](https://codecov.io/gh/noshiro-pf/mono/graph/badge.svg?component=synstate)](https://codecov.io/gh/noshiro-pf/mono)
 
 </p>
 
@@ -24,7 +24,7 @@
 - 🎯 **Simple State Management**: Easy-to-use `createState` and `createReducer` similar to React useState/useReducer for global state
 - ⚡ **High Performance**: Optimized for fast state updates and minimal re-renders
 - 🎨 **Type-Safe**: Full TypeScript support with precise type inference
-- 🚀 **Lightweight**: <!-- bundle-size:synstate -->~4.4 kB min+gzip<!-- /bundle-size:synstate --> with only one external runtime dependency ([ts-data-forge](https://www.npmjs.com/package/ts-data-forge))
+- 🚀 **Lightweight**: <!-- bundle-size:synstate -->~4.6 kB min+gzip<!-- /bundle-size:synstate --> with only one external runtime dependency ([ts-data-forge](https://www.npmjs.com/package/ts-data-forge))
 - 🌐 **Framework Agnostic**: Works with React, Vue, Svelte, or vanilla JavaScript
 - 🔄 **Reactive Updates**: Automatic propagation of state changes to all subscribers
 - 📡 **Event System**: Built-in `createValueEmitter`, `createEventEmitter` for event-driven architecture

package/dist/core/base/create-child-observable.d.mts

@@ -0,0 +1,65 @@
+import { type Optional, type Some } from 'ts-data-forge';
+import { type AsyncChildObservable, type InitializedSyncChildObservable, type NonEmptyUnknownList, type SyncChildObservable, type UpdateToken, type Wrap } from '../types/index.mjs';
+/**
+ * The internal tools a sync-child leaf factory (`map`, `filter`, `zip`, …)
+ * receives — the replacement for the `protected` methods a subclass of
+ * `SyncChildObservableClass` used to inherit.
+ */
+export type SyncChildObservableTools<A> = Readonly<{
+    /** Emits `nextValue` under `updateToken` and notifies subscribers. */
+    setNext: (nextValue: A, updateToken: UpdateToken) => void;
+    getSnapshot: () => Optional<A>;
+    /** Completes this observable (leaf teardown included). */
+    complete: () => void;
+}>;
+/**
+ * The internal tools an async-child leaf factory (`debounce`, `switchMap`, …)
+ * receives. Async children additionally start their own update propagation.
+ */
+export type AsyncChildObservableTools<A> = Readonly<{
+    /** Emits `nextValue` and propagates the update to all descendants. */
+    startUpdate: (nextValue: A) => void;
+}> & SyncChildObservableTools<A>;
+type ChildObservableConfigBase<P extends NonEmptyUnknownList> = Readonly<{
+    parents: Wrap<P>;
+    depth?: number;
+    /**
+     * Leaf teardown (clear timers, unsubscribe inner observables, …), run at
+     * the beginning of `complete()` — the closure replacement for
+     * `override complete() { teardown(); super.complete(); }`.
+     */
+    onComplete?: () => void;
+}>;
+export type ChildObservableConfig<A, P extends NonEmptyUnknownList> = ChildObservableConfigBase<P> & Readonly<{
+    initialValue: Optional<A>;
+}>;
+export type InitializedChildObservableConfig<A, P extends NonEmptyUnknownList> = ChildObservableConfigBase<P> & Readonly<{
+    initialValue: Some<A>;
+}>;
+/**
+ * Creates a sync-child observable — the classless replacement for extending
+ * `SyncChildObservableClass`.
+ *
+ * `createTryUpdate` receives the internal tools and returns the `tryUpdate`
+ * implementation (the former `override tryUpdate`). It runs during
+ * construction, before the observable is registered to its parents; leaf
+ * state can live either in the enclosing factory scope or inside the
+ * `createTryUpdate` closure.
+ */
+export declare const createSyncChildObservable: <A, P extends NonEmptyUnknownList>({ parents, depth, initialValue, onComplete, }: ChildObservableConfig<A, P>, createTryUpdate: (tools: SyncChildObservableTools<A>) => (updateToken: UpdateToken) => void) => SyncChildObservable<A, P>;
+/**
+ * Creates a sync-child observable that always holds a value.
+ *
+ * Runtime-wise this is exactly `createSyncChildObservable`; only the types of
+ * `getSnapshot` and `pipe` are narrowed, which is what the
+ * `InitializedSyncChildObservableClass` overrides existed for.
+ */
+export declare const createInitializedSyncChildObservable: <A, P extends NonEmptyUnknownList>(config: InitializedChildObservableConfig<A, P>, createTryUpdate: (tools: SyncChildObservableTools<A>) => (updateToken: UpdateToken) => void) => InitializedSyncChildObservable<A, P>;
+/**
+ * Creates an async-child observable — the classless replacement for extending
+ * `AsyncChildObservableClass`. See {@link createSyncChildObservable} for the
+ * `createTryUpdate` contract.
+ */
+export declare const createAsyncChildObservable: <A, P extends NonEmptyUnknownList>({ parents, depth, initialValue, onComplete, }: ChildObservableConfig<A, P>, createTryUpdate: (tools: AsyncChildObservableTools<A>) => (updateToken: UpdateToken) => void) => AsyncChildObservable<A, P>;
+export {};
+//# sourceMappingURL=create-child-observable.d.mts.map

package/dist/core/base/create-child-observable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-child-observable.d.mts","sourceRoot":"","sources":["../../../src/core/base/create-child-observable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,MAAM,eAAe,CAAC;AAE9D,OAAO,EAGL,KAAK,oBAAoB,EAEzB,KAAK,8BAA8B,EACnC,KAAK,mBAAmB,EAGxB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,IAAI,EACV,MAAM,oBAAoB,CAAC;AAQ5B;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,CAAC,CAAC,IAAI,QAAQ,CAAC;IACjD,sEAAsE;IACtE,OAAO,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;IAE1D,WAAW,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE/B,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,IAAI,QAAQ,CAAC;IAClD,sEAAsE;IACtE,WAAW,EAAE,CAAC,SAAS,EAAE,CAAC,KAAK,IAAI,CAAC;CACrC,CAAC,GACA,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAE9B,KAAK,yBAAyB,CAAC,CAAC,SAAS,mBAAmB,IAAI,QAAQ,CAAC;IACvE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAEjB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,CAC/B,CAAC,EACD,CAAC,SAAS,mBAAmB,IAC3B,yBAAyB,CAAC,CAAC,CAAC,GAC9B,QAAQ,CAAC;IACP,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;CAC3B,CAAC,CAAC;AAEL,MAAM,MAAM,gCAAgC,CAC1C,CAAC,EACD,CAAC,SAAS,mBAAmB,IAC3B,yBAAyB,CAAC,CAAC,CAAC,GAC9B,QAAQ,CAAC;IACP,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;CACvB,CAAC,CAAC;AAEL;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,CAAC,EAAE,CAAC,SAAS,mBAAmB,iDAMrE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,mBACb,CACf,KAAK,EAAE,wBAAwB,CAAC,CAAC,CAAC,KAC/B,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,KACtC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CA0C1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC,GAC/C,CAAC,EACD,CAAC,SAAS,mBAAmB,UAErB,gCAAgC,CAAC,CAAC,EAAE,CAAC,CAAC,mBAC7B,CACf,KAAK,EAAE,wBAAwB,CAAC,CAAC,CAAC,KAC/B,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,KACtC,8BAA8B,CAAC,CAAC,EAAE,CAAC,CASrC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,EAAE,CAAC,SAAS,mBAAmB,iDAMtE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,mBACb,CACf,KAAK,EAAE,yBAAyB,CAAC,CAAC,CAAC,KAChC,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,KACtC,oBAAoB,CAAC,CAAC,EAAE,CAAC,CA6C3B,CAAC"}

package/dist/core/base/create-child-observable.mjs

@@ -0,0 +1,157 @@
+import { Arr } from 'ts-data-forge';
+import { isManagerObservable, isChildObservable } from '../types/observable.mjs';
+import '../utils/id-maker.mjs';
+import { maxDepth } from '../utils/max-depth.mjs';
+import { createObservableBaseHandle, createManagerObservableParts, assembleObservable } from './create-observable-base.mjs';
+
+const createSyncChildObservable = ({
+  parents,
+  depth = 1 + maxDepth(parents),
+  initialValue,
+  onComplete
+}, createTryUpdate) => {
+  const handle = createObservableBaseHandle(initialValue);
+  const complete = () => {
+    onComplete?.();
+    handle.completeBase();
+    for (const par of parents) {
+      par.tryComplete();
+    }
+  };
+  const tryComplete = () => {
+    tryCompleteChild({
+      hasSubscriber: handle.hasSubscriber(),
+      hasActiveChild: handle.hasActiveChild(),
+      parents,
+      complete
+    });
+  };
+  const tryUpdate = createTryUpdate({
+    setNext: handle.setNext,
+    getSnapshot: handle.getSnapshot,
+    complete
+  });
+  const observable = assembleObservable({
+    kind: "sync child",
+    depth,
+    handle,
+    tryUpdate,
+    tryComplete,
+    complete,
+    extra: { parents }
+  });
+  registerChild(observable, parents);
+  return observable;
+};
+const createInitializedSyncChildObservable = (config, createTryUpdate) => {
+  const observable = createSyncChildObservable(config, createTryUpdate);
+  return (
+    // `getSnapshot` always returns `Some` here: `initialValue` is a `Some` and
+    // `setNext` only ever stores a `Some`.
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    observable
+  );
+};
+const createAsyncChildObservable = ({
+  parents,
+  depth = 1 + maxDepth(parents),
+  initialValue,
+  onComplete
+}, createTryUpdate) => {
+  const handle = createObservableBaseHandle(initialValue);
+  const { addDescendant, startUpdate } = createManagerObservableParts(handle);
+  const complete = () => {
+    onComplete?.();
+    handle.completeBase();
+    for (const par of parents) {
+      par.tryComplete();
+    }
+  };
+  const tryComplete = () => {
+    tryCompleteChild({
+      hasSubscriber: handle.hasSubscriber(),
+      hasActiveChild: handle.hasActiveChild(),
+      parents,
+      complete
+    });
+  };
+  const tryUpdate = createTryUpdate({
+    setNext: handle.setNext,
+    getSnapshot: handle.getSnapshot,
+    complete,
+    startUpdate
+  });
+  const observable = assembleObservable({
+    kind: "async child",
+    depth,
+    handle,
+    tryUpdate,
+    tryComplete,
+    complete,
+    extra: { parents, addDescendant }
+  });
+  registerChild(observable, parents);
+  return observable;
+};
+const hasCircularDependencyFrom = (node, mut_visited, mut_inPath) => {
+  if (mut_inPath.has(node.id)) return true;
+  if (mut_visited.has(node.id)) return false;
+  mut_visited.add(node.id);
+  mut_inPath.add(node.id);
+  if (isChildObservable(node)) {
+    for (const parent of node.parents) {
+      if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+        return true;
+      }
+    }
+  }
+  mut_inPath.delete(node.id);
+  return false;
+};
+const detectCircularDependency = (child, parents) => {
+  const mut_visited = /* @__PURE__ */ new Set();
+  const mut_inPath = /* @__PURE__ */ new Set([child.id]);
+  for (const parent of parents) {
+    if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {
+      throw new Error(
+        "Circular dependency detected in observable graph: a child observable cannot be its own ancestor."
+      );
+    }
+  }
+};
+const registerChild = (child, parents) => {
+  detectCircularDependency(child, parents);
+  for (const p of parents) {
+    p.addChild(child);
+  }
+  const mut_rest = Array.from(parents);
+  while (Arr.isNonEmpty(mut_rest)) {
+    const p = mut_rest.pop();
+    if (p === void 0) break;
+    if (isManagerObservable(p)) {
+      p.addDescendant(child);
+    } else {
+      mut_rest.push(...p.parents);
+    }
+  }
+};
+const tryCompleteChild = ({
+  hasSubscriber,
+  hasActiveChild,
+  parents,
+  complete
+}) => {
+  if (parents.every((r) => r.isCompleted)) {
+    complete();
+    return;
+  }
+  if (!hasSubscriber && !hasActiveChild) {
+    complete();
+  }
+  for (const par of parents) {
+    par.tryComplete();
+  }
+};
+
+export { createAsyncChildObservable, createInitializedSyncChildObservable, createSyncChildObservable };
+//# sourceMappingURL=create-child-observable.mjs.map

package/dist/core/base/create-child-observable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-child-observable.mjs","sources":["../../../src/core/base/create-child-observable.mts"],"sourcesContent":["import { Arr, type Optional, type Some } from 'ts-data-forge';\nimport { type MutableSet } from 'ts-type-forge';\nimport {\n  isChildObservable,\n  isManagerObservable,\n  type AsyncChildObservable,\n  type ChildObservable,\n  type InitializedSyncChildObservable,\n  type NonEmptyUnknownList,\n  type Observable,\n  type ObservableId,\n  type SyncChildObservable,\n  type UpdateToken,\n  type Wrap,\n} from '../types/index.mjs';\nimport { maxDepth } from '../utils/index.mjs';\nimport {\n  assembleObservable,\n  createManagerObservableParts,\n  createObservableBaseHandle,\n} from './create-observable-base.mjs';\n\n/**\n * The internal tools a sync-child leaf factory (`map`, `filter`, `zip`, …)\n * receives — the replacement for the `protected` methods a subclass of\n * `SyncChildObservableClass` used to inherit.\n */\nexport type SyncChildObservableTools<A> = Readonly<{\n  /** Emits `nextValue` under `updateToken` and notifies subscribers. */\n  setNext: (nextValue: A, updateToken: UpdateToken) => void;\n\n  getSnapshot: () => Optional<A>;\n\n  /** Completes this observable (leaf teardown included). */\n  complete: () => void;\n}>;\n\n/**\n * The internal tools an async-child leaf factory (`debounce`, `switchMap`, …)\n * receives. Async children additionally start their own update propagation.\n */\nexport type AsyncChildObservableTools<A> = Readonly<{\n  /** Emits `nextValue` and propagates the update to all descendants. */\n  startUpdate: (nextValue: A) => void;\n}> &\n  SyncChildObservableTools<A>;\n\ntype ChildObservableConfigBase<P extends NonEmptyUnknownList> = Readonly<{\n  parents: Wrap<P>;\n\n  depth?: number;\n\n  /**\n   * Leaf teardown (clear timers, unsubscribe inner observables, …), run at\n   * the beginning of `complete()` — the closure replacement for\n   * `override complete() { teardown(); super.complete(); }`.\n   */\n  onComplete?: () => void;\n}>;\n\nexport type ChildObservableConfig<\n  A,\n  P extends NonEmptyUnknownList,\n> = ChildObservableConfigBase<P> &\n  Readonly<{\n    initialValue: Optional<A>;\n  }>;\n\nexport type InitializedChildObservableConfig<\n  A,\n  P extends NonEmptyUnknownList,\n> = ChildObservableConfigBase<P> &\n  Readonly<{\n    initialValue: Some<A>;\n  }>;\n\n/**\n * Creates a sync-child observable — the classless replacement for extending\n * `SyncChildObservableClass`.\n *\n * `createTryUpdate` receives the internal tools and returns the `tryUpdate`\n * implementation (the former `override tryUpdate`). It runs during\n * construction, before the observable is registered to its parents; leaf\n * state can live either in the enclosing factory scope or inside the\n * `createTryUpdate` closure.\n */\nexport const createSyncChildObservable = <A, P extends NonEmptyUnknownList>(\n  {\n    parents,\n    depth = 1 + maxDepth(parents),\n    initialValue,\n    onComplete,\n  }: ChildObservableConfig<A, P>,\n  createTryUpdate: (\n    tools: SyncChildObservableTools<A>,\n  ) => (updateToken: UpdateToken) => void,\n): SyncChildObservable<A, P> => {\n  const handle = createObservableBaseHandle<A>(initialValue);\n\n  const complete = (): void => {\n    onComplete?.();\n\n    handle.completeBase();\n\n    // propagate to parents\n    for (const par of parents) {\n      par.tryComplete();\n    }\n  };\n\n  const tryComplete = (): void => {\n    tryCompleteChild({\n      hasSubscriber: handle.hasSubscriber(),\n      hasActiveChild: handle.hasActiveChild(),\n      parents,\n      complete,\n    });\n  };\n\n  const tryUpdate = createTryUpdate({\n    setNext: handle.setNext,\n    getSnapshot: handle.getSnapshot,\n    complete,\n  });\n\n  const observable: SyncChildObservable<A, P> = assembleObservable({\n    kind: 'sync child',\n    depth,\n    handle,\n    tryUpdate,\n    tryComplete,\n    complete,\n    extra: { parents },\n  });\n\n  registerChild(observable, parents);\n\n  return observable;\n};\n\n/**\n * Creates a sync-child observable that always holds a value.\n *\n * Runtime-wise this is exactly `createSyncChildObservable`; only the types of\n * `getSnapshot` and `pipe` are narrowed, which is what the\n * `InitializedSyncChildObservableClass` overrides existed for.\n */\nexport const createInitializedSyncChildObservable = <\n  A,\n  P extends NonEmptyUnknownList,\n>(\n  config: InitializedChildObservableConfig<A, P>,\n  createTryUpdate: (\n    tools: SyncChildObservableTools<A>,\n  ) => (updateToken: UpdateToken) => void,\n): InitializedSyncChildObservable<A, P> => {\n  const observable = createSyncChildObservable<A, P>(config, createTryUpdate);\n\n  return (\n    // `getSnapshot` always returns `Some` here: `initialValue` is a `Some` and\n    // `setNext` only ever stores a `Some`.\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    observable as InitializedSyncChildObservable<A, P>\n  );\n};\n\n/**\n * Creates an async-child observable — the classless replacement for extending\n * `AsyncChildObservableClass`. See {@link createSyncChildObservable} for the\n * `createTryUpdate` contract.\n */\nexport const createAsyncChildObservable = <A, P extends NonEmptyUnknownList>(\n  {\n    parents,\n    depth = 1 + maxDepth(parents),\n    initialValue,\n    onComplete,\n  }: ChildObservableConfig<A, P>,\n  createTryUpdate: (\n    tools: AsyncChildObservableTools<A>,\n  ) => (updateToken: UpdateToken) => void,\n): AsyncChildObservable<A, P> => {\n  const handle = createObservableBaseHandle<A>(initialValue);\n\n  const { addDescendant, startUpdate } = createManagerObservableParts(handle);\n\n  const complete = (): void => {\n    onComplete?.();\n\n    handle.completeBase();\n\n    // propagate to parents\n    for (const par of parents) {\n      par.tryComplete();\n    }\n  };\n\n  const tryComplete = (): void => {\n    tryCompleteChild({\n      hasSubscriber: handle.hasSubscriber(),\n      hasActiveChild: handle.hasActiveChild(),\n      parents,\n      complete,\n    });\n  };\n\n  const tryUpdate = createTryUpdate({\n    setNext: handle.setNext,\n    getSnapshot: handle.getSnapshot,\n    complete,\n    startUpdate,\n  });\n\n  const observable: AsyncChildObservable<A, P> = assembleObservable({\n    kind: 'async child',\n    depth,\n    handle,\n    tryUpdate,\n    tryComplete,\n    complete,\n    extra: { parents, addDescendant },\n  });\n\n  registerChild(observable, parents);\n\n  return observable;\n};\n\n/* helpers */\n\n/**\n * Detects circular dependencies by walking the full ancestor chain of the\n * given parents and checking whether `child` already appears among them.\n *\n * @throws {Error} if a circular dependency is detected\n */\nconst hasCircularDependencyFrom = (\n  node: Observable<unknown>,\n  mut_visited: MutableSet<ObservableId>,\n  mut_inPath: MutableSet<ObservableId>,\n): boolean => {\n  if (mut_inPath.has(node.id)) return true;\n\n  if (mut_visited.has(node.id)) return false;\n\n  mut_visited.add(node.id);\n\n  mut_inPath.add(node.id);\n\n  if (isChildObservable(node)) {\n    for (const parent of node.parents) {\n      if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {\n        return true;\n      }\n    }\n  }\n\n  mut_inPath.delete(node.id);\n\n  return false;\n};\n\nconst detectCircularDependency = (\n  child: ChildObservable<unknown>,\n  parents: readonly Observable<unknown>[],\n): void => {\n  const mut_visited = new Set<ObservableId>();\n\n  const mut_inPath = new Set<ObservableId>([child.id]);\n\n  for (const parent of parents) {\n    if (hasCircularDependencyFrom(parent, mut_visited, mut_inPath)) {\n      throw new Error(\n        'Circular dependency detected in observable graph: a child observable cannot be its own ancestor.',\n      );\n    }\n  }\n};\n\n/**\n * Registers `child` to its parents and to all reachable manager observables.\n * Runs after the child object is fully assembled, so parents only ever hold a\n * reference to the final composed object (the class version registered `this`\n * from inside the constructor instead).\n */\nconst registerChild = <A,>(\n  child: ChildObservable<A>,\n  parents: ChildObservable<A>['parents'],\n): void => {\n  detectCircularDependency(child, parents);\n\n  for (const p of parents) {\n    p.addChild(child);\n  }\n\n  // register child to all reachable ManagerObservables\n  const mut_rest = Array.from(parents);\n\n  while (Arr.isNonEmpty(mut_rest)) {\n    const p = mut_rest.pop();\n\n    if (p === undefined) break;\n\n    if (isManagerObservable(p)) {\n      p.addDescendant(child);\n    } else {\n      // trace back dependency graph\n      mut_rest.push(...p.parents);\n    }\n  }\n};\n\nconst tryCompleteChild = <A,>({\n  hasSubscriber,\n  hasActiveChild,\n  parents,\n  complete,\n}: Readonly<{\n  hasSubscriber: boolean;\n  hasActiveChild: boolean;\n  parents: ChildObservable<A>['parents'];\n  complete: () => void;\n}>): void => {\n  // If there is no working parent node\n  if (parents.every((r) => r.isCompleted)) {\n    complete();\n\n    return;\n  }\n\n  // If there are no active child node\n  if (!hasSubscriber && !hasActiveChild) {\n    complete();\n  }\n\n  // propagate to parents\n  for (const par of parents) {\n    par.tryComplete();\n  }\n};\n"],"names":[],"mappings":"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"}

package/dist/core/base/create-observable-base.d.mts

@@ -0,0 +1,82 @@
+import { Optional } from 'ts-data-forge';
+import { type ReadonlyRecord } from 'ts-type-forge';
+import { type ChildObservable, type ObservableBase, type ObservableId, type ObservableKind, type Subscription, type UpdateToken } from '../types/index.mjs';
+/**
+ * The mutable core shared by every observable, expressed as closures instead of
+ * a base class.
+ *
+ * The returned handle is the "protected" surface of the former
+ * `ObservableBaseClass`: the layer factories (`createRootObservable`,
+ * `createSyncChildObservable`, `createAsyncChildObservable`) build the public
+ * object from it via {@link assembleObservable}, and leaf factories receive
+ * only the narrow tools they need. Neither the handle nor its type is exported
+ * from the package (`core/base/**` is excluded from index generation), so
+ * `setNext` and friends stay internal, as `protected` kept them before.
+ */
+export type ObservableBaseHandle<A> = Readonly<{
+    id: ObservableId;
+    addChild: <B>(child: ChildObservable<B>) => void;
+    getSnapshot: () => Optional<A>;
+    isCompleted: () => boolean;
+    updateToken: () => UpdateToken;
+    hasSubscriber: () => boolean;
+    hasChild: () => boolean;
+    hasActiveChild: () => boolean;
+    subscribe: (onNext: (v: A) => void, onComplete?: () => void) => Subscription;
+    /** Stores `nextValue` as the current value and notifies subscribers. */
+    setNext: (nextValue: A, updateToken: UpdateToken) => void;
+    /**
+     * The innermost part of `complete()` (what `ObservableBaseClass.complete`
+     * used to do): marks this observable completed exactly once, notifies and
+     * removes all subscribers, and propagates `tryComplete` to children. Layer
+     * factories wrap this with leaf teardown and propagation to parents.
+     */
+    completeBase: () => void;
+}>;
+export declare const createObservableBaseHandle: <A>(initialValue: Optional<A>) => ObservableBaseHandle<A>;
+/**
+ * The extra members every manager observable — a root or an async child — owns:
+ * the depth-ordered descendant list and the update propagation that walks it.
+ */
+export type ManagerObservableParts<A> = Readonly<{
+    addDescendant: <B>(child: ChildObservable<B>) => void;
+    /** Emits `nextValue` and propagates the update to all descendants. */
+    startUpdate: (nextValue: A) => void;
+}>;
+/**
+ * Builds the manager half of a root or async-child observable. Both start their
+ * own update propagation, so both keep a descendant set and a depth-ordered
+ * propagation list; this is the single implementation of that pair (the class
+ * version duplicated it across `RootObservableClass` and
+ * `AsyncChildObservableClass`).
+ */
+export declare const createManagerObservableParts: <A>(handle: ObservableBaseHandle<A>) => ManagerObservableParts<A>;
+/** Default `tryUpdate` for observables that never receive parent updates. */
+export declare const createTryUpdateNotImplemented: () => ((_updateToken: UpdateToken) => void);
+type AssembleObservableArgs<A, Kind extends ObservableKind, Extra extends ReadonlyRecord<string, unknown>> = Readonly<{
+    kind: Kind;
+    depth: number;
+    handle: ObservableBaseHandle<A>;
+    tryUpdate: (updateToken: UpdateToken) => void;
+    tryComplete: () => void;
+    complete: () => void;
+    /**
+     * Kind-specific public members (`parents`, `addDescendant`) and leaf
+     * extensions (`next`, `start`). They are merged here, in the one place the
+     * final object literal is created, because the public getters below must not
+     * be copied by a spread (spreading would freeze their current values).
+     */
+    extra: Extra;
+}>;
+/**
+ * Builds the public observable object from a base handle. This replaces the
+ * implicit assembly a `class` performs: state stays in the handle's closures,
+ * `isCompleted` / `updateToken` / `hasSubscriber` / `hasChild` become getters
+ * delegating to the handle, and the kind-specific behavior (`tryUpdate`,
+ * `tryComplete`, `complete`) is passed in already composed.
+ */
+export declare const assembleObservable: <A, Kind extends ObservableKind, Extra extends ReadonlyRecord<string, unknown>>({ kind, depth, handle, tryUpdate, tryComplete, complete, extra, }: AssembleObservableArgs<A, Kind, Extra>) => Extra & ObservableBase<A> & Readonly<{
+    kind: Kind;
+}>;
+export {};
+//# sourceMappingURL=create-observable-base.d.mts.map

package/dist/core/base/create-observable-base.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-observable-base.d.mts","sourceRoot":"","sources":["../../../src/core/base/create-observable-base.mts"],"names":[],"mappings":"AAAA,OAAO,EAAO,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,KAAK,eAAe,EAGpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,cAAc,EAInB,KAAK,YAAY,EACjB,KAAK,WAAW,EAEjB,MAAM,oBAAoB,CAAC;AAS5B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC7C,EAAE,EAAE,YAAY,CAAC;IAEjB,QAAQ,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAEjD,WAAW,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE/B,WAAW,EAAE,MAAM,OAAO,CAAC;IAE3B,WAAW,EAAE,MAAM,WAAW,CAAC;IAE/B,aAAa,EAAE,MAAM,OAAO,CAAC;IAE7B,QAAQ,EAAE,MAAM,OAAO,CAAC;IAExB,cAAc,EAAE,MAAM,OAAO,CAAC;IAE9B,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,IAAI,KAAK,YAAY,CAAC;IAE7E,wEAAwE;IACxE,OAAO,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;IAE1D;;;;;OAKG;IACH,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B,CAAC,CAAC;AAEH,eAAO,MAAM,0BAA0B,GAAI,CAAC,gBAC5B,QAAQ,CAAC,CAAC,CAAC,KACxB,oBAAoB,CAAC,CAAC,CAwHxB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC/C,aAAa,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAEtD,sEAAsE;IACtE,WAAW,EAAE,CAAC,SAAS,EAAE,CAAC,KAAK,IAAI,CAAC;CACrC,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GAAI,CAAC,UACpC,oBAAoB,CAAC,CAAC,CAAC,KAC9B,sBAAsB,CAAC,CAAC,CAiC1B,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,6BAA6B,QAAO,CAAC,CAChD,YAAY,EAAE,WAAW,KACtB,IAAI,CAA4B,CAAC;AAMtC,KAAK,sBAAsB,CACzB,CAAC,EACD,IAAI,SAAS,cAAc,EAC3B,KAAK,SAAS,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,IAC3C,QAAQ,CAAC;IACX,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC;IAChC,SAAS,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;IAC9C,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB;;;;;OAKG;IACH,KAAK,EAAE,KAAK,CAAC;CACd,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC7B,CAAC,EACD,IAAI,SAAS,cAAc,EAC3B,KAAK,SAAS,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,qEAS5C,sBAAsB,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,KAAG,KAAK,GAC/C,cAAc,CAAC,CAAC,CAAC,GACjB,QAAQ,CAAC;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAyDxB,CAAC"}

package/dist/core/base/create-observable-base.mjs

@@ -0,0 +1,160 @@
+import { Arr, Optional } from 'ts-data-forge';
+import { issueObservableId, issueUpdateToken, issueSubscriberId } from '../utils/id-maker.mjs';
+import { toSubscriber } from '../utils/observable-utils.mjs';
+import { binarySearch } from '../utils/utils.mjs';
+
+const createObservableBaseHandle = (initialValue) => {
+  const id = issueObservableId();
+  let mut_children = [];
+  const mut_subscribers = /* @__PURE__ */ new Map();
+  let mut_currentValue = initialValue;
+  let mut_isCompleted = false;
+  let mut_updateToken = issueUpdateToken();
+  const addSubscriber = (s) => {
+    const subscriberId = issueSubscriberId();
+    mut_subscribers.set(subscriberId, s);
+    return subscriberId;
+  };
+  const removeSubscriber = (subscriberId) => {
+    mut_subscribers.delete(subscriberId);
+  };
+  const addChild = (child) => {
+    mut_children = Arr.toPushed(
+      mut_children,
+      child
+    );
+  };
+  const getSnapshot = () => mut_currentValue;
+  const isCompleted = () => mut_isCompleted;
+  const updateToken = () => mut_updateToken;
+  const hasSubscriber = () => mut_subscribers.size > 0;
+  const hasChild = () => Arr.isNonEmpty(mut_children);
+  const hasActiveChild = () => mut_children.some((c) => !c.isCompleted);
+  const setNext = (nextValue, nextUpdateToken) => {
+    mut_updateToken = nextUpdateToken;
+    mut_currentValue = Optional.some(nextValue);
+    for (const s of mut_subscribers.values()) {
+      s.onNext(nextValue);
+    }
+  };
+  const completeBase = () => {
+    if (mut_isCompleted) return;
+    mut_isCompleted = true;
+    for (const s of mut_subscribers.values()) {
+      s.onComplete();
+    }
+    mut_subscribers.clear();
+    for (const o of mut_children) {
+      o.tryComplete();
+    }
+  };
+  const subscribe = (onNext, onComplete) => {
+    const curr = getSnapshot();
+    if (Optional.isSome(curr)) {
+      onNext(curr.value);
+    }
+    if (mut_isCompleted) {
+      if (onComplete !== void 0) {
+        onComplete();
+      }
+      return { unsubscribe: () => {
+      } };
+    }
+    const subscriberId = addSubscriber(
+      toSubscriber(onNext, onComplete)
+    );
+    return {
+      unsubscribe: () => {
+        removeSubscriber(subscriberId);
+      }
+    };
+  };
+  return {
+    id,
+    addChild,
+    getSnapshot,
+    isCompleted,
+    updateToken,
+    hasSubscriber,
+    hasChild,
+    hasActiveChild,
+    subscribe,
+    setNext,
+    completeBase
+  };
+};
+const createManagerObservableParts = (handle) => {
+  let mut_propagationOrder = [];
+  const mut_descendantsIdSet = /* @__PURE__ */ new Set();
+  const addDescendant = (child) => {
+    if (mut_descendantsIdSet.has(child.id)) return;
+    mut_descendantsIdSet.add(child.id);
+    const insertPos = binarySearch(
+      mut_propagationOrder.map((a) => a.depth),
+      child.depth
+    );
+    mut_propagationOrder = Arr.toInserted(
+      mut_propagationOrder,
+      insertPos,
+      child
+    );
+  };
+  const startUpdate = (nextValue) => {
+    const updateToken = issueUpdateToken();
+    handle.setNext(nextValue, updateToken);
+    for (const p of mut_propagationOrder) {
+      p.tryUpdate(updateToken);
+    }
+  };
+  return { addDescendant, startUpdate };
+};
+const createTryUpdateNotImplemented = () => tryUpdateNotImplemented;
+const tryUpdateNotImplemented = (_updateToken) => {
+  throw new Error("not implemented");
+};
+const assembleObservable = ({
+  kind,
+  depth,
+  handle,
+  tryUpdate,
+  tryComplete,
+  complete,
+  extra
+}) => {
+  function pipe(operator) {
+    return operator(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      observable
+    );
+  }
+  const observable = {
+    ...extra,
+    id: handle.id,
+    kind,
+    depth,
+    addChild: handle.addChild,
+    getSnapshot: handle.getSnapshot,
+    get isCompleted() {
+      return handle.isCompleted();
+    },
+    get updateToken() {
+      return handle.updateToken();
+    },
+    get hasSubscriber() {
+      return handle.hasSubscriber();
+    },
+    get hasChild() {
+      return handle.hasChild();
+    },
+    hasActiveChild: handle.hasActiveChild,
+    tryUpdate,
+    tryComplete,
+    complete,
+    subscribe: handle.subscribe,
+    pipe
+  };
+  return observable;
+};
+
+export { assembleObservable, createManagerObservableParts, createObservableBaseHandle, createTryUpdateNotImplemented };
+//# sourceMappingURL=create-observable-base.mjs.map

package/dist/core/base/create-observable-base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-observable-base.mjs","sources":["../../../src/core/base/create-observable-base.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport {\n  type MutableMap,\n  type MutableSet,\n  type ReadonlyRecord,\n} from 'ts-type-forge';\nimport {\n  type ChildObservable,\n  type InitializedObservable,\n  type Observable,\n  type ObservableBase,\n  type ObservableId,\n  type ObservableKind,\n  type Operator,\n  type Subscriber,\n  type SubscriberId,\n  type Subscription,\n  type UpdateToken,\n  type WithInitialValueOperator,\n} from '../types/index.mjs';\nimport {\n  binarySearch,\n  issueObservableId,\n  issueSubscriberId,\n  issueUpdateToken,\n  toSubscriber,\n} from '../utils/index.mjs';\n\n/**\n * The mutable core shared by every observable, expressed as closures instead of\n * a base class.\n *\n * The returned handle is the \"protected\" surface of the former\n * `ObservableBaseClass`: the layer factories (`createRootObservable`,\n * `createSyncChildObservable`, `createAsyncChildObservable`) build the public\n * object from it via {@link assembleObservable}, and leaf factories receive\n * only the narrow tools they need. Neither the handle nor its type is exported\n * from the package (`core/base/**` is excluded from index generation), so\n * `setNext` and friends stay internal, as `protected` kept them before.\n */\nexport type ObservableBaseHandle<A> = Readonly<{\n  id: ObservableId;\n\n  addChild: <B>(child: ChildObservable<B>) => void;\n\n  getSnapshot: () => Optional<A>;\n\n  isCompleted: () => boolean;\n\n  updateToken: () => UpdateToken;\n\n  hasSubscriber: () => boolean;\n\n  hasChild: () => boolean;\n\n  hasActiveChild: () => boolean;\n\n  subscribe: (onNext: (v: A) => void, onComplete?: () => void) => Subscription;\n\n  /** Stores `nextValue` as the current value and notifies subscribers. */\n  setNext: (nextValue: A, updateToken: UpdateToken) => void;\n\n  /**\n   * The innermost part of `complete()` (what `ObservableBaseClass.complete`\n   * used to do): marks this observable completed exactly once, notifies and\n   * removes all subscribers, and propagates `tryComplete` to children. Layer\n   * factories wrap this with leaf teardown and propagation to parents.\n   */\n  completeBase: () => void;\n}>;\n\nexport const createObservableBaseHandle = <A,>(\n  initialValue: Optional<A>,\n): ObservableBaseHandle<A> => {\n  const id = issueObservableId();\n\n  let mut_children: readonly ChildObservable<unknown>[] = [];\n\n  const mut_subscribers: MutableMap<SubscriberId, Subscriber<A>> = new Map();\n\n  let mut_currentValue: Optional<A> = initialValue;\n\n  let mut_isCompleted = false;\n\n  let mut_updateToken: UpdateToken = issueUpdateToken();\n\n  const addSubscriber = (s: Subscriber<A>): SubscriberId => {\n    // return the id of added subscriber\n    const subscriberId = issueSubscriberId();\n\n    mut_subscribers.set(subscriberId, s);\n\n    return subscriberId;\n  };\n\n  const removeSubscriber = (subscriberId: SubscriberId): void => {\n    mut_subscribers.delete(subscriberId);\n  };\n\n  const addChild = <B,>(child: ChildObservable<B>): void => {\n    mut_children = Arr.toPushed(\n      mut_children,\n\n      child as ChildObservable<unknown>,\n    );\n  };\n\n  const getSnapshot = (): Optional<A> => mut_currentValue;\n\n  const isCompleted = (): boolean => mut_isCompleted;\n\n  const updateToken = (): UpdateToken => mut_updateToken;\n\n  const hasSubscriber = (): boolean => mut_subscribers.size > 0;\n\n  const hasChild = (): boolean => Arr.isNonEmpty(mut_children);\n\n  const hasActiveChild = (): boolean =>\n    mut_children.some((c) => !c.isCompleted);\n\n  const setNext = (nextValue: A, nextUpdateToken: UpdateToken): void => {\n    mut_updateToken = nextUpdateToken;\n\n    mut_currentValue = Optional.some(nextValue);\n\n    for (const s of mut_subscribers.values()) {\n      s.onNext(nextValue);\n    }\n  };\n\n  const completeBase = (): void => {\n    if (mut_isCompleted) return; // terminate only once\n\n    // change state\n    mut_isCompleted = true;\n\n    // run subscribers for the current value\n    for (const s of mut_subscribers.values()) {\n      s.onComplete();\n    }\n\n    // remove all subscribers\n    mut_subscribers.clear();\n\n    // propagate to children\n    for (const o of mut_children) {\n      o.tryComplete();\n    }\n  };\n\n  const subscribe = (\n    onNext: (v: A) => void,\n    onComplete?: () => void,\n  ): Subscription => {\n    // first emit\n    const curr = getSnapshot();\n\n    if (Optional.isSome(curr)) {\n      onNext(curr.value);\n    }\n\n    if (mut_isCompleted) {\n      if (onComplete !== undefined) {\n        onComplete();\n      }\n\n      return { unsubscribe: () => {} };\n    }\n\n    const subscriberId: SubscriberId = addSubscriber(\n      toSubscriber(onNext, onComplete),\n    );\n\n    return {\n      unsubscribe: () => {\n        removeSubscriber(subscriberId);\n      },\n    };\n  };\n\n  return {\n    id,\n    addChild,\n    getSnapshot,\n    isCompleted,\n    updateToken,\n    hasSubscriber,\n    hasChild,\n    hasActiveChild,\n    subscribe,\n    setNext,\n    completeBase,\n  };\n};\n\n/**\n * The extra members every manager observable — a root or an async child — owns:\n * the depth-ordered descendant list and the update propagation that walks it.\n */\nexport type ManagerObservableParts<A> = Readonly<{\n  addDescendant: <B>(child: ChildObservable<B>) => void;\n\n  /** Emits `nextValue` and propagates the update to all descendants. */\n  startUpdate: (nextValue: A) => void;\n}>;\n\n/**\n * Builds the manager half of a root or async-child observable. Both start their\n * own update propagation, so both keep a descendant set and a depth-ordered\n * propagation list; this is the single implementation of that pair (the class\n * version duplicated it across `RootObservableClass` and\n * `AsyncChildObservableClass`).\n */\nexport const createManagerObservableParts = <A,>(\n  handle: ObservableBaseHandle<A>,\n): ManagerObservableParts<A> => {\n  let mut_propagationOrder: readonly ChildObservable<unknown>[] = [];\n\n  const mut_descendantsIdSet: MutableSet<ObservableId> = new Set();\n\n  const addDescendant = <B,>(child: ChildObservable<B>): void => {\n    if (mut_descendantsIdSet.has(child.id)) return;\n\n    mut_descendantsIdSet.add(child.id);\n\n    const insertPos = binarySearch(\n      mut_propagationOrder.map((a) => a.depth),\n      child.depth,\n    );\n\n    mut_propagationOrder = Arr.toInserted(\n      mut_propagationOrder,\n      insertPos,\n      child,\n    );\n  };\n\n  const startUpdate = (nextValue: A): void => {\n    const updateToken = issueUpdateToken();\n\n    handle.setNext(nextValue, updateToken);\n\n    for (const p of mut_propagationOrder) {\n      p.tryUpdate(updateToken);\n    }\n  };\n\n  return { addDescendant, startUpdate };\n};\n\n/** Default `tryUpdate` for observables that never receive parent updates. */\nexport const createTryUpdateNotImplemented = (): ((\n  _updateToken: UpdateToken,\n) => void) => tryUpdateNotImplemented;\n\nconst tryUpdateNotImplemented = (_updateToken: UpdateToken): void => {\n  throw new Error('not implemented');\n};\n\ntype AssembleObservableArgs<\n  A,\n  Kind extends ObservableKind,\n  Extra extends ReadonlyRecord<string, unknown>,\n> = Readonly<{\n  kind: Kind;\n  depth: number;\n  handle: ObservableBaseHandle<A>;\n  tryUpdate: (updateToken: UpdateToken) => void;\n  tryComplete: () => void;\n  complete: () => void;\n  /**\n   * Kind-specific public members (`parents`, `addDescendant`) and leaf\n   * extensions (`next`, `start`). They are merged here, in the one place the\n   * final object literal is created, because the public getters below must not\n   * be copied by a spread (spreading would freeze their current values).\n   */\n  extra: Extra;\n}>;\n\n/**\n * Builds the public observable object from a base handle. This replaces the\n * implicit assembly a `class` performs: state stays in the handle's closures,\n * `isCompleted` / `updateToken` / `hasSubscriber` / `hasChild` become getters\n * delegating to the handle, and the kind-specific behavior (`tryUpdate`,\n * `tryComplete`, `complete`) is passed in already composed.\n */\nexport const assembleObservable = <\n  A,\n  Kind extends ObservableKind,\n  Extra extends ReadonlyRecord<string, unknown>,\n>({\n  kind,\n  depth,\n  handle,\n  tryUpdate,\n  tryComplete,\n  complete,\n  extra,\n}: AssembleObservableArgs<A, Kind, Extra>): Extra &\n  ObservableBase<A> &\n  Readonly<{ kind: Kind }> => {\n  function pipe<B>(\n    operator: WithInitialValueOperator<A, B>,\n  ): InitializedObservable<B>;\n\n  function pipe<B>(operator: Operator<A, B>): Observable<B>;\n\n  function pipe<B>(operator: Operator<A, B>): Observable<B> {\n    return operator(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      observable as unknown as InitializedObservable<A>,\n    );\n  }\n\n  const observable = {\n    ...extra,\n\n    id: handle.id,\n\n    kind,\n\n    depth,\n\n    addChild: handle.addChild,\n\n    getSnapshot: handle.getSnapshot,\n\n    get isCompleted(): boolean {\n      return handle.isCompleted();\n    },\n\n    get updateToken(): UpdateToken {\n      return handle.updateToken();\n    },\n\n    get hasSubscriber(): boolean {\n      return handle.hasSubscriber();\n    },\n\n    get hasChild(): boolean {\n      return handle.hasChild();\n    },\n\n    hasActiveChild: handle.hasActiveChild,\n\n    tryUpdate,\n\n    tryComplete,\n\n    complete,\n\n    subscribe: handle.subscribe,\n\n    pipe,\n  } as const;\n\n  return observable;\n};\n"],"names":[],"mappings":"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"}

package/dist/core/base/create-root-observable.d.mts

@@ -0,0 +1,37 @@
+import { Optional } from 'ts-data-forge';
+import { type ReadonlyRecord } from 'ts-type-forge';
+import { type RootObservable } from '../types/index.mjs';
+/**
+ * The internal tools a root leaf factory (`source`, `timer`, `fromPromise`, …)
+ * receives — the replacement for the `protected` methods a subclass of
+ * `RootObservableClass` used to inherit.
+ */
+export type RootObservableTools<A> = Readonly<{
+    /** Emits `nextValue` and propagates the update to all descendants. */
+    startUpdate: (nextValue: A) => void;
+    isCompleted: () => boolean;
+    /** Completes this observable (leaf teardown included). */
+    complete: () => void;
+}>;
+export type RootObservableConfig<A> = Readonly<{
+    initialValue: Optional<A>;
+    /**
+     * Leaf teardown (clear timers, abort requests, …), run at the beginning of
+     * `complete()` — the closure replacement for
+     * `override complete() { teardown(); super.complete(); }`.
+     */
+    onComplete?: () => void;
+}>;
+/**
+ * Creates a root observable — the classless replacement for extending
+ * `RootObservableClass`.
+ *
+ * The optional `init` callback receives the internal tools and returns extra
+ * public members to merge into the observable (e.g. `next` for `source`,
+ * `start` for `timer`). `init` runs during construction; it may register
+ * asynchronous callbacks that use the tools, and may call `complete`
+ * synchronously, but the observable object itself does not exist yet at that
+ * point.
+ */
+export declare const createRootObservable: <A, Extension extends ReadonlyRecord<string, unknown> = ReadonlyRecord<never, never>>({ initialValue, onComplete }: RootObservableConfig<A>, init: (tools: RootObservableTools<A>) => Extension) => Extension & RootObservable<A>;
+//# sourceMappingURL=create-root-observable.d.mts.map

package/dist/core/base/create-root-observable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-root-observable.d.mts","sourceRoot":"","sources":["../../../src/core/base/create-root-observable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAQ3E;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC5C,sEAAsE;IACtE,WAAW,EAAE,CAAC,SAAS,EAAE,CAAC,KAAK,IAAI,CAAC;IAEpC,WAAW,EAAE,MAAM,OAAO,CAAC;IAE3B,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC,CAAC;AAEH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC7C,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE1B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAC/B,CAAC,EACD,SAAS,SAAS,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc,CAChE,KAAK,EACL,KAAK,CACN,gCAE6B,oBAAoB,CAAC,CAAC,CAAC,QAC/C,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,SAAS,KACjD,SAAS,GAAG,cAAc,CAAC,CAAC,CAmC9B,CAAC"}

package/dist/core/base/create-root-observable.mjs

@@ -0,0 +1,36 @@
+import 'ts-data-forge';
+import { createObservableBaseHandle, createManagerObservableParts, assembleObservable, createTryUpdateNotImplemented } from './create-observable-base.mjs';
+
+const createRootObservable = ({ initialValue, onComplete }, init) => {
+  const handle = createObservableBaseHandle(initialValue);
+  const { addDescendant, startUpdate } = createManagerObservableParts(handle);
+  const complete = () => {
+    onComplete?.();
+    handle.completeBase();
+  };
+  const tryComplete = () => {
+    if (!handle.hasSubscriber() && !handle.hasActiveChild()) {
+      complete();
+    }
+  };
+  const extension = init({
+    startUpdate,
+    isCompleted: handle.isCompleted,
+    complete
+  });
+  return assembleObservable({
+    kind: "root",
+    depth: 0,
+    handle,
+    tryUpdate: createTryUpdateNotImplemented,
+    tryComplete,
+    complete,
+    extra: {
+      ...extension,
+      addDescendant
+    }
+  });
+};
+
+export { createRootObservable };
+//# sourceMappingURL=create-root-observable.mjs.map

package/dist/core/base/create-root-observable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-root-observable.mjs","sources":["../../../src/core/base/create-root-observable.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { type ReadonlyRecord } from 'ts-type-forge';\nimport { isRootObservable, type RootObservable } from '../types/index.mjs';\nimport {\n  assembleObservable,\n  createManagerObservableParts,\n  createObservableBaseHandle,\n  createTryUpdateNotImplemented,\n} from './create-observable-base.mjs';\n\n/**\n * The internal tools a root leaf factory (`source`, `timer`, `fromPromise`, …)\n * receives — the replacement for the `protected` methods a subclass of\n * `RootObservableClass` used to inherit.\n */\nexport type RootObservableTools<A> = Readonly<{\n  /** Emits `nextValue` and propagates the update to all descendants. */\n  startUpdate: (nextValue: A) => void;\n\n  isCompleted: () => boolean;\n\n  /** Completes this observable (leaf teardown included). */\n  complete: () => void;\n}>;\n\nexport type RootObservableConfig<A> = Readonly<{\n  initialValue: Optional<A>;\n\n  /**\n   * Leaf teardown (clear timers, abort requests, …), run at the beginning of\n   * `complete()` — the closure replacement for\n   * `override complete() { teardown(); super.complete(); }`.\n   */\n  onComplete?: () => void;\n}>;\n\n/**\n * Creates a root observable — the classless replacement for extending\n * `RootObservableClass`.\n *\n * The optional `init` callback receives the internal tools and returns extra\n * public members to merge into the observable (e.g. `next` for `source`,\n * `start` for `timer`). `init` runs during construction; it may register\n * asynchronous callbacks that use the tools, and may call `complete`\n * synchronously, but the observable object itself does not exist yet at that\n * point.\n */\nexport const createRootObservable = <\n  A,\n  Extension extends ReadonlyRecord<string, unknown> = ReadonlyRecord<\n    never,\n    never\n  >,\n>(\n  { initialValue, onComplete }: RootObservableConfig<A>,\n  init: (tools: RootObservableTools<A>) => Extension,\n): Extension & RootObservable<A> => {\n  const handle = createObservableBaseHandle<A>(initialValue);\n\n  const { addDescendant, startUpdate } = createManagerObservableParts(handle);\n\n  const complete = (): void => {\n    onComplete?.();\n\n    handle.completeBase();\n  };\n\n  const tryComplete = (): void => {\n    if (!handle.hasSubscriber() && !handle.hasActiveChild()) {\n      complete();\n    }\n  };\n\n  const extension: Extension = init({\n    startUpdate,\n    isCompleted: handle.isCompleted,\n    complete,\n  });\n\n  return assembleObservable({\n    kind: 'root',\n    depth: 0,\n    handle,\n    tryUpdate: createTryUpdateNotImplemented,\n    tryComplete,\n    complete,\n    extra: {\n      ...extension,\n      addDescendant,\n    },\n  });\n};\n\nif (import.meta.vitest !== undefined) {\n  test('isRootObservable', () => {\n    assert.isTrue(\n      isRootObservable(\n        createRootObservable({ initialValue: Optional.some(0) }, () => ({})),\n      ),\n    );\n  });\n}\n"],"names":[],"mappings":";;;AA+CO,MAAM,uBAAuB,CAOlC,EAAE,YAAA,EAAc,UAAA,IAChB,IAAA,KACkC;AAClC,EAAA,MAAM,MAAA,GAAS,2BAA8B,YAAY,CAAA;AAEzD,EAAA,MAAM,EAAE,aAAA,EAAe,WAAA,EAAY,GAAI,6BAA6B,MAAM,CAAA;AAE1E,EAAA,MAAM,WAAW,MAAY;AAC3B,IAAA,UAAA,IAAa;AAEb,IAAA,MAAA,CAAO,YAAA,EAAa;AAAA,EACtB,CAAA;AAEA,EAAA,MAAM,cAAc,MAAY;AAC9B,IAAA,IAAI,CAAC,MAAA,CAAO,aAAA,MAAmB,CAAC,MAAA,CAAO,gBAAe,EAAG;AACvD,MAAA,QAAA,EAAS;AAAA,IACX;AAAA,EACF,CAAA;AAEA,EAAA,MAAM,YAAuB,IAAA,CAAK;AAAA,IAChC,WAAA;AAAA,IACA,aAAa,MAAA,CAAO,WAAA;AAAA,IACpB;AAAA,GACD,CAAA;AAED,EAAA,OAAO,kBAAA,CAAmB;AAAA,IACxB,IAAA,EAAM,MAAA;AAAA,IACN,KAAA,EAAO,CAAA;AAAA,IACP,MAAA;AAAA,IACA,SAAA,EAAW,6BAAA;AAAA,IACX,WAAA;AAAA,IACA,QAAA;AAAA,IACA,KAAA,EAAO;AAAA,MACL,GAAG,SAAA;AAAA,MACH;AAAA;AACF,GACD,CAAA;AACH;;;;"}

package/dist/core/base/index.d.mts

@@ -0,0 +1,3 @@
+export * from './create-child-observable.mjs';
+export * from './create-root-observable.mjs';
+//# sourceMappingURL=index.d.mts.map