synstate 0.1.0

package/dist/utils/create-state.d.mts

@@ -0,0 +1,61 @@
+import { type InitializedObservable } from '../core/index.mjs';
+/**
+ * Creates a reactive state container with getter and setter methods.
+ * Provides a simple state management solution with observable state.
+ *
+ * @template S - The type of the state
+ * @param initialState - The initial value of the state
+ * @returns An object containing the state observable and methods to manipulate it
+ *
+ * @example
+ * ```ts
+ * const [state, setState, { updateState, resetState }] = createState(0);
+ *
+ * state.subscribe((value: number) => {
+ *   console.log(value);
+ * }); // logs: 0
+ *
+ * setState(10); // logs: 10
+ *
+ * updateState((prev: number) => prev + 1); // logs: 11
+ *
+ * resetState(); // logs: 0
+ * ```
+ */
+export declare const createState: <S>(initialState: S) => readonly [state: InitializedObservable<S>, setState: (v: S) => S, Readonly<{
+    updateState: (updateFn: (prev: S) => S) => S;
+    resetState: () => S;
+    getSnapshot: () => S;
+}>];
+/**
+ * Creates a reactive boolean state with convenient methods for boolean operations.
+ * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
+ *
+ * @param initialState - The initial boolean value
+ * @returns An object with the state observable and boolean-specific methods
+ *
+ * @example
+ * ```ts
+ * const [state, { setTrue, toggle }] = createBooleanState(false);
+ *
+ * state.subscribe((value: boolean) => {
+ *   console.log(value);
+ * }); // logs: false
+ *
+ * setTrue(); // logs: true
+ *
+ * toggle(); // logs: false
+ *
+ * toggle(); // logs: true
+ * ```
+ */
+export declare const createBooleanState: (initialState: boolean) => readonly [state: InitializedObservable<boolean>, Readonly<{
+    setTrue: () => void;
+    setFalse: () => void;
+    setState: (next: boolean) => boolean;
+    toggle: () => boolean;
+    updateState: (updateFn: (prev: boolean) => boolean) => boolean;
+    resetState: () => boolean;
+    getSnapshot: () => boolean;
+}>];
+//# sourceMappingURL=create-state.d.mts.map

package/dist/utils/create-state.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-state.d.mts","sourceRoot":"","sources":["../../src/utils/create-state.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAwB/D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,cAAc,CAAC,KACd,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,QAAQ,CAAC;IACP,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,CAAC;CACtB,CAAC,CAwBH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB,GAC7B,cAAc,OAAO,KACpB,SAAS,CACV,KAAK,EAAE,qBAAqB,CAAC,OAAO,CAAC,EACrC,QAAQ,CAAC;IACP,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;IACrC,MAAM,EAAE,MAAM,OAAO,CAAC;IACtB,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,KAAK,OAAO,CAAC;IAC/D,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC,CAqBH,CAAC"}

package/dist/utils/create-state.mjs

@@ -0,0 +1,92 @@
+import { createReducer } from './create-reducer.mjs';
+
+const reducer = (state, action) => {
+    switch (action.type) {
+        case 'set':
+            return action.nextState;
+        case 'update':
+            return action.updateFn(state);
+    }
+};
+/**
+ * Creates a reactive state container with getter and setter methods.
+ * Provides a simple state management solution with observable state.
+ *
+ * @template S - The type of the state
+ * @param initialState - The initial value of the state
+ * @returns An object containing the state observable and methods to manipulate it
+ *
+ * @example
+ * ```ts
+ * const [state, setState, { updateState, resetState }] = createState(0);
+ *
+ * state.subscribe((value: number) => {
+ *   console.log(value);
+ * }); // logs: 0
+ *
+ * setState(10); // logs: 10
+ *
+ * updateState((prev: number) => prev + 1); // logs: 11
+ *
+ * resetState(); // logs: 0
+ * ```
+ */
+const createState = (initialState) => {
+    const [state, dispatch, getSnapshot] = createReducer(reducer, initialState);
+    const updateState = (updateFn) => dispatch({ type: 'update', updateFn });
+    const setState = (nextState) => dispatch({ type: 'set', nextState });
+    const resetState = () => dispatch({ type: 'set', nextState: initialState });
+    return [
+        state,
+        setState,
+        {
+            updateState,
+            resetState,
+            getSnapshot,
+        },
+    ];
+};
+/**
+ * Creates a reactive boolean state with convenient methods for boolean operations.
+ * Extends `createState` with boolean-specific helpers like `toggle`, `setTrue`, and `setFalse`.
+ *
+ * @param initialState - The initial boolean value
+ * @returns An object with the state observable and boolean-specific methods
+ *
+ * @example
+ * ```ts
+ * const [state, { setTrue, toggle }] = createBooleanState(false);
+ *
+ * state.subscribe((value: boolean) => {
+ *   console.log(value);
+ * }); // logs: false
+ *
+ * setTrue(); // logs: true
+ *
+ * toggle(); // logs: false
+ *
+ * toggle(); // logs: true
+ * ```
+ */
+const createBooleanState = (initialState) => {
+    const [state, setState, { updateState, resetState, getSnapshot }] = createState(initialState);
+    return [
+        state,
+        {
+            setTrue: () => {
+                setState(true);
+            },
+            setFalse: () => {
+                setState(false);
+            },
+            toggle: () => updateState((s) => !s),
+            setState,
+            updateState,
+            resetState,
+            getSnapshot,
+        },
+    ];
+};
+
+export { createBooleanState, createState };
+//# sourceMappingURL=create-state.mjs.map

