@okikio/observables 1.0.2

package/script/events.js

@@ -0,0 +1,458 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _EventBus_subscribers, _EventBus_closed;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+exports.createEventDispatcher = createEventDispatcher;
+exports.waitForEvent = waitForEvent;
+exports.withReplay = withReplay;
+/**
+ * Multicast event primitives built on top of the Observable runtime.
+ *
+ * This entrypoint is for the hot side of the library: shared event streams that
+ * multiple consumers can listen to at the same time. It exports `EventBus` for
+ * one-to-many pub/sub, `createEventDispatcher` for named and type-safe events,
+ * and helpers such as `withReplay` and `waitForEvent` for common coordination
+ * patterns.
+ *
+ * Use `Observable` when each subscription should start fresh work. Use this
+ * module when one emission should fan out to many listeners, such as UI events,
+ * app-wide notifications, or workflow status updates.
+ *
+ * @module
+ */
+require("./_dnt.polyfills.js");
+const observable_js_1 = require("./observable.js");
+const symbol_js_1 = require("./symbol.js");
+const queue_js_1 = require("./queue.js"); // Assume path to your queue utils
+/**
+ * A multicast event bus that extends {@link Observable<T>}, allowing
+ * emission of values to multiple subscribers and supporting both
+ * Observer-style and async-iterator consumption.
+ *
+ * @typeParam T - The type of values emitted by this bus.
+ *
+ * - Calling {@link emit} delivers the value to all active subscribers.
+ * - Calling {@link close} completes all subscribers and prevents further emissions.
+ * - Implements both {@link Symbol.dispose} and {@link Symbol.asyncDispose}
+ *   for cleanup in synchronous and asynchronous contexts.
+ *
+ * @example
+ * ```ts
+ * import { EventBus } from './EventBus.ts';
+ *
+ * // Create a bus for string messages
+ * const bus = new EventBus<string>();
+ *
+ * // Subscribe using Observer
+ * bus.events.subscribe({
+ *   next(msg) { console.log('Received:', msg); },
+ *   complete()  { console.log('Bus closed'); }
+ * });
+ *
+ * // Emit values
+ * bus.emit('hello');
+ * bus.emit('world');
+ *
+ * // Close the bus
+ * bus.close();
+ * ```
+ */
+class EventBus extends observable_js_1.Observable {
+    /**
+     * Construct a new EventBus instance.
+     *
+     * The base {@link Observable} constructor is invoked with the subscriber
+     * registration logic, adding and removing subscribers to the internal set.
+     */
+    constructor() {
+        super((subscriber) => {
+            if (__classPrivateFieldGet(this, _EventBus_closed, "f")) {
+                subscriber.complete?.();
+                return;
+            }
+            __classPrivateFieldGet(this, _EventBus_subscribers, "f").add(subscriber);
+            return () => {
+                __classPrivateFieldGet(this, _EventBus_subscribers, "f").delete(subscriber);
+            };
+        });
+        /** Active subscribers receiving emitted values */
+        _EventBus_subscribers.set(this, new Set());
+        /** Tracks whether the bus has been closed */
+        _EventBus_closed.set(this, false);
+    }
+    /**
+     * Exposes the bus itself as an {@link Observable<T>} for subscription.
+     *
+     * @returns The current instance as an Observable of T.
+     */
+    get events() {
+        return this;
+    }
+    /**
+     * Emit a value to all active subscribers.
+     *
+     * @param value - The value to deliver.
+     */
+    emit(value) {
+        if (__classPrivateFieldGet(this, _EventBus_closed, "f"))
+            return;
+        for (const subscriber of __classPrivateFieldGet(this, _EventBus_subscribers, "f")) {
+            subscriber.next?.(value);
+        }
+    }
+    /**
+     * Close the bus, completing all subscribers and preventing further emits.
+     */
+    close() {
+        if (__classPrivateFieldGet(this, _EventBus_closed, "f"))
+            return;
+        __classPrivateFieldSet(this, _EventBus_closed, true, "f");
+        for (const subscriber of __classPrivateFieldGet(this, _EventBus_subscribers, "f")) {
+            subscriber.complete?.();
+        }
+        __classPrivateFieldGet(this, _EventBus_subscribers, "f").clear();
+    }
+    /**
+     * Synchronous disposal method (for `using` syntax).
+     *
+     * Alias for {@link close}.
+     */
+    [(_EventBus_subscribers = new WeakMap(), _EventBus_closed = new WeakMap(), symbol_js_1.Symbol.dispose)]() {
+        this.close();
+    }
+    /**
+     * Asynchronous disposal method.
+     *
+     * Alias for {@link close}.
+     */
+    async [symbol_js_1.Symbol.asyncDispose]() {
+        return await this.close();
+    }
+}
+exports.EventBus = EventBus;
+/**
+ * Creates a strongly-typed event bus based on {@link EventBus}, ensuring
+ * that both `emit` and `on` methods enforce matching event names and payload types.
+ *
+ * @typeParam E - The event map type, mapping event names to payloads.
+ *
+ * @returns An object with the following methods:
+ * - `emit(name, payload)`: Emit an event.
+ * - `on(name, handler)`: Subscribe to a specific event.
+ * - `events`: Observable stream of all events.
+ * - `close()`: Close the bus and complete all subscribers.
+ *
+ * @example
+ * ```ts
+ * interface MyEvents {
+ *   message: { text: string };
+ *   error: { code: number; message: string };
+ * }
+ *
+ * const bus = createTypedEventBus<MyEvents>();
+ *
+ * // Subscribe to `message` events
+ * bus.on('message', payload => {
+ *   console.log('New message:', payload.text);
+ * });
+ *
+ * // Emit an event
+ * bus.emit('message', { text: 'Hello World' });
+ *
+ * // Close the bus when done
+ * bus.close();
+ * ```
+ */
+function createEventDispatcher() {
+    // Internal bus carries a union of all event types and payloads
+    const bus = new EventBus();
+    return {
+        /**
+         * Emit an event with the given name and payload.
+         * @param name - The event name.
+         * @param payload - The payload matching the event name.
+         */
+        emit(name, payload) {
+            bus.emit({ type: name, payload });
+        },
+        /**
+         * Subscribe to a specific event by name.
+         * Only events with a matching `type` will invoke the handler.
+         * @param name - The event name to listen for.
+         * @param handler - The callback invoked with the event payload.
+         * @returns A subscription object with `unsubscribe()`.
+         */
+        on(name, handler) {
+            return bus.events.subscribe({
+                next(event) {
+                    if (event.type === name) {
+                        handler(event.payload);
+                    }
+                },
+            });
+        },
+        /**
+         * Observable stream of all emitted events, carrying `{ type, payload }` objects.
+         */
+        events: bus.events,
+        /**
+         * Synchronous disposal method (for `using` syntax).
+         * Closes the bus and completes all subscribers.
+         */
+        [symbol_js_1.Symbol.dispose]() {
+            bus[symbol_js_1.Symbol.dispose]();
+        },
+        /**
+         * Asynchronous disposal method.
+         * Closes the bus and completes all subscribers.
+         */
+        [symbol_js_1.Symbol.asyncDispose]() {
+            return bus[symbol_js_1.Symbol.asyncDispose]();
+        },
+        /**
+         * Close the bus, completing all subscribers and preventing further emits.
+         */
+        close() {
+            bus.close();
+        },
+    };
+}
+/**
+ * Waits for the next occurrence of a specific event on a typed event bus.
+ * Resolves with the event payload when the named event fires.
+ * Can be aborted or optionally reject if the bus closes first.
+ *
+ * @typeParam E    - The event map type.
+ * @typeParam K    - The specific event key to listen for.
+ *
+ * @param bus      - An object with an `events` Observable emitting `{ type, payload }`.
+ * @param type     - The event name to wait for.
+ * @param options  - Optional signal to abort, and throwOnClose behavior.
+ * @returns A promise resolving to the payload of the event, or rejecting on error/abort/close.
+ *
+ * @example
+ * ```ts
+ * interface MyEvents {
+ *   data: { value: number };
+ *   done: void;
+ * }
+ *
+ * const bus = createTypedEventBus<MyEvents>();
+ *
+ * // somewhere else...
+ * waitForEvent(bus, 'data').then(payload => {
+ *   console.log('Data arrived:', payload.value);
+ * });
+ *
+ * // later
+ * bus.emit('data', { value: 42 });
+ * ```
+ */
+function waitForEvent(bus, type, { signal, throwOnClose = false } = {}) {
+    const { resolve, reject, promise } = Promise.withResolvers();
+    let settled = false;
+    // Immediate abort
+    if (signal?.aborted) {
+        reject(signal.reason);
+        return promise;
+    }
+    const subscription_ref = {};
+    function cleanup() {
+        subscription_ref.current?.unsubscribe?.();
+        signal?.removeEventListener?.("abort", onAbort);
+    }
+    function onAbort() {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        reject(signal.reason);
+    }
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+    subscription_ref.current = bus.events.subscribe({
+        next(event) {
+            if (settled)
+                return;
+            if (event.type === type) {
+                settled = true;
+                cleanup();
+                // cast payload to the correct type
+                resolve(event.payload);
+            }
+        },
+        error(err) {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(err);
+        },
+        complete() {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (throwOnClose) {
+                reject(new Error(`Stream closed before event "${String(type)}" fired`));
+            }
+            else {
+                resolve(undefined);
+            }
+        },
+    });
+    // We need both hooks for full race coverage:
+    // 1. the listener above catches aborts that happen before or during
+    //    subscription setup, so the promise rejects immediately
+    // 2. this re-check catches the narrow case where that abort happened before
+    //    `subscription_ref.current` was assigned, so we can still unsubscribe the
+    //    newly created subscription instead of leaving it attached. For example,
+    //    the signal can abort synchronously from inside `addEventListener()`
+    //    before control returns to the subscription assignment above.
+    if (signal?.aborted) {
+        onAbort();
+    }
+    return promise;
+}
+/**
+ * Adds replay capability to an Observable, multicasting values to multiple subscribers
+ * while maintaining a buffer of recent emissions.
+ *
+ * Without replay, each new subscriber triggers a fresh execution of the source Observable:
+ * ```ts
+ * const apiCall = new Observable(subscriber => {
+ *   console.log('Making expensive API call...');
+ *   fetch('/api/data').then(response => subscriber.next(response));
+ * });
+ *
+ * apiCall.subscribe(data1 => {}); // Triggers API call #1
+ * apiCall.subscribe(data2 => {}); // Triggers API call #2 (duplicate!)
+ * ```
+ *
+ * With replay, the source executes once and shares results:
+ * ```ts
+ * const sharedApi = withReplay(apiCall, { count: 1, mode: 'lazy' });
+ *
+ * sharedApi.subscribe(data1 => {}); // Triggers API call
+ * sharedApi.subscribe(data2 => {}); // Gets cached result, no new call!
+ * ```
+ *
+ * ## Memory Considerations
+ *
+ * - Buffer size directly impacts memory usage: `count * sizeof(T)`
+ * - 'eager' mode holds references even with no subscribers (potential memory leak)
+ * - 'lazy' mode clears buffer when all subscribers disconnect (automatic cleanup)
+ * - Consider using finite counts for long-running streams to prevent unbounded growth
+ *
+ * > **Note**: Infinite buffers are by default capped at 1000 items to prevent memory issues.
+ * > The primary reason for this cap is because some runtimes such as Deno and Node.js
+ * > litereally crash when you try to allocate Ininity-sized arrays.
+ *
+ * ## Performance Characteristics
+ *
+ * - Enqueue/Dequeue: O(1) constant time
+ * - New subscriber replay: O(n) where n = buffer size
+ * - Memory overhead: One queue + subscriber set + source subscription
+ *
+ * ## Edge Cases & Gotchas
+ *
+ * 1. **Late subscribers in eager mode**: May receive very old values if the source
+ *    emitted long ago and no cleanup occurred.
+ *
+ * 2. **Infinite buffers**: Without a count limit, buffers grow indefinitely.
+ *    Always set a reasonable count for production use.
+ *
+ * 3. **Error handling**: Errors are multicast to all subscribers but don't clear
+ *    the buffer. New subscribers still get the replay before the error.
+ *
+ * 4. **Completion**: The source completion is multicast, but the replay buffer
+ *    remains accessible to new subscribers (they get replay + completion).
+ *
+ * @param source The source Observable to add replay behavior to
+ * @param options Configuration for replay behavior
+ * @returns A new Observable with replay capability
+ *
+ * @example
+ * ```ts
+ * // Lazy mode - only buffers when subscribers are present
+ * const shared = withReplay(expensive, {
+ *   count: 5,
+ *   mode: 'lazy'  // Only run expensive when needed
+ * });
+ *
+ * // Eager mode - always buffering, like a flight recorder
+ * const eventLog = withReplay(systemEvents, {
+ *   count: 100,
+ *   mode: 'eager'  // Capture events even if no one's listening
+ * });
+ * ```
+ */
+function withReplay(source, { count = Infinity, mode = "lazy" } = {}) {
+    // Validate inputs
+    if (count <= 0) {
+        throw new Error(`Replay count must be positive, got {count}`);
+    }
+    // Shared state across all subscribers
+    // Using 1000 as a reasonable default for "infinite" to avoid memory issues
+    const buffer = (0, queue_js_1.createQueue)(count === Infinity ? 1000 : count);
+    const subscribers = new Set();
+    const observer = {
+        next(value) {
+            // Manage buffer capacity
+            if (count !== Infinity && (0, queue_js_1.isFull)(buffer)) {
+                (0, queue_js_1.dequeue)(buffer); // Remove oldest
+            }
+            (0, queue_js_1.enqueue)(buffer, value);
+            // Emit to all active subscribers
+            for (const sub of subscribers) {
+                sub.next(value);
+            }
+        },
+        error(err) {
+            for (const sub of subscribers) {
+                sub.error(err);
+            }
+        },
+        complete() {
+            for (const sub of subscribers) {
+                sub.complete();
+            }
+        },
+    };
+    const isEager = mode === "eager";
+    let shared = isEager ? source.subscribe(observer) : null;
+    /**
+     * Creates the replay Observable that new subscribers will receive.
+     */
+    return new observable_js_1.Observable((subscriber) => {
+        // Step 1: Replay buffered values to the new subscriber
+        (0, queue_js_1.forEach)(buffer, (item) => subscriber.next(item));
+        // Step 2: Add to active subscribers for future emissions
+        subscribers.add(subscriber);
+        // Step 3: Connect to source if needed (lazy mode, first subscriber)
+        if (!isEager && !shared && subscribers.size > 0) {
+            shared = source.subscribe(observer);
+        }
+        // Step 4: Return cleanup function
+        return () => {
+            subscribers.delete(subscriber);
+            // In lazy mode, disconnect and clear when last subscriber leaves
+            if (!isEager && subscribers.size === 0 && shared) {
+                shared.unsubscribe();
+                shared = null;
+                (0, queue_js_1.clear)(buffer); // Clear shared buffer when fully disconnected
+            }
+            // In eager mode, we keep the connection alive regardless
+        };
+    });
+}

