request-iframe 0.0.6 → 0.1.1

package/esm/stream/stream-core.js

@@ -0,0 +1,204 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { StreamState as StreamStateConstant, Messages, StreamEvent } from '../constants';
+
+/**
+ * Shared stream core (internal).
+ *
+ * - Read side: buffer + waiters + consume compaction
+ * - Common: state + terminal error + basic waiter mechanics
+ *
+ * NOTE:
+ * This is an internal abstraction to share logic between Readable/Writable streams.
+ * Public API remains `IframeReadableStream` / `IframeWritableStream`.
+ */
+export class IframeStreamCore {
+  constructor(streamId, type, chunked, metadata, consume, mode) {
+    _defineProperty(this, "_state", StreamStateConstant.PENDING);
+    _defineProperty(this, "chunks", []);
+    _defineProperty(this, "waiters", []);
+    _defineProperty(this, "listeners", new Map());
+    this.streamId = streamId;
+    this.type = type;
+    this.chunked = chunked;
+    this.metadata = metadata;
+    this.consume = consume;
+    this.mode = mode;
+  }
+  get state() {
+    return this._state;
+  }
+
+  /**
+   * Subscribe to stream events.
+   *
+   * This is designed for observability (debugging / metrics / UI progress),
+   * and should not be used to drive protocol-critical logic.
+   *
+   * Returns an unsubscribe function.
+   */
+
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event).add(listener);
+
+    // Terminal events: if already reached, fire once immediately for convenience.
+    if (event === StreamEvent.END && this._state === StreamStateConstant.ENDED) {
+      this.safeCall(listener);
+    } else if (event === StreamEvent.ERROR && this._state === StreamStateConstant.ERROR) {
+      this.safeCall(listener, {
+        error: this.terminalError
+      });
+    } else if (event === StreamEvent.CANCEL && this._state === StreamStateConstant.CANCELLED) {
+      this.safeCall(listener, {
+        error: this.terminalError
+      });
+    }
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    // If already terminal, behave like a synchronous one-shot.
+    if (event === StreamEvent.END && this._state === StreamStateConstant.ENDED) {
+      this.safeCall(listener);
+      return () => {};
+    }
+    if (event === StreamEvent.ERROR && this._state === StreamStateConstant.ERROR) {
+      this.safeCall(listener, {
+        error: this.terminalError
+      });
+      return () => {};
+    }
+    if (event === StreamEvent.CANCEL && this._state === StreamStateConstant.CANCELLED) {
+      this.safeCall(listener, {
+        error: this.terminalError
+      });
+      return () => {};
+    }
+    var wrapped = payload => {
+      this.off(event, wrapped);
+      this.safeCall(listener, payload);
+    };
+    return this.on(event, wrapped);
+  }
+
+  /**
+   * Unsubscribe from stream events.
+   */
+
+  off(event, listener) {
+    var set = this.listeners.get(event);
+    if (!set) return;
+    set.delete(listener);
+    if (set.size === 0) {
+      this.listeners.delete(event);
+    }
+  }
+  emit(event, payload) {
+    var set = this.listeners.get(event);
+    if (!set || set.size === 0) return;
+    // Snapshot to avoid issues if listeners mutate subscriptions.
+    var list = Array.from(set);
+    list.forEach(fn => this.safeCall(fn, payload));
+  }
+  clearAllListeners() {
+    this.listeners.clear();
+  }
+  safeCall(fn, payload) {
+    try {
+      fn(payload);
+    } catch (_unused) {
+      /** ignore user listener errors */
+    }
+  }
+  notifyWaiters() {
+    if (this.waiters.length === 0) return;
+    var list = this.waiters;
+    this.waiters = [];
+    list.forEach(fn => {
+      try {
+        fn();
+      } catch (_unused2) {
+        /** ignore */
+      }
+    });
+  }
+  waitForChange() {
+    if (this._state === StreamStateConstant.ENDED || this._state === StreamStateConstant.ERROR || this._state === StreamStateConstant.CANCELLED) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      this.waiters.push(resolve);
+    });
+  }
+  fail(error) {
+    if (this._state === StreamStateConstant.ENDED || this._state === StreamStateConstant.ERROR) return;
+    this._state = StreamStateConstant.ERROR;
+    this.terminalError = error;
+    this.emit(StreamEvent.ERROR, {
+      error
+    });
+    this.emit(StreamEvent.STATE, {
+      state: this._state
+    });
+    this.notifyWaiters();
+  }
+  cancel(reason) {
+    if (this._state === StreamStateConstant.ENDED || this._state === StreamStateConstant.ERROR || this._state === StreamStateConstant.CANCELLED) return;
+    this._state = StreamStateConstant.CANCELLED;
+    this.terminalError = new Error(reason || Messages.STREAM_CANCELLED);
+    this.emit(StreamEvent.CANCEL, {
+      reason,
+      error: this.terminalError
+    });
+    this.emit(StreamEvent.STATE, {
+      state: this._state
+    });
+    this.notifyWaiters();
+  }
+
+  /**
+   * Read-side: enqueue a decoded chunk
+   */
+  pushChunk(chunk) {
+    if (this._state !== StreamStateConstant.PENDING && this._state !== StreamStateConstant.STREAMING) return;
+    this._state = StreamStateConstant.STREAMING;
+    this.chunks.push(chunk);
+    this.emit(StreamEvent.DATA, {
+      chunk
+    });
+    this.emit(StreamEvent.STATE, {
+      state: this._state
+    });
+    this.notifyWaiters();
+  }
+
+  /**
+   * Read-side: mark end
+   */
+  end() {
+    if (this._state === StreamStateConstant.ENDED) return;
+    this._state = StreamStateConstant.ENDED;
+    this.emit(StreamEvent.END);
+    this.emit(StreamEvent.STATE, {
+      state: this._state
+    });
+    this.notifyWaiters();
+  }
+
+  /**
+   * Handle inbound message (shared).
+   * - ReadableStream will use DATA/END/ERROR/CANCEL
+   * - WritableStream may use PULL/ACK/CANCEL separately, so this is intentionally minimal.
+   */
+  handleInboundMessage(_data) {
+    // Intentionally left blank in core.
+  }
+}

package/esm/stream/types.js

@@ -0,0 +1 @@
+export {};