package/dist/utils/create-state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-state.mjs","sources":["../../src/utils/create-state.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAcA,MAAM,OAAO,GAAG,CAAK,KAAQ,EAAE,MAAiB,KAAO;AACrD,IAAA,QAAQ,MAAM,CAAC,IAAI;AACjB,QAAA,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,SAAS;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;;AAEnC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,WAAW,GAAG,CACzB,YAAe,KASb;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC,GAAG,aAAa,CAClD,OAAO,EACP,YAAY,CACb;AAED,IAAA,MAAM,WAAW,GAAG,CAAC,QAAwB,KAC3C,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAExC,IAAA,MAAM,QAAQ,GAAG,CAAC,SAAY,KAAQ,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;AAE1E,IAAA,MAAM,UAAU,GAAG,MACjB,QAAQ,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IAEpD,OAAO;QACL,KAAK;QACL,QAAQ;AACR,QAAA;YACE,WAAW;YACX,UAAU;YACV,WAAW;AACZ,SAAA;KACO;AACZ;AAEA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,kBAAkB,GAAG,CAChC,YAAqB,KAYnB;AACF,IAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,GAC/D,WAAW,CAAC,YAAY,CAAC;IAE3B,OAAO;QACL,KAAK;AACL,QAAA;YACE,OAAO,EAAE,MAAK;gBACZ,QAAQ,CAAC,IAAI,CAAC;YAChB,CAAC;YACD,QAAQ,EAAE,MAAK;gBACb,QAAQ,CAAC,KAAK,CAAC;YACjB,CAAC;AACD,YAAA,MAAM,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YACpC,QAAQ;YACR,WAAW;YACX,UAAU;YACV,WAAW;AACZ,SAAA;KACO;AACZ;;;;"}

package/dist/utils/index.d.mts

@@ -0,0 +1,4 @@
+export * from './create-event-emitter.mjs';
+export * from './create-reducer.mjs';
+export * from './create-state.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/utils/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/utils/index.mts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

package/dist/utils/index.mjs