package/script/helpers/_types.d.ts

@@ -0,0 +1,188 @@
+import type { ObservableError } from "../error.js";
+import type { Observable } from "../observable.js";
+/**
+ * Type representing a stream operator function
+ * Transforms a ReadableStream of type In to a ReadableStream of type Out
+ */
+export type Operator<In, Out> = (stream: ReadableStream<In>) => ReadableStream<Out>;
+/**
+ * Removes `ObservableError` from a type so operators can describe
+ * error-filtered output channels.
+ */
+export type ExcludeError<T> = Exclude<T, ObservableError>;
+/**
+ * Represents an operator slot in a pipeline where the previous operator may
+ * or may not have filtered `ObservableError` values out of the stream.
+ */
+export type OperatorItem<T, R> = Operator<T, R> | Operator<T, ExcludeError<R>>;
+/**
+ * Infers the item type contributed by either an Observable source or an
+ * operator in a pipe chain.
+ */
+export type InferSourceType<TSource extends unknown> = TSource extends Observable<unknown> ? InferObservableType<TSource> : TSource extends OperatorItem<unknown, unknown> ? InferOperatorItemOutputType<TSource> : TSource;
+/**
+ * Extracts the chunk type emitted by an operator.
+ */
+export type InferOperatorItemOutputType<TSource extends OperatorItem<any, any>> = ReturnType<TSource> extends ReadableStream<infer T> ? T : never;
+/**
+ * Extracts the value type emitted by an Observable.
+ */
+export type InferObservableType<TSource extends Observable<unknown>> = TSource extends Observable<infer R> ? R : any;
+/**
+ * Returns the first item in a non-empty tuple.
+ */
+export type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
+/**
+ * Returns the last item in any tuple shape.
+ */
+export type GenericLastTupleItem<T extends readonly any[]> = T extends [
+    ...infer _,
+    infer L
+] ? L : never;
+/**
+ * Returns the last tuple item only when it is a valid operator item.
+ */
+export type LastTupleItem<T extends readonly unknown[]> = GenericLastTupleItem<T> extends OperatorItem<any, any> ? GenericLastTupleItem<T> : never;
+/**
+ * Computes the Observable type returned by a `pipe()` call from the source and
+ * its final operator.
+ */
+export type ObservableWithPipe<TPipe extends readonly [Observable<unknown>, ...OperatorItem<any, unknown>[]]> = Observable<InferOperatorItemOutputType<LastTupleItem<TPipe>>>;
+/**
+ * Type representing how to handle errors in operators
+ * - "ignore" => errors wrapped in ObservableError will be used as values
+ *               and can then be transformed as the operator sees fit
+ * - "pass-through" => errors automatically pass through, meaning ObservableError
+ *                     will not appear as a value
+ * - "throw" => errors will cause the stream to throw and terminate
+ * - "manual" => errors are passed to the transform function to handle manually
+ */
+export type OperatorErrorMode = "ignore" | "pass-through" | "throw" | "manual";
+/**
+ * Base interface with properties shared across all transform options
+ */
+export interface BaseTransformOptions {
+    /**
+     * Optional name for the operator (used in error reporting)
+     */
+    name?: string;
+}
+/**
+ * Options for using an existing TransformStream
+ */
+export interface TransformStreamOptions<T, R> extends BaseTransformOptions {
+    /**
+     * An existing TransformStream to use for transformation
+     */
+    stream: (opts: TransformStreamOptions<T, R>) => TransformStream<T, R>;
+}
+/**
+ * Options for custom transformation logic
+ */
+export interface TransformFunctionOptions<T, R> extends BaseTransformOptions {
+    /**
+     * How to handle errors in the stream:
+     * - "ignore" => errors wrapped in ObservableError will be used as values
+     *               and can then be transformed as the operator sees fit
+     * - "pass-through" => errors automatically pass through, meaning ObservableError
+     *                     will not appear as a value
+     * - "throw" => errors will cause the stream to throw and terminate
+     * - "manual" => errors are passed to the transform function to handle manually
+     * @default "pass-through"
+     */
+    errorMode?: OperatorErrorMode;
+    /**
+     * Function to transform each chunk
+     * @param chunk - The input chunk
+     * @param controller - The TransformStreamDefaultController
+     * @returns The transformed chunk(s) or undefined to filter out the chunk
+     */
+    transform: (chunk: T, controller: TransformStreamDefaultController<R>) => R | undefined | void | null | Promise<R | undefined | void | null>;
+    /**
+     * Function called when the stream is about to close
+     * Can enqueue final chunks before closing
+     * @param controller - The TransformStreamDefaultController
+     */
+    flush?: (controller: TransformStreamDefaultController<R>) => void | Promise<void>;
+    /**
+     * Called when the stream starts, before processing any chunks
+     * @param controller - The TransformStreamDefaultController
+     */
+    start?: (controller: TransformStreamDefaultController<R>) => void | Promise<void>;
+    /**
+     * Called when the stream is cancelled before natural completion
+     */
+    cancel?: (reason?: unknown) => void | Promise<void>;
+}
+/**
+ * Union type for all createOperator options
+ */
+export type CreateOperatorOptions<T, R> = TransformStreamOptions<T, R> | TransformFunctionOptions<T, R>;
+/**
+ * Options for stateful transformation logic
+ */
+export interface StatefulTransformFunctionOptions<T, R, S> extends BaseTransformOptions {
+    /**
+     * How to handle errors in the stream:
+     * - "ignore" => errors wrapped in ObservableError will be used as values
+     *               and can then be transformed as the operator sees fit
+     * - "pass-through" => errors automatically pass through, meaning ObservableError
+     *                     will not appear as a value
+     * - "throw" => errors will cause the stream to throw and terminate
+     * - "manual" => errors are passed to the transform function to handle manually
+     * @default "pass-through"
+     */
+    errorMode?: OperatorErrorMode;
+    /**
+     * Function to create the initial state
+     * @returns The initial state
+     */
+    createState: () => S;
+    /**
+     * Function to transform each chunk, with access to the current state
+     * @param chunk - The input chunk
+     * @param state - The current state (can be modified)
+     * @param controller - The TransformStreamDefaultController
+     */
+    transform: (chunk: T, state: S, controller: TransformStreamDefaultController<R>) => void | Promise<void>;
+    /**
+     * Function called when the stream is about to close
+     * Can enqueue final chunks based on the state
+     * @param state - The final state
+     * @param controller - The TransformStreamDefaultController
+     */
+    flush?: (state: S, controller: TransformStreamDefaultController<R>) => void | Promise<void>;
+    /**
+     * Called when the stream starts, before processing any chunks
+     * @param state - The initial state
+     * @param controller - The TransformStreamDefaultController
+     */
+    start?: (state: S, controller: TransformStreamDefaultController<R>) => void | Promise<void>;
+    /**
+     * Called when the stream is cancelled before natural completion
+     * @param state - The current state
+     */
+    cancel?: (state: S, reason?: unknown) => void | Promise<void>;
+}
+/**
+ * Context for transform handlers
+ * This interface provides additional information for the transform handler,
+ * such as the operator name, whether it is
+ * stateful, and any associated state.
+ * @typeParam S - State type (if applicable)
+ */
+export interface TransformHandlerContext<S extends unknown = undefined> {
+    /**
+     * Human-readable operator name used in wrapped error messages.
+     */
+    operatorName?: string;
+    /**
+     * Indicates that the lifecycle handler should pass shared state through.
+     */
+    isStateful?: boolean;
+    /**
+     * Shared operator state for stateful transforms.
+     */
+    state?: S;
+}
+//# sourceMappingURL=_types.d.ts.map

package/script/helpers/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../src/helpers/_types.ts"],"names":[],"mappings":"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"}

package/script/helpers/_types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });