reactor-core-ts 2.1.6 → 3.2.2

package/dist/sinks/subscribers.js

@@ -0,0 +1,32 @@
+//#region src/sinks/subscribers.ts
+/** Adds a queue without allocating a Set for the common single-subscriber case. */
+function addSinkSubscriber(subscribers, queue) {
+	if (subscribers === void 0) return queue;
+	if (subscribers instanceof Set) {
+		subscribers.add(queue);
+		return subscribers;
+	}
+	return subscribers === queue ? subscribers : /* @__PURE__ */ new Set([subscribers, queue]);
+}
+/** Removes a queue and releases multi-subscriber storage when it becomes empty. */
+function removeSinkSubscriber(subscribers, queue) {
+	if (subscribers === void 0) return;
+	if (subscribers instanceof Set) {
+		subscribers.delete(queue);
+		return subscribers.size === 0 ? void 0 : subscribers;
+	}
+	return subscribers === queue ? void 0 : subscribers;
+}
+/** Clears multi-subscriber storage before the owner drops its reference. */
+function clearSinkSubscribers(subscribers) {
+	if (subscribers instanceof Set) subscribers.clear();
+}
+/** Returns the number of active queues in compact subscriber storage. */
+function sinkSubscriberCount(subscribers) {
+	if (subscribers === void 0) return 0;
+	return subscribers instanceof Set ? subscribers.size : 1;
+}
+//#endregion
+export { addSinkSubscriber, clearSinkSubscribers, removeSinkSubscriber, sinkSubscriberCount };
+
+//# sourceMappingURL=subscribers.js.map

package/dist/sinks/subscribers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribers.js","names":[],"sources":["../../src/sinks/subscribers.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Compact subscriber storage shared by sink implementations.\n */\nimport type {AsyncQueue} from \"@/internal/async-queue.js\";\n\n/** Compact storage for one or many active sink subscriber queues. */\nexport type SinkSubscribers<T> = AsyncQueue<T> | Set<AsyncQueue<T>>;\n\n/** Adds a queue without allocating a Set for the common single-subscriber case. */\nexport function addSinkSubscriber<T>(\n    subscribers: SinkSubscribers<T> | undefined,\n    queue: AsyncQueue<T>\n): SinkSubscribers<T> {\n    if (subscribers === undefined) {\n        return queue;\n    }\n    if (subscribers instanceof Set) {\n        subscribers.add(queue);\n        return subscribers;\n    }\n    return subscribers === queue ? subscribers : new Set([subscribers, queue]);\n}\n\n/** Removes a queue and releases multi-subscriber storage when it becomes empty. */\nexport function removeSinkSubscriber<T>(\n    subscribers: SinkSubscribers<T> | undefined,\n    queue: AsyncQueue<T>\n): SinkSubscribers<T> | undefined {\n    if (subscribers === undefined) {\n        return undefined;\n    }\n    if (subscribers instanceof Set) {\n        subscribers.delete(queue);\n        return subscribers.size === 0 ? undefined : subscribers;\n    }\n    return subscribers === queue ? undefined : subscribers;\n}\n\n/** Clears multi-subscriber storage before the owner drops its reference. */\nexport function clearSinkSubscribers<T>(subscribers: SinkSubscribers<T> | undefined): void {\n    if (subscribers instanceof Set) {\n        subscribers.clear();\n    }\n}\n\n/** Returns the number of active queues in compact subscriber storage. */\nexport function sinkSubscriberCount<T>(subscribers: SinkSubscribers<T> | undefined): number {\n    if (subscribers === undefined) {\n        return 0;\n    }\n    return subscribers instanceof Set ? subscribers.size : 1;\n}\n"],"mappings":";;AAUA,SAAgB,kBACZ,aACA,OACkB;CAClB,IAAI,gBAAgB,QAChB,OAAO;CAEX,IAAI,uBAAuB,KAAK;EAC5B,YAAY,IAAI,KAAK;EACrB,OAAO;CACX;CACA,OAAO,gBAAgB,QAAQ,8BAAc,IAAI,IAAI,CAAC,aAAa,KAAK,CAAC;AAC7E;;AAGA,SAAgB,qBACZ,aACA,OAC8B;CAC9B,IAAI,gBAAgB,QAChB;CAEJ,IAAI,uBAAuB,KAAK;EAC5B,YAAY,OAAO,KAAK;EACxB,OAAO,YAAY,SAAS,IAAI,SAAY;CAChD;CACA,OAAO,gBAAgB,QAAQ,SAAY;AAC/C;;AAGA,SAAgB,qBAAwB,aAAmD;CACvF,IAAI,uBAAuB,KACvB,YAAY,MAAM;AAE1B;;AAGA,SAAgB,oBAAuB,aAAqD;CACxF,IAAI,gBAAgB,QAChB,OAAO;CAEX,OAAO,uBAAuB,MAAM,YAAY,OAAO;AAC3D"}