@@ -0,0 +1,4 @@
+export { createEventEmitter, createValueEmitter } from './create-event-emitter.mjs';
+export { createReducer } from './create-reducer.mjs';
+export { createBooleanState, createState } from './create-state.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

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

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "synstate",
+  "version": "0.1.0",
+  "description": "Reactive Programming Library for TypeScript/JavaScript",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noshiro-pf/synstate.git"
+  },
+  "license": "Apache-2.0",
+  "author": "noshiro-pf <noshiro.pf@gmail.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsx ./scripts/cmd/build.mts",
+    "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
+    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
+    "check-all": "tsx ./scripts/cmd/check-all.mts",
+    "codemod": "convert-to-readonly '{src,samples,test}/**/*.{mts,tsx}'",
+    "doc": "tsx ./scripts/cmd/gen-docs.mts",
+    "doc:embed": "tsx ./scripts/cmd/embed-examples.mts",
+    "doc:embed:jsdoc": "tsx ./scripts/cmd/embed-examples-in-jsdoc.mts",
+    "doc:preview": "vite preview --config ./configs/vite.doc.config.ts",
+    "doc:watch": "typedoc --options ./configs/typedoc.config.mjs --watch",
+    "fmt": "pnpm run z:prettier .",
+    "gi": "run-s gi:src fmt",
+    "gi:src": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "pnpm run z:vitest:node run",
+    "test:all": "run-p test test:stream",
+    "test:browser": "pnpm run z:vitest --project='Browser' run",
+    "test:cov": "pnpm run z:vitest:node run --coverage",
+    "test:cov:ui": "vite preview --outDir ./coverage",
+    "test:stream": "pnpm run z:vitest:stream run",
+    "test:ui": "pnpm run z:vitest:node --ui",
+    "testw": "pnpm run z:vitest:node watch",
+    "tsc": "tsc --noEmit",
+    "tscw": "tsc --noEmit --watch",
+    "type-check": "tsc --noEmit",
+    "update-packages": "pnpm update --latest",
+    "z:prettier": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --ignore-path ../../.gitignore --ignore-unknown --no-error-on-unmatched-pattern --write",
+    "z:vitest": "vitest --config ./configs/vitest.config.mts",
+    "z:vitest:node": "pnpm run z:vitest --project='Node.js'",
+    "z:vitest:stream": "vitest --config ./configs/vitest.config.stream.ts"
+  },
+  "dependencies": {
+    "ts-data-forge": "^6.5.0"
+  },
+  "devDependencies": {
+    "@types/argparse": "^2.0.17",
+    "@types/react": "^19.2.14",
+    "argparse": "^2.0.1",
+    "react": "^19.2.4"
+  }
+}

package/src/core/class/child-observable-class.mts

@@ -0,0 +1,232 @@
+import { Arr } from 'ts-data-forge';
+import {
+  isManagerObservable,
+  type AsyncChildObservable,
+  type ChildObservable,
+  type InitializedObservable,
+  type InitializedSyncChildObservable,
+  type KeepInitialValueOperator,
+  type NonEmptyUnknownList,
+  type Observable,
+  type ObservableId,
+  type Operator,
+  type SyncChildObservable,
+  type WithInitialValueOperator,
+  type Wrap,
+} from '../types/index.mjs';
+import { binarySearch, issueUpdaterSymbol, maxDepth } from '../utils/index.mjs';
+import { ObservableBaseClass } from './observable-base-class.mjs';
+
+const registerChild = <A,>(
+  child: ChildObservable<A>,
+  parents: ChildObservable<A>['parents'],
+): void => {
+  for (const p of parents) {
+    p.addChild(child);
+  }
+
+  // register child to all reachable ManagerObservables
+  const mut_rest = Array.from(parents);
+
+  while (Arr.isNonEmpty(mut_rest)) {
+    const p = mut_rest.pop();
+
+    if (p === undefined) break;
+
+    if (isManagerObservable(p)) {
+      p.addDescendant(child);
+    } else {
+      // trace back dependency graph
+      mut_rest.push(...p.parents);
+    }
+  }
+};
+
+const tryComplete = <A,>({
+  hasSubscriber,
+  hasActiveChild,
+  parents,
+  complete,
+}: Readonly<{
+  hasSubscriber: boolean;
+  hasActiveChild: boolean;
+  parents: ChildObservable<A>['parents'];
+  complete: () => void;
+}>): void => {
+  // If there is no working parent node
+  if (parents.every((r) => r.isCompleted)) {
+    complete();
+
+    return;
+  }
+
+  // If there are no active child node
+  if (!hasSubscriber && !hasActiveChild) {
+    complete();
+  }
+
+  // propagate to parents
+  for (const par of parents) {
+    par.tryComplete();
+  }
+};
+
+export class AsyncChildObservableClass<A, const P extends NonEmptyUnknownList>
+  extends ObservableBaseClass<A, 'async child', number>
+  implements AsyncChildObservable<A, P>
+{
+  readonly parents;
+  #mut_procedure: readonly ChildObservable<unknown>[];
+  protected readonly descendantsIdSet: MutableSet<ObservableId>;
+
+  constructor({
+    parents,
+    depth = 1 + maxDepth(parents),
+    initialValue,
+  }: Readonly<{
+    parents: Wrap<P>;
+    depth?: number;
+    initialValue: ReturnType<AsyncChildObservable<A>['getSnapshot']>;
+  }>) {
+    super({
+      kind: 'async child',
+      depth,
+      initialValue,
+    });
+
+    this.parents = parents;
+
+    this.#mut_procedure = [];
+
+    this.descendantsIdSet = new Set<ObservableId>();
+
+    registerChild(this, parents);
+  }
+
+  // overload
+  addDescendant<B>(child: ChildObservable<B>): void {
+    if (this.descendantsIdSet.has(child.id)) return;
+
+    this.descendantsIdSet.add(child.id);
+
+    const insertPos = binarySearch(
+      this.#mut_procedure.map((a) => a.depth),
+      child.depth,
+    );
+
+    this.#mut_procedure = Arr.toInserted(this.#mut_procedure, insertPos, child);
+  }
+
+  startUpdate(nextValue: A): void {
+    const updaterSymbol = issueUpdaterSymbol();
+
+    this.setNext(nextValue, updaterSymbol);
+
+    for (const p of this.#mut_procedure) {
+      p.tryUpdate(updaterSymbol);
+    }
+  }
+
+  override complete(): void {
+    super.complete();
+
+    // propagate to parents
+    for (const par of this.parents) {
+      par.tryComplete();
+    }
+  }
+
+  override tryComplete(): void {
+    tryComplete({
+      complete: () => {
+        this.complete();
+      },
+      hasActiveChild: this.hasActiveChild(),
+      hasSubscriber: this.hasSubscriber,
+      parents: this.parents,
+    });
+  }
+}
+
+export class SyncChildObservableClass<A, const P extends NonEmptyUnknownList>
+  extends ObservableBaseClass<A, 'sync child', number>
+  implements SyncChildObservable<A, P>
+{
+  readonly parents;
+
+  constructor({
+    parents,
+    depth = 1 + maxDepth(parents),
+    initialValue,
+  }: Readonly<{
+    parents: Wrap<P>;
+    depth?: number;
+    initialValue: ReturnType<SyncChildObservable<A>['getSnapshot']>;
+  }>) {
+    super({
+      kind: 'sync child',
+      depth,
+      initialValue,
+    });
+
+    this.parents = parents;
+
+    registerChild(this, parents);
+  }
+
+  override complete(): void {
+    super.complete();
+
+    for (const par of this.parents) {
+      par.tryComplete();
+    }
+  }
+
+  override tryComplete(): void {
+    tryComplete({
+      complete: () => {
+        this.complete();
+      },
+      hasActiveChild: this.hasActiveChild(),
+      hasSubscriber: this.hasSubscriber,
+      parents: this.parents,
+    });
+  }
+}
+
+export class InitializedSyncChildObservableClass<
+  A,
+  const P extends NonEmptyUnknownList,
+>
+  extends SyncChildObservableClass<A, P>
+  implements InitializedSyncChildObservable<A, P>
+{
+  constructor({
+    parents,
+    depth = 1 + maxDepth(parents),
+    initialValue,
+  }: Readonly<{
+    parents: Wrap<P>;
+    depth?: number;
+    initialValue: ReturnType<InitializedSyncChildObservable<A>['getSnapshot']>;
+  }>) {
+    super({ parents, depth, initialValue });
+  }
+
+  override getSnapshot(): Some<A> {
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return super.getCurrentValue() as Some<A>;
+  }
+
+  override pipe<B>(
+    operator: KeepInitialValueOperator<A, B> | WithInitialValueOperator<A, B>,
+  ): InitializedObservable<B>;
+
+  override pipe<B>(operator: Operator<A, B>): Observable<B>;
+  override pipe<B>(operator: Operator<A, B>): Observable<B> {
+    return operator(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      this as unknown as InitializedObservable<A>,
+    );
+  }
+}

package/src/core/class/index.mts

@@ -0,0 +1,3 @@
+export * from './child-observable-class.mjs';
+export * from './observable-base-class.mjs';
+export * from './root-observable-class.mjs';

package/src/core/class/observable-base-class.mts