package/dist/sinks/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * @packageDocumentation
+ * Sink specifications and default browser-oriented sink implementations.
+ */
+import type { Disposable } from "../core/types.js";
+import type { Flux } from "../publisher/flux.js";
+import type { Mono } from "../publisher/mono.js";
+import type { PublisherInput } from "../publisher/types.js";
+import { SignalType } from "../signal/signal-type.js";
+/** Result of a sink emission attempt. */
+export declare enum EmitResult {
+    /** Emission succeeded. */
+    OK = "OK",
+    /** Emission failed because the sink has already terminated. */
+    FAIL_TERMINATED = "FAIL_TERMINATED",
+    /** Emission failed because buffering capacity was exhausted. */
+    FAIL_OVERFLOW = "FAIL_OVERFLOW",
+    /** Emission failed because the sink was cancelled. */
+    FAIL_CANCELLED = "FAIL_CANCELLED",
+    /** Emission failed because concurrent emission was detected. */
+    FAIL_NON_SERIALIZED = "FAIL_NON_SERIALIZED",
+    /** Emission failed because no subscriber was present. */
+    FAIL_ZERO_SUBSCRIBER = "FAIL_ZERO_SUBSCRIBER"
+}
+/** Error thrown when an emitting API cannot recover from an emission failure. */
+export declare class EmissionException extends Error {
+    /** Failed emission result that caused this exception. */
+    readonly reason: EmitResult;
+    /** Creates an emission exception for a failed result. */
+    constructor(reason: EmitResult, cause?: unknown);
+}
+/** Callback that decides whether a failed emission should be retried. */
+export type EmitFailureHandler = (signalType: SignalType, emitResult: EmitResult) => boolean;
+/** Built-in emission failure handlers. */
+export declare const EmitFailureHandlers: {
+    /** Fails immediately without retrying. */
+    FAIL_FAST: () => boolean;
+    /** Retries non-serialized emissions until the busy-loop deadline expires. */
+    busyLooping(durationMs: number): EmitFailureHandler;
+};
+/** Sink that can only emit a terminal signal. */
+export interface EmptySink<T> {
+    /** Returns the Mono view of this sink. */
+    asMono(): Mono<T>;
+    /** Returns current active subscriber count. */
+    currentSubscriberCount(): number;
+    /** Attempts to complete this sink. */
+    tryEmitEmpty(): EmitResult;
+    /** Attempts to fail this sink. */
+    tryEmitError(error: unknown): EmitResult;
+    /** Completes this sink using the provided failure handler. */
+    emitEmpty(handler?: EmitFailureHandler): void;
+    /** Fails this sink using the provided failure handler. */
+    emitError(error: unknown, handler?: EmitFailureHandler): void;
+    /** Handles an emission failure and returns true when the caller should retry. */
+    onEmitFailure(signalType: SignalType, emitResult: EmitResult): boolean;
+}
+/** Sink that can emit zero or one value followed by completion. */
+export interface OneSink<T> extends EmptySink<T> {
+    /** Attempts to emit a value and complete this sink. */
+    tryEmitValue(value: T): EmitResult;
+    /** Emits a value using the provided failure handler. */
+    emitValue(value: T, handler?: EmitFailureHandler): void;
+}
+/** Sink that can emit multiple values and a terminal signal. */
+export interface ManySink<T> {
+    /** Returns the Flux view of this sink. */
+    asFlux(): Flux<T>;
+    /** Attempts to emit a value. */
+    tryEmitNext(value: T): EmitResult;
+    /** Attempts to complete this sink. */
+    tryEmitComplete(): EmitResult;
+    /** Attempts to fail this sink. */
+    tryEmitError(error: unknown): EmitResult;
+    /** Emits a value using the provided failure handler. */
+    emitNext(value: T, handler?: EmitFailureHandler): void;
+    /** Completes this sink using the provided failure handler. */
+    emitComplete(handler?: EmitFailureHandler): void;
+    /** Fails this sink using the provided failure handler. */
+    emitError(error: unknown, handler?: EmitFailureHandler): void;
+    /** Returns current active subscriber count. */
+    currentSubscriberCount(): number;
+    /** Subscribes this sink to an upstream publisher. */
+    subscribeTo(source: PublisherInput<T>): void;
+    /** Handles an emission failure and returns true when the caller should retry. */
+    onEmitFailure(signalType: SignalType, emitResult: EmitResult): boolean;
+}
+/** Root builder for many-valued sink variants. */
+export interface ManySpec {
+    /** Returns unicast sink builders. */
+    unicast(): UnicastSpec;
+    /** Returns multicast sink builders. */
+    multicast(): MulticastSpec;
+    /** Returns replay sink builders. */
+    replay(): ReplaySpec;
+}
+/** Builder for unicast many-valued sinks. */
+export interface UnicastSpec {
+    /** Creates a unicast sink with backpressure buffering. */
+    onBackpressureBuffer<T>(): ManySink<T>;
+    /** Creates a unicast sink that fails when backpressure cannot be honored. */
+    onBackpressureError<T>(): ManySink<T>;
+}
+/** Builder for sinks that can subscribe to one upstream publisher. */
+export interface ManyWithUpstreamSpec {
+    /** Creates a multicast sink that buffers and can subscribe to one upstream publisher. */
+    multicastOnBackpressureBuffer<T>(): ManySink<T>;
+}
+/** Builder for multicast many-valued sinks. */
+export interface MulticastSpec {
+    /** Creates a multicast sink with backpressure buffering. */
+    onBackpressureBuffer<T>(): ManySink<T>;
+    /** Creates a direct multicast sink that fails when no subscriber is present. */
+    directAllOrNothing<T>(): ManySink<T>;
+    /** Creates a direct best-effort multicast sink. */
+    directBestEffort<T>(): ManySink<T>;
+}
+/** Builder for replaying many-valued sinks. */
+export interface ReplaySpec {
+    /** Replays all emitted values to late subscribers. */
+    all<T>(): ManySink<T>;
+    /** Replays up to `historySize` values to late subscribers. */
+    limit<T>(historySize: number): ManySink<T>;
+    /** Replays only the latest value to late subscribers. */
+    latest<T>(): ManySink<T>;
+    /** Replays the latest value or the provided default before the first emission. */
+    latestOrDefault<T>(value: T): ManySink<T>;
+}
+/** Disposable type alias used by sink implementations. */
+export type SinkDisposable = Disposable;
+/** Repeatedly invokes an emission attempt or throws when failure is not recoverable. */
+export declare function emitOrThrow(signalType: SignalType, emit: () => EmitResult, handler: EmitFailureHandler, cause?: unknown): void;
+/** Returns true when the emission result is successful. */
+export declare function isEmitSuccess(result: EmitResult): boolean;
+/** Returns true when the emission result is a failure. */
+export declare function isEmitFailure(result: EmitResult): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/sinks/types.d.ts.map

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

package/dist/sinks/types.js

@@ -0,0 +1,58 @@
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/defineProperty.js";
+import { SignalType } from "../signal/signal-type.js";
+//#region src/sinks/types.ts
+/** Result of a sink emission attempt. */
+var EmitResult = /* @__PURE__ */ function(EmitResult) {
+	/** Emission succeeded. */
+	EmitResult["OK"] = "OK";
+	/** Emission failed because the sink has already terminated. */
+	EmitResult["FAIL_TERMINATED"] = "FAIL_TERMINATED";
+	/** Emission failed because buffering capacity was exhausted. */
+	EmitResult["FAIL_OVERFLOW"] = "FAIL_OVERFLOW";
+	/** Emission failed because the sink was cancelled. */
+	EmitResult["FAIL_CANCELLED"] = "FAIL_CANCELLED";
+	/** Emission failed because concurrent emission was detected. */
+	EmitResult["FAIL_NON_SERIALIZED"] = "FAIL_NON_SERIALIZED";
+	/** Emission failed because no subscriber was present. */
+	EmitResult["FAIL_ZERO_SUBSCRIBER"] = "FAIL_ZERO_SUBSCRIBER";
+	return EmitResult;
+}({});
+/** Error thrown when an emitting API cannot recover from an emission failure. */
+var EmissionException = class extends Error {
+	/** Creates an emission exception for a failed result. */
+	constructor(reason, cause) {
+		super(cause === void 0 ? `Emission failed with ${reason}` : `Emission failed with ${reason}: ${String(cause)}`);
+		_defineProperty(
+			this,
+			/** Failed emission result that caused this exception. */
+			"reason",
+			void 0
+		);
+		this.reason = reason;
+		this.name = "EmissionException";
+	}
+};
+/** Built-in emission failure handlers. */
+var EmitFailureHandlers = {
+	/** Fails immediately without retrying. */
+	FAIL_FAST: () => false,
+	/** Retries non-serialized emissions until the busy-loop deadline expires. */
+	busyLooping(durationMs) {
+		return (signalType, emitResult) => {
+			const deadline = Date.now() + durationMs;
+			return signalType !== SignalType.ERROR && emitResult === "FAIL_NON_SERIALIZED" && Date.now() < deadline;
+		};
+	}
+};
+/** Repeatedly invokes an emission attempt or throws when failure is not recoverable. */
+function emitOrThrow(signalType, emit, handler, cause) {
+	for (;;) {
+		const result = emit();
+		if (result === "OK") return;
+		if (!handler(signalType, result)) throw new EmissionException(result, cause);
+	}
+}
+//#endregion
+export { EmissionException, EmitFailureHandlers, EmitResult, emitOrThrow };
+
+//# sourceMappingURL=types.js.map

package/dist/sinks/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/sinks/types.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Sink specifications and default browser-oriented sink implementations.\n */\nimport type {Disposable} from \"@/core/types.js\";\nimport type {Flux} from \"@/publisher/flux.js\";\nimport type {Mono} from \"@/publisher/mono.js\";\nimport type {PublisherInput} from \"@/publisher/types.js\";\nimport {SignalType} from \"@/signal/signal-type.js\";\n\n/** Result of a sink emission attempt. */\nexport enum EmitResult {\n    /** Emission succeeded. */\n    OK = \"OK\",\n    /** Emission failed because the sink has already terminated. */\n    FAIL_TERMINATED = \"FAIL_TERMINATED\",\n    /** Emission failed because buffering capacity was exhausted. */\n    FAIL_OVERFLOW = \"FAIL_OVERFLOW\",\n    /** Emission failed because the sink was cancelled. */\n    FAIL_CANCELLED = \"FAIL_CANCELLED\",\n    /** Emission failed because concurrent emission was detected. */\n    FAIL_NON_SERIALIZED = \"FAIL_NON_SERIALIZED\",\n    /** Emission failed because no subscriber was present. */\n    FAIL_ZERO_SUBSCRIBER = \"FAIL_ZERO_SUBSCRIBER\"\n}\n\n/** Error thrown when an emitting API cannot recover from an emission failure. */\nexport class EmissionException extends Error {\n    /** Failed emission result that caused this exception. */\n    public readonly reason: EmitResult;\n\n    /** Creates an emission exception for a failed result. */\n    public constructor(reason: EmitResult, cause?: unknown) {\n        super(cause === undefined ? `Emission failed with ${reason}` : `Emission failed with ${reason}: ${String(cause)}`);\n        this.reason = reason;\n        this.name = \"EmissionException\";\n    }\n}\n\n/** Callback that decides whether a failed emission should be retried. */\nexport type EmitFailureHandler = (signalType: SignalType, emitResult: EmitResult) => boolean;\n\n/** Built-in emission failure handlers. */\nexport const EmitFailureHandlers = {\n    /** Fails immediately without retrying. */\n    FAIL_FAST: () => false,\n\n    /** Retries non-serialized emissions until the busy-loop deadline expires. */\n    busyLooping(durationMs: number): EmitFailureHandler {\n        return (signalType, emitResult) => {\n            const deadline = Date.now() + durationMs;\n            return signalType !== SignalType.ERROR && emitResult === EmitResult.FAIL_NON_SERIALIZED && Date.now() < deadline;\n        };\n    }\n};\n\n/** Sink that can only emit a terminal signal. */\nexport interface EmptySink<T> {\n    /** Returns the Mono view of this sink. */\n    asMono(): Mono<T>;\n\n    /** Returns current active subscriber count. */\n    currentSubscriberCount(): number;\n\n    /** Attempts to complete this sink. */\n    tryEmitEmpty(): EmitResult;\n\n    /** Attempts to fail this sink. */\n    tryEmitError(error: unknown): EmitResult;\n\n    /** Completes this sink using the provided failure handler. */\n    emitEmpty(handler?: EmitFailureHandler): void;\n\n    /** Fails this sink using the provided failure handler. */\n    emitError(error: unknown, handler?: EmitFailureHandler): void;\n\n    /** Handles an emission failure and returns true when the caller should retry. */\n    onEmitFailure(signalType: SignalType, emitResult: EmitResult): boolean;\n}\n\n/** Sink that can emit zero or one value followed by completion. */\nexport interface OneSink<T> extends EmptySink<T> {\n    /** Attempts to emit a value and complete this sink. */\n    tryEmitValue(value: T): EmitResult;\n\n    /** Emits a value using the provided failure handler. */\n    emitValue(value: T, handler?: EmitFailureHandler): void;\n}\n\n/** Sink that can emit multiple values and a terminal signal. */\nexport interface ManySink<T> {\n    /** Returns the Flux view of this sink. */\n    asFlux(): Flux<T>;\n\n    /** Attempts to emit a value. */\n    tryEmitNext(value: T): EmitResult;\n\n    /** Attempts to complete this sink. */\n    tryEmitComplete(): EmitResult;\n\n    /** Attempts to fail this sink. */\n    tryEmitError(error: unknown): EmitResult;\n\n    /** Emits a value using the provided failure handler. */\n    emitNext(value: T, handler?: EmitFailureHandler): void;\n\n    /** Completes this sink using the provided failure handler. */\n    emitComplete(handler?: EmitFailureHandler): void;\n\n    /** Fails this sink using the provided failure handler. */\n    emitError(error: unknown, handler?: EmitFailureHandler): void;\n\n    /** Returns current active subscriber count. */\n    currentSubscriberCount(): number;\n\n    /** Subscribes this sink to an upstream publisher. */\n    subscribeTo(source: PublisherInput<T>): void;\n\n    /** Handles an emission failure and returns true when the caller should retry. */\n    onEmitFailure(signalType: SignalType, emitResult: EmitResult): boolean;\n}\n\n/** Root builder for many-valued sink variants. */\nexport interface ManySpec {\n    /** Returns unicast sink builders. */\n    unicast(): UnicastSpec;\n\n    /** Returns multicast sink builders. */\n    multicast(): MulticastSpec;\n\n    /** Returns replay sink builders. */\n    replay(): ReplaySpec;\n}\n\n/** Builder for unicast many-valued sinks. */\nexport interface UnicastSpec {\n    /** Creates a unicast sink with backpressure buffering. */\n    onBackpressureBuffer<T>(): ManySink<T>;\n\n    /** Creates a unicast sink that fails when backpressure cannot be honored. */\n    onBackpressureError<T>(): ManySink<T>;\n}\n\n/** Builder for sinks that can subscribe to one upstream publisher. */\nexport interface ManyWithUpstreamSpec {\n    /** Creates a multicast sink that buffers and can subscribe to one upstream publisher. */\n    multicastOnBackpressureBuffer<T>(): ManySink<T>;\n}\n\n/** Builder for multicast many-valued sinks. */\nexport interface MulticastSpec {\n    /** Creates a multicast sink with backpressure buffering. */\n    onBackpressureBuffer<T>(): ManySink<T>;\n\n    /** Creates a direct multicast sink that fails when no subscriber is present. */\n    directAllOrNothing<T>(): ManySink<T>;\n\n    /** Creates a direct best-effort multicast sink. */\n    directBestEffort<T>(): ManySink<T>;\n}\n\n/** Builder for replaying many-valued sinks. */\nexport interface ReplaySpec {\n    /** Replays all emitted values to late subscribers. */\n    all<T>(): ManySink<T>;\n\n    /** Replays up to `historySize` values to late subscribers. */\n    limit<T>(historySize: number): ManySink<T>;\n\n    /** Replays only the latest value to late subscribers. */\n    latest<T>(): ManySink<T>;\n\n    /** Replays the latest value or the provided default before the first emission. */\n    latestOrDefault<T>(value: T): ManySink<T>;\n}\n\n/** Disposable type alias used by sink implementations. */\nexport type SinkDisposable = Disposable;\n\n/** Repeatedly invokes an emission attempt or throws when failure is not recoverable. */\nexport function emitOrThrow(\n    signalType: SignalType,\n    emit: () => EmitResult,\n    handler: EmitFailureHandler,\n    cause?: unknown\n): void {\n    for (; ;) {\n        const result = emit();\n        if (result === EmitResult.OK) {\n            return;\n        }\n        if (!handler(signalType, result)) {\n            throw new EmissionException(result, cause);\n        }\n    }\n}\n\n/** Returns true when the emission result is successful. */\nexport function isEmitSuccess(result: EmitResult): boolean {\n    return result === EmitResult.OK;\n}\n\n/** Returns true when the emission result is a failure. */\nexport function isEmitFailure(result: EmitResult): boolean {\n    return result !== EmitResult.OK;\n}\n"],"mappings":";;;;AAWA,IAAY,aAAL,yBAAA,YAAA;;CAEH,WAAA,QAAA;;CAEA,WAAA,qBAAA;;CAEA,WAAA,mBAAA;;CAEA,WAAA,oBAAA;;CAEA,WAAA,yBAAA;;CAEA,WAAA,0BAAA;;AACJ,EAAA,CAAA,CAAA;;AAGA,IAAa,oBAAb,cAAuC,MAAM;;CAKzC,YAAmB,QAAoB,OAAiB;EACpD,MAAM,UAAU,SAAY,wBAAwB,WAAW,wBAAwB,OAAO,IAAI,OAAO,KAAK,GAAG;;;;GAJrH;;;EAKI,KAAK,SAAS;EACd,KAAK,OAAO;CAChB;AACJ;;AAMA,IAAa,sBAAsB;;CAE/B,iBAAiB;;CAGjB,YAAY,YAAwC;EAChD,QAAQ,YAAY,eAAe;GAC/B,MAAM,WAAW,KAAK,IAAI,IAAI;GAC9B,OAAO,eAAe,WAAW,SAAS,eAAA,yBAAiD,KAAK,IAAI,IAAI;EAC5G;CACJ;AACJ;;AA8HA,SAAgB,YACZ,YACA,MACA,SACA,OACI;CACJ,SAAU;EACN,MAAM,SAAS,KAAK;EACpB,IAAI,WAAA,MACA;EAEJ,IAAI,CAAC,QAAQ,YAAY,MAAM,GAC3B,MAAM,IAAI,kBAAkB,QAAQ,KAAK;CAEjD;AACJ"}

package/dist/subscription/core-subscriber.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @packageDocumentation
+ * Context-aware subscriber contract.
+ */
+import type { Context } from "../context/context.js";
+import type { Subscriber } from "./subscriber.js";
+/** Subscriber variant that can expose a Reactor context to operators. */
+export interface CoreSubscriber<T> extends Subscriber<T> {
+    /** Returns the subscriber context used for contextual operators. */
+    currentContext?(): Context;
+}
+//# sourceMappingURL=core-subscriber.d.ts.map

package/dist/subscription/core-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-subscriber.d.ts","sourceRoot":"","sources":["../../src/subscription/core-subscriber.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAE7D,yEAAyE;AACzE,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IACpD,oEAAoE;IACpE,cAAc,CAAC,IAAI,OAAO,CAAC;CAC9B"}

package/dist/subscription/iterable-subscription.d.ts

@@ -0,0 +1,64 @@
+import type { Context } from "../context/context.js";
+import type { Flux } from "../publisher/flux.js";
+import type { Subscriber } from "./subscriber.js";
+import type { Subscription } from "./subscription.js";
+/** Subscription implementation that drains a Flux only when demand is requested. */
+export declare class IterableSubscription<T> implements Subscription {
+    /** Abort controller used to cancel the active source iterator. */
+    private readonly controller;
+    /** Lazily created async iterator over the backing Flux. */
+    private asyncIterator;
+    /** Lazily created synchronous iterator over the backing Flux. */
+    private syncIterator;
+    /** Tracks whether the source iterator has been assembled. */
+    private started;
+    /** Stores a synchronous source assembly failure until it can be signalled. */
+    private startFailure;
+    /** Tracks whether source assembly failed synchronously. */
+    private hasStartFailure;
+    /** Prefetched async result used to detect completion with zero demand. */
+    private pendingAsyncNext;
+    /** Prefetched sync result used to detect completion with zero demand. */
+    private pendingSyncNext;
+    /** Outstanding downstream demand. */
+    private requested;
+    /** Guards against concurrent drain loops. */
+    private draining;
+    /** Tracks downstream cancellation. */
+    private cancelled;
+    /** Tracks terminal completion or failure delivery. */
+    private terminated;
+    /** Source Flux drained by this subscription. */
+    private readonly flux;
+    /** Downstream subscriber receiving signals. */
+    private readonly subscriber;
+    /** Context used for the source iteration. */
+    private readonly context;
+    /** Creates a subscription for the provided Flux and subscriber. */
+    constructor(flux: Flux<T>, subscriber: Subscriber<T>, context: Context);
+    /** Starts source assembly without pulling any values from it. */
+    start(): void;
+    /** Delivers a synchronous source assembly failure after `onSubscribe`. */
+    deliverStartFailure(): void;
+    /** Requests more values from the backing iterator. */
+    request(n: number): void;
+    /** Cancels iteration and closes upstream resources. */
+    cancel(): void;
+    /** Drains the source while there is outstanding demand. */
+    private drain;
+    /** Drains a synchronous source without per-item promise allocation. */
+    private drainSync;
+    /** Returns true after delivering a terminal result. */
+    private deliverResult;
+    /** Returns the pending prefetched async result or asks the async iterator for the next item. */
+    private nextAsyncResult;
+    /** Returns the pending prefetched sync result or asks the sync iterator for the next item. */
+    private nextSyncResult;
+    /** Prefetches one item to discover terminal completion without extra demand. */
+    private lookAheadForTermination;
+    /** Prefetches one synchronous item to discover terminal completion without extra demand. */
+    private lookAheadForSyncTermination;
+    /** Closes active iterators and ignores cleanup failures after cancellation. */
+    private closeIterators;
+}
+//# sourceMappingURL=iterable-subscription.d.ts.map

package/dist/subscription/iterable-subscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable-subscription.d.ts","sourceRoot":"","sources":["../../src/subscription/iterable-subscription.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,sBAAsB,CAAC;AAGlD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AAEjE,oFAAoF;AACpF,qBAAa,oBAAoB,CAAC,CAAC,CAAE,YAAW,YAAY;IACxD,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,2DAA2D;IAC3D,OAAO,CAAC,aAAa,CAA+B;IACpD,iEAAiE;IACjE,OAAO,CAAC,YAAY,CAA0B;IAC9C,6DAA6D;IAC7D,OAAO,CAAC,OAAO,CAAS;IACxB,8EAA8E;IAC9E,OAAO,CAAC,YAAY,CAAU;IAC9B,2DAA2D;IAC3D,OAAO,CAAC,eAAe,CAAS;IAChC,0EAA0E;IAC1E,OAAO,CAAC,gBAAgB,CAAyC;IACjE,yEAAyE;IACzE,OAAO,CAAC,eAAe,CAAgC;IACvD,qCAAqC;IACrC,OAAO,CAAC,SAAS,CAAK;IACtB,6CAA6C;IAC7C,OAAO,CAAC,QAAQ,CAAS;IACzB,sCAAsC;IACtC,OAAO,CAAC,SAAS,CAAS;IAC1B,sDAAsD;IACtD,OAAO,CAAC,UAAU,CAAS;IAC3B,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,+CAA+C;IAC/C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,6CAA6C;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAElC,mEAAmE;IACnE,YAAmB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAI5E;IAED,iEAAiE;IAC1D,KAAK,IAAI,IAAI,CAgBnB;IAED,0EAA0E;IACnE,mBAAmB,IAAI,IAAI,CAOjC;IAED,sDAAsD;IAC/C,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAkB9B;IAED,uDAAuD;IAChD,MAAM,IAAI,IAAI,CAOpB;IAED,2DAA2D;YAC7C,KAAK;IAyCnB,uEAAuE;IACvE,OAAO,CAAC,SAAS;IAYjB,uDAAuD;IACvD,OAAO,CAAC,aAAa;IAmBrB,gGAAgG;IAChG,OAAO,CAAC,eAAe;IASvB,8FAA8F;IAC9F,OAAO,CAAC,cAAc;IAStB,gFAAgF;IAChF,OAAO,CAAC,uBAAuB;IAgC/B,4FAA4F;IAC5F,OAAO,CAAC,2BAA2B;IAuBnC,+EAA+E;IAC/E,OAAO,CAAC,cAAc;CAYzB"}

package/dist/subscription/iterable-subscription.js

@@ -0,0 +1,281 @@
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/defineProperty.js";
+import { doneResult, isAsyncIterable, resolvedDoneResult } from "../internal/iterable.js";
+import { addCap, normalizeRequest } from "../core/demand.js";
+import { scheduleMicrotask } from "../internal/microtask.js";
+//#region src/subscription/iterable-subscription.ts
+/**
+* @packageDocumentation
+* Reactive Streams subscription and subscriber contracts.
+*/
+/** Subscription implementation that drains a Flux only when demand is requested. */
+var IterableSubscription = class {
+	/** Creates a subscription for the provided Flux and subscriber. */
+	constructor(flux, subscriber, context) {
+		_defineProperty(
+			this,
+			/** Abort controller used to cancel the active source iterator. */
+			"controller",
+			new AbortController()
+		);
+		_defineProperty(
+			this,
+			/** Lazily created async iterator over the backing Flux. */
+			"asyncIterator",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Lazily created synchronous iterator over the backing Flux. */
+			"syncIterator",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Tracks whether the source iterator has been assembled. */
+			"started",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Stores a synchronous source assembly failure until it can be signalled. */
+			"startFailure",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Tracks whether source assembly failed synchronously. */
+			"hasStartFailure",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Prefetched async result used to detect completion with zero demand. */
+			"pendingAsyncNext",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Prefetched sync result used to detect completion with zero demand. */
+			"pendingSyncNext",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Outstanding downstream demand. */
+			"requested",
+			0
+		);
+		_defineProperty(
+			this,
+			/** Guards against concurrent drain loops. */
+			"draining",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Tracks downstream cancellation. */
+			"cancelled",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Tracks terminal completion or failure delivery. */
+			"terminated",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Source Flux drained by this subscription. */
+			"flux",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Downstream subscriber receiving signals. */
+			"subscriber",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Context used for the source iteration. */
+			"context",
+			void 0
+		);
+		this.flux = flux;
+		this.subscriber = subscriber;
+		this.context = context;
+	}
+	/** Starts source assembly without pulling any values from it. */
+	start() {
+		if (this.started || this.cancelled || this.terminated) return;
+		this.started = true;
+		try {
+			const source = this.flux.iterate(this.controller.signal, this.context);
+			if (isAsyncIterable(source)) this.asyncIterator = source[Symbol.asyncIterator]();
+			else this.syncIterator = source[Symbol.iterator]();
+		} catch (error) {
+			this.startFailure = error;
+			this.hasStartFailure = true;
+		}
+	}
+	/** Delivers a synchronous source assembly failure after `onSubscribe`. */
+	deliverStartFailure() {
+		if (!this.hasStartFailure || this.cancelled || this.terminated) return;
+		this.hasStartFailure = false;
+		this.terminated = true;
+		this.subscriber.onError(this.startFailure);
+	}
+	/** Requests more values from the backing iterator. */
+	request(n) {
+		if (this.cancelled || this.terminated) return;
+		let request;
+		try {
+			request = normalizeRequest(n);
+		} catch (error) {
+			this.cancel();
+			this.subscriber.onError(error);
+			return;
+		}
+		this.requested = addCap(this.requested, request);
+		if (this.hasStartFailure) {
+			this.deliverStartFailure();
+			return;
+		}
+		this.drain();
+	}
+	/** Cancels iteration and closes upstream resources. */
+	cancel() {
+		if (this.cancelled || this.terminated) return;
+		this.cancelled = true;
+		this.controller.abort();
+		this.closeIterators();
+	}
+	/** Drains the source while there is outstanding demand. */
+	async drain() {
+		if (this.draining) return;
+		this.draining = true;
+		try {
+			this.start();
+			if (this.hasStartFailure) {
+				this.deliverStartFailure();
+				return;
+			}
+			if (this.syncIterator) {
+				this.drainSync();
+				return;
+			}
+			while (!this.cancelled && !this.terminated && this.requested > 0) {
+				const result = await this.nextAsyncResult();
+				if (this.cancelled || this.terminated) return;
+				if (this.deliverResult(result)) return;
+			}
+		} catch (error) {
+			if (!this.cancelled && !this.terminated) {
+				this.terminated = true;
+				this.subscriber.onError(error);
+			}
+		} finally {
+			this.draining = false;
+			if (!this.cancelled && !this.terminated && this.requested > 0) scheduleMicrotask(() => {
+				this.drain();
+			});
+			else if (!this.cancelled && !this.terminated && this.requested === 0) this.lookAheadForTermination();
+		}
+	}
+	/** Drains a synchronous source without per-item promise allocation. */
+	drainSync() {
+		while (!this.cancelled && !this.terminated && this.requested > 0) {
+			const result = this.nextSyncResult();
+			if (this.cancelled || this.terminated) return;
+			if (this.deliverResult(result)) return;
+		}
+	}
+	/** Returns true after delivering a terminal result. */
+	deliverResult(result) {
+		if (result.done) {
+			this.terminated = true;
+			this.subscriber.onComplete();
+			return true;
+		}
+		if (this.requested !== Number.POSITIVE_INFINITY) this.requested -= 1;
+		try {
+			this.subscriber.onNext(result.value);
+		} catch (error) {
+			this.cancel();
+			this.subscriber.onError(error);
+			return true;
+		}
+		return false;
+	}
+	/** Returns the pending prefetched async result or asks the async iterator for the next item. */
+	nextAsyncResult() {
+		if (this.pendingAsyncNext) {
+			const pending = this.pendingAsyncNext;
+			this.pendingAsyncNext = void 0;
+			return pending;
+		}
+		return this.asyncIterator?.next() ?? resolvedDoneResult();
+	}
+	/** Returns the pending prefetched sync result or asks the sync iterator for the next item. */
+	nextSyncResult() {
+		if (this.pendingSyncNext) {
+			const pending = this.pendingSyncNext;
+			this.pendingSyncNext = void 0;
+			return pending;
+		}
+		return this.syncIterator?.next() ?? doneResult();
+	}
+	/** Prefetches one item to discover terminal completion without extra demand. */
+	lookAheadForTermination() {
+		if (this.syncIterator) {
+			this.lookAheadForSyncTermination();
+			return;
+		}
+		if (!this.asyncIterator || this.pendingAsyncNext) return;
+		const pending = this.asyncIterator.next();
+		this.pendingAsyncNext = pending;
+		pending.then((result) => {
+			if (this.pendingAsyncNext !== pending || this.cancelled || this.terminated) return;
+			if (result.done) {
+				this.pendingAsyncNext = void 0;
+				this.terminated = true;
+				this.subscriber.onComplete();
+			}
+		}, (error) => {
+			if (this.pendingAsyncNext !== pending || this.cancelled || this.terminated) return;
+			this.pendingAsyncNext = void 0;
+			this.terminated = true;
+			this.subscriber.onError(error);
+		});
+	}
+	/** Prefetches one synchronous item to discover terminal completion without extra demand. */
+	lookAheadForSyncTermination() {
+		if (!this.syncIterator || this.pendingSyncNext) return;
+		try {
+			const result = this.syncIterator.next();
+			if (this.cancelled || this.terminated) return;
+			if (result.done) {
+				this.terminated = true;
+				this.subscriber.onComplete();
+			} else this.pendingSyncNext = result;
+		} catch (error) {
+			if (!this.cancelled && !this.terminated) {
+				this.terminated = true;
+				this.subscriber.onError(error);
+			}
+		}
+	}
+	/** Closes active iterators and ignores cleanup failures after cancellation. */
+	closeIterators() {
+		try {
+			this.asyncIterator?.return?.();
+		} catch {}
+		try {
+			this.syncIterator?.return?.();
+		} catch {}
+	}
+};
+//#endregion
+export { IterableSubscription };
+
+//# sourceMappingURL=iterable-subscription.js.map