@@ -0,0 +1,186 @@
+import { Arr, Optional } from 'ts-data-forge';
+import {
+  type ChildObservable,
+  type InitializedObservable,
+  type Observable,
+  type ObservableBase,
+  type Operator,
+  type Subscriber,
+  type SubscriberId,
+  type Subscription,
+  type UpdaterSymbol,
+  type WithInitialValueOperator,
+} from '../types/index.mjs';
+import {
+  issueObservableId,
+  issueSubscriberId,
+  issueUpdaterSymbol,
+  toSubscriber,
+} from '../utils/index.mjs';
+
+export class ObservableBaseClass<
+  A,
+  Kind extends ObservableBase<A>['kind'],
+  Depth extends ObservableBase<A>['depth'],
+> implements ObservableBase<A> {
+  readonly id;
+  readonly kind: Kind;
+  readonly depth: Depth;
+  #mut_children: readonly ChildObservable<unknown>[];
+  readonly #subscribers: MutableMap<SubscriberId, Subscriber<A>>;
+  #mut_currentValue: ReturnType<ObservableBase<A>['getSnapshot']>;
+  #mut_isCompleted: ObservableBase<A>['isCompleted'];
+  #mut_updaterSymbol: ObservableBase<A>['updaterSymbol'];
+
+  constructor({
+    kind,
+    depth,
+    initialValue,
+  }: Readonly<{
+    kind: Kind;
+    depth: Depth;
+    initialValue: ReturnType<ObservableBase<A>['getSnapshot']>;
+  }>) {
+    this.kind = kind;
+
+    this.depth = depth;
+
+    this.id = issueObservableId();
+
+    this.#mut_currentValue = initialValue;
+
+    this.#mut_children = [];
+
+    this.#subscribers = new Map<SubscriberId, Subscriber<A>>();
+
+    this.#mut_isCompleted = false;
+
+    this.#mut_updaterSymbol = issueUpdaterSymbol();
+  }
+
+  addChild<B>(child: ChildObservable<B>): void {
+    this.#mut_children = Arr.toPushed(
+      this.#mut_children,
+
+      child as ChildObservable<unknown>,
+    );
+  }
+
+  getSnapshot(): ReturnType<ObservableBase<A>['getSnapshot']> {
+    return this.#mut_currentValue;
+  }
+
+  protected getCurrentValue(): ReturnType<ObservableBase<A>['getSnapshot']> {
+    return this.#mut_currentValue;
+  }
+
+  get isCompleted(): boolean {
+    return this.#mut_isCompleted;
+  }
+
+  get updaterSymbol(): UpdaterSymbol {
+    return this.#mut_updaterSymbol;
+  }
+
+  get hasSubscriber(): boolean {
+    return this.#subscribers.size > 0;
+  }
+
+  get hasChild(): boolean {
+    return Arr.isNonEmpty(this.#mut_children);
+  }
+
+  hasActiveChild(): boolean {
+    return this.#mut_children.some((c) => !c.isCompleted);
+  }
+
+  protected setNext(nextValue: A, updaterSymbol: UpdaterSymbol): void {
+    this.#mut_updaterSymbol = updaterSymbol;
+
+    this.#mut_currentValue = Optional.some(nextValue);
+
+    for (const s of this.#subscribers.values()) {
+      s.onNext(nextValue);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  tryUpdate(_updaterSymbol: UpdaterSymbol): void {
+    throw new Error('not implemented');
+  }
+
+  tryComplete(): void {
+    if (!this.hasSubscriber && !this.hasActiveChild()) {
+      this.complete();
+    }
+  }
+
+  complete(): void {
+    if (this.isCompleted) return; // terminate only once
+
+    // change state
+    this.#mut_isCompleted = true;
+
+    // run subscribers for the current value
+    for (const s of this.#subscribers.values()) {
+      s.onComplete();
+    }
+
+    // remove all subscribers
+    this.#subscribers.clear();
+
+    // propagate to children
+    for (const o of this.#mut_children) {
+      o.tryComplete();
+    }
+  }
+
+  pipe<B>(operator: WithInitialValueOperator<A, B>): InitializedObservable<B>;
+  pipe<B>(operator: Operator<A, B>): Observable<B>;
+  pipe<B>(operator: Operator<A, B>): Observable<B> {
+    return operator(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      this as unknown as InitializedObservable<A>,
+    );
+  }
+
+  subscribe(onNext: (v: A) => void, onComplete?: () => void): Subscription {
+    // first emit
+    const curr = this.getSnapshot();
+
+    if (Optional.isSome(curr)) {
+      onNext(curr.value);
+    }
+
+    if (this.isCompleted) {
+      if (onComplete !== undefined) {
+        onComplete();
+      }
+
+      return { unsubscribe: () => {} };
+    }
+
+    const id: SubscriberId = this.#addSubscriber(
+      toSubscriber(onNext, onComplete),
+    );
+
+    return {
+      unsubscribe: () => {
+        this.#removeSubscriber(id);
+      },
+    };
+  }
+
+  #addSubscriber(s: Subscriber<A>): SubscriberId {
+    // return the id of added subscriber
+    const id = issueSubscriberId();
+
+    this.#subscribers.set(id, s);
+
+    return id;
+  }
+
+  #removeSubscriber(id: SubscriberId): void {
+    this.#subscribers.delete(id);
+  }
+}