request-iframe 0.0.5 → 0.1.0

package/library/stream/readable-stream.js

@@ -1,5 +1,8 @@
 "use strict";
 
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/web.dom-collections.for-each.js");
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
@@ -7,11 +10,18 @@ Object.defineProperty(exports, "__esModule", {
 exports.IframeReadableStream = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 require("core-js/modules/es.symbol.async-iterator.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.js");
 require("core-js/modules/es.promise.js");
+require("core-js/modules/es.promise.finally.js");
+require("core-js/modules/web.dom-collections.iterator.js");
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _utils = require("../utils");
 var _constants = require("../constants");
+var _streamCore = require("./stream-core");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /**
  * Stream message handler interface
  */
@@ -20,35 +30,73 @@ var _constants = require("../constants");
  * IframeReadableStream - Client-side readable stream
  * Used to receive stream data sent from the server
  */
-class IframeReadableStream {
+class IframeReadableStream extends _streamCore.IframeStreamCore {
   constructor(streamId, requestId, messageHandler, options = {}) {
-    var _options$type, _options$chunked;
-    (0, _defineProperty2.default)(this, "_state", _constants.StreamState.PENDING);
-    (0, _defineProperty2.default)(this, "chunks", []);
-    this.streamId = streamId;
+    var _options$type, _options$chunked, _options$consume;
+    super(streamId, (_options$type = options.type) !== null && _options$type !== void 0 ? _options$type : _constants.StreamType.DATA, (_options$chunked = options.chunked) !== null && _options$chunked !== void 0 ? _options$chunked : true, options.metadata, (_options$consume = options.consume) !== null && _options$consume !== void 0 ? _options$consume : true, options.mode);
+    (0, _defineProperty2.default)(this, "heartbeatInFlight", null);
+    (0, _defineProperty2.default)(this, "lastActivityAt", Date.now());
+    /** pull/ack protocol */
+    (0, _defineProperty2.default)(this, "pullScheduled", false);
+    (0, _defineProperty2.default)(this, "highWaterMark", 16);
     this.requestId = requestId;
     this.messageHandler = messageHandler;
-    this.type = (_options$type = options.type) !== null && _options$type !== void 0 ? _options$type : _constants.StreamType.DATA;
-    this.chunked = (_options$chunked = options.chunked) !== null && _options$chunked !== void 0 ? _options$chunked : true;
-    this.metadata = options.metadata;
     this.secretKey = options.secretKey;
+    this.idleTimeout = options.idleTimeout;
+    this.heartbeat = options.heartbeat;
 
     // Register stream message handler
     this.messageHandler.registerStreamHandler(streamId, this.handleStreamMessage.bind(this));
+    // Initial pull to start the stream (pull protocol)
+    this.requestMore(1);
+  }
+  postControl(type, body) {
+    var message = (0, _utils.createPostMessage)(type, this.requestId, {
+      secretKey: this.secretKey,
+      body: _objectSpread({
+        streamId: this.streamId
+      }, body)
+    });
+    this.messageHandler.postMessage(message);
+  }
+  requestMore(credit) {
+    if (!credit || credit <= 0) return;
+    if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
+    try {
+      this.postControl(_constants.MessageType.STREAM_PULL, {
+        credit
+      });
+    } catch (_unused) {
+      /** ignore */
+    }
+  }
+  schedulePullIfNeeded() {
+    if (this.pullScheduled) return;
+    this.pullScheduled = true;
+    Promise.resolve().then(() => {
+      this.pullScheduled = false;
+      if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
+      var need = Math.max(0, this.highWaterMark - this.chunks.length);
+      if (need > 0) {
+        this.requestMore(need);
+      }
+    });
   }
 
   /** Get stream state */
   get state() {
-    return this._state;
+    return super.state;
   }
 
   /**
    * Handle stream message
    */
   handleStreamMessage(data) {
+    // Mark activity on any incoming stream message
+    this.lastActivityAt = Date.now();
     switch (data.type) {
       case _constants.StreamInternalMessageType.DATA:
-        this.handleData(data.data, data.done);
+        this.handleData(data.data, data.done, data.seq);
         break;
       case _constants.StreamInternalMessageType.END:
         this.handleEnd();
@@ -59,17 +107,34 @@ class IframeReadableStream {
       case _constants.StreamInternalMessageType.CANCEL:
         this.handleCancel(data.reason);
         break;
+      case _constants.StreamInternalMessageType.PULL:
+      case _constants.StreamInternalMessageType.ACK:
+        // Control messages for writer side; ignore in readable stream
+        break;
     }
   }
 
   /**
    * Handle data chunk (internal method)
    */
-  handleData(data, done) {
+  handleData(data, done, seq) {
     if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
     this._state = _constants.StreamState.STREAMING;
     var decoded = this.decodeData(data);
     this.chunks.push(decoded);
+
+    // Ack this chunk (if seq provided)
+    if (typeof seq === 'number' && seq >= 0) {
+      try {
+        this.postControl(_constants.MessageType.STREAM_ACK, {
+          seq
+        });
+      } catch (_unused2) {
+        /** ignore */
+      }
+    }
+    this.notifyWaiters();
+    this.schedulePullIfNeeded();
     if (done) {
       this.handleEnd();
     }
@@ -88,15 +153,9 @@ class IframeReadableStream {
   handleEnd() {
     var _this$onEndCallback;
     if (this._state === _constants.StreamState.ENDED) return;
-    this._state = _constants.StreamState.ENDED;
+    super.end();
     this.messageHandler.unregisterStreamHandler(this.streamId);
-    if (this.resolveRead) {
-      // Merge all data chunks
-      var result = this.mergeChunks();
-      this.resolveRead(result);
-      this.resolveRead = undefined;
-      this.rejectRead = undefined;
-    }
+    this.notifyWaiters();
     (_this$onEndCallback = this.onEndCallback) === null || _this$onEndCallback === void 0 || _this$onEndCallback.call(this);
   }
 
@@ -120,13 +179,9 @@ class IframeReadableStream {
   handleError(error) {
     var _this$onErrorCallback;
     if (this._state === _constants.StreamState.ENDED || this._state === _constants.StreamState.ERROR) return;
-    this._state = _constants.StreamState.ERROR;
+    super.fail(error);
     this.messageHandler.unregisterStreamHandler(this.streamId);
-    if (this.rejectRead) {
-      this.rejectRead(error);
-      this.resolveRead = undefined;
-      this.rejectRead = undefined;
-    }
+    this.notifyWaiters();
     (_this$onErrorCallback = this.onErrorCallback) === null || _this$onErrorCallback === void 0 || _this$onErrorCallback.call(this, error);
   }
 
@@ -134,35 +189,229 @@ class IframeReadableStream {
    * Stream cancelled (internal method)
    */
   handleCancel(reason) {
-    var _this$onErrorCallback2;
+    this.cancelInternal(reason, false);
+  }
+
+  /**
+   * Cancel/abort core logic
+   * @param reason cancel reason
+   * @param notifyRemote whether to notify remote side (send stream_cancel)
+   */
+  cancelInternal(reason, notifyRemote = false) {
     if (this._state === _constants.StreamState.ENDED || this._state === _constants.StreamState.ERROR || this._state === _constants.StreamState.CANCELLED) return;
-    this._state = _constants.StreamState.CANCELLED;
+    super.cancel((0, _constants.formatMessage)(_constants.Messages.STREAM_CANCELLED, reason || ''));
+    this.notifyWaiters();
+    if (notifyRemote) {
+      try {
+        /** Notify server to cancel */
+        var _message = (0, _utils.createPostMessage)(_constants.MessageType.STREAM_CANCEL, this.requestId, {
+          secretKey: this.secretKey,
+          body: {
+            streamId: this.streamId,
+            reason
+          }
+        });
+        this.messageHandler.postMessage(_message);
+      } catch (_unused3) {
+        /** ignore send failures on cancel/abort */
+      }
+    }
     this.messageHandler.unregisterStreamHandler(this.streamId);
-    var error = new Error(reason || _constants.Messages.STREAM_CANCELLED);
-    if (this.rejectRead) {
-      this.rejectRead(error);
-      this.resolveRead = undefined;
-      this.rejectRead = undefined;
+    if (this.terminalError) {
+      var _this$onErrorCallback2;
+      (_this$onErrorCallback2 = this.onErrorCallback) === null || _this$onErrorCallback2 === void 0 || _this$onErrorCallback2.call(this, this.terminalError);
+    } else {
+      var _this$onErrorCallback3;
+      (_this$onErrorCallback3 = this.onErrorCallback) === null || _this$onErrorCallback3 === void 0 || _this$onErrorCallback3.call(this, new Error(_constants.Messages.STREAM_CANCELLED));
     }
-    (_this$onErrorCallback2 = this.onErrorCallback) === null || _this$onErrorCallback2 === void 0 || _this$onErrorCallback2.call(this, error);
+  }
+  performHeartbeat() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+      return _regenerator.default.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (_this.heartbeat) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return", false);
+          case 1:
+            if (!_this.heartbeatInFlight) {
+              _this.heartbeatInFlight = Promise.resolve().then(() => _this.heartbeat()).catch(() => false).finally(() => {
+                _this.heartbeatInFlight = null;
+              });
+            }
+            return _context.abrupt("return", _this.heartbeatInFlight);
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
+  waitForChangeWithIdleTimeout() {
+    var _this2 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var state0, snapshot, timerId, stateAfter, ok;
+      return _regenerator.default.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            state0 = _this2._state;
+            if (!(state0 === _constants.StreamState.ENDED || state0 === _constants.StreamState.ERROR || state0 === _constants.StreamState.CANCELLED)) {
+              _context2.next = 1;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 1:
+            if (!(!_this2.idleTimeout || _this2.idleTimeout <= 0)) {
+              _context2.next = 3;
+              break;
+            }
+            _context2.next = 2;
+            return _this2.waitForChange();
+          case 2:
+            return _context2.abrupt("return");
+          case 3:
+            snapshot = _this2.lastActivityAt;
+            timerId = null;
+            _context2.next = 4;
+            return Promise.race([_this2.waitForChange(), new Promise(resolve => {
+              timerId = setTimeout(resolve, _this2.idleTimeout);
+            })]);
+          case 4:
+            if (timerId) clearTimeout(timerId);
+
+            // If stream already moved to a terminal state, just return
+            stateAfter = _this2._state;
+            if (!(stateAfter === _constants.StreamState.ENDED || stateAfter === _constants.StreamState.ERROR || stateAfter === _constants.StreamState.CANCELLED)) {
+              _context2.next = 5;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 5:
+            if (!(_this2.lastActivityAt !== snapshot)) {
+              _context2.next = 6;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 6:
+            _context2.next = 7;
+            return _this2.performHeartbeat();
+          case 7:
+            ok = _context2.sent;
+            if (!ok) {
+              _context2.next = 8;
+              break;
+            }
+            // Treat heartbeat as activity to prevent immediate re-trigger
+            _this2.lastActivityAt = Date.now();
+            return _context2.abrupt("return");
+          case 8:
+            // Connection likely dead: fail the stream
+            _this2.handleError(new Error((0, _constants.formatMessage)(_constants.Messages.STREAM_TIMEOUT, _this2.idleTimeout)));
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
   }
 
   /**
    * Read all data
    */
   read() {
-    return new Promise((resolve, reject) => {
-      if (this._state === _constants.StreamState.ENDED) {
-        resolve(this.mergeChunks());
-        return;
-      }
-      if (this._state === _constants.StreamState.ERROR || this._state === _constants.StreamState.CANCELLED) {
-        reject(new Error(_constants.Messages.STREAM_READ_ERROR));
-        return;
-      }
-      this.resolveRead = resolve;
-      this.rejectRead = reject;
-    });
+    var _this3 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      return _regenerator.default.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!(_this3._state === _constants.StreamState.ENDED)) {
+              _context3.next = 1;
+              break;
+            }
+            return _context3.abrupt("return", _this3.mergeChunks());
+          case 1:
+            if (!(_this3._state === _constants.StreamState.ERROR || _this3._state === _constants.StreamState.CANCELLED)) {
+              _context3.next = 2;
+              break;
+            }
+            throw _this3.terminalError || new Error(_constants.Messages.STREAM_READ_ERROR);
+          case 2:
+            if (!(_this3._state === _constants.StreamState.PENDING || _this3._state === _constants.StreamState.STREAMING)) {
+              _context3.next = 4;
+              break;
+            }
+            if (_this3.chunks.length === 0) {
+              _this3.requestMore(1);
+            }
+            _context3.next = 3;
+            return _this3.waitForChangeWithIdleTimeout();
+          case 3:
+            _context3.next = 2;
+            break;
+          case 4:
+            if (!(_this3._state === _constants.StreamState.ENDED)) {
+              _context3.next = 5;
+              break;
+            }
+            return _context3.abrupt("return", _this3.mergeChunks());
+          case 5:
+            throw _this3.terminalError || new Error(_constants.Messages.STREAM_READ_ERROR);
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  }
+
+  /**
+   * Read all chunks as an array
+   */
+  readAll() {
+    var _this4 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!(_this4._state === _constants.StreamState.ENDED)) {
+              _context4.next = 1;
+              break;
+            }
+            return _context4.abrupt("return", _this4.chunks.slice());
+          case 1:
+            if (!(_this4._state === _constants.StreamState.ERROR || _this4._state === _constants.StreamState.CANCELLED)) {
+              _context4.next = 2;
+              break;
+            }
+            throw _this4.terminalError || new Error(_constants.Messages.STREAM_READ_ERROR);
+          case 2:
+            if (!(_this4._state === _constants.StreamState.PENDING || _this4._state === _constants.StreamState.STREAMING)) {
+              _context4.next = 4;
+              break;
+            }
+            _this4.schedulePullIfNeeded();
+            _context4.next = 3;
+            return _this4.waitForChangeWithIdleTimeout();
+          case 3:
+            _context4.next = 2;
+            break;
+          case 4:
+            if (!(_this4._state === _constants.StreamState.ENDED)) {
+              _context4.next = 5;
+              break;
+            }
+            return _context4.abrupt("return", _this4.chunks.slice());
+          case 5:
+            throw _this4.terminalError || new Error(_constants.Messages.STREAM_READ_ERROR);
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
   }
 
   /**
@@ -173,62 +422,69 @@ class IframeReadableStream {
     var stream = this;
     return {
       next() {
-        return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
-          return _regenerator.default.wrap(function (_context) {
-            while (1) switch (_context.prev = _context.next) {
+        return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+          var value;
+          return _regenerator.default.wrap(function (_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
               case 0:
                 if (!(index >= stream.chunks.length)) {
-                  _context.next = 3;
+                  _context5.next = 3;
                   break;
                 }
                 if (!(stream._state === _constants.StreamState.ENDED || stream._state === _constants.StreamState.ERROR || stream._state === _constants.StreamState.CANCELLED)) {
-                  _context.next = 1;
+                  _context5.next = 1;
                   break;
                 }
-                return _context.abrupt("return", {
+                return _context5.abrupt("return", {
                   done: true,
                   value: undefined
                 });
               case 1:
-                _context.next = 2;
-                return new Promise(resolve => setTimeout(resolve, 10));
+                // Consumer is ready: request at least 1 chunk
+                stream.requestMore(1);
+                _context5.next = 2;
+                return stream.waitForChangeWithIdleTimeout();
               case 2:
-                _context.next = 0;
+                _context5.next = 0;
                 break;
               case 3:
-                return _context.abrupt("return", {
+                value = stream.chunks[index++];
+                if (stream.consume) {
+                  /**
+                   * Drop already-consumed chunks to reduce memory usage.
+                   * Use compaction (slice) to avoid O(n) shift per chunk.
+                   */
+                  if (index > 128) {
+                    stream.chunks = stream.chunks.slice(index);
+                    index = 0;
+                  }
+                }
+                return _context5.abrupt("return", {
                   done: false,
-                  value: stream.chunks[index++]
+                  value
                 });
               case 4:
               case "end":
-                return _context.stop();
+                return _context5.stop();
             }
-          }, _callee);
+          }, _callee5);
         }))();
       }
     };
   }
 
+  /**
+   * Abort stream (is alias of cancel method)
+   */
+  abort(reason) {
+    this.cancelInternal(reason, true);
+  }
+
   /**
    * Cancel stream
    */
   cancel(reason) {
-    if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
-    this._state = _constants.StreamState.CANCELLED;
-
-    // Notify server to cancel
-    var message = (0, _utils.createPostMessage)(_constants.MessageType.STREAM_CANCEL, this.requestId, {
-      secretKey: this.secretKey,
-      body: {
-        streamId: this.streamId,
-        reason
-      },
-      role: _constants.MessageRole.CLIENT,
-      creatorId: this.messageHandler.id
-    });
-    this.messageHandler.postMessage(message);
-    this.messageHandler.unregisterStreamHandler(this.streamId);
+    this.cancelInternal(reason, true);
   }
 
   /**

package/library/stream/stream-core.d.ts

@@ -0,0 +1,44 @@
+import type { StreamState, StreamType, StreamMessageData, WritableStreamMode } from './types';
+/**
+ * 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 declare class IframeStreamCore<T = any> {
+    readonly streamId: string;
+    readonly type: StreamType;
+    readonly chunked: boolean;
+    readonly metadata?: Record<string, any>;
+    readonly mode?: WritableStreamMode;
+    protected _state: StreamState;
+    protected terminalError?: Error;
+    protected chunks: T[];
+    protected waiters: Array<() => void>;
+    protected consume: boolean;
+    constructor(streamId: string, type: StreamType, chunked: boolean, metadata: Record<string, any> | undefined, consume: boolean, mode?: WritableStreamMode);
+    get state(): StreamState;
+    protected notifyWaiters(): void;
+    protected waitForChange(): Promise<void>;
+    protected fail(error: Error): void;
+    protected cancel(reason?: string): void;
+    /**
+     * Read-side: enqueue a decoded chunk
+     */
+    protected pushChunk(chunk: T): void;
+    /**
+     * Read-side: mark end
+     */
+    protected end(): void;
+    /**
+     * 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: StreamMessageData): void;
+}
+//# sourceMappingURL=stream-core.d.ts.map

package/library/stream/stream-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-core.d.ts","sourceRoot":"","sources":["../../src/stream/stream-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAG9F;;;;;;;;;GASG;AACH,qBAAa,gBAAgB,CAAC,CAAC,GAAG,GAAG;IACnC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,UAAU,CAAC;IACjC,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/C,SAAgB,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAE1C,SAAS,CAAC,MAAM,EAAE,WAAW,CAA+B;IAC5D,SAAS,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC;IAEhC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,CAAM;IAC3B,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAM;IAE1C,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;gBAGzB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,EACzC,OAAO,EAAE,OAAO,EAChB,IAAI,CAAC,EAAE,kBAAkB;IAU3B,IAAW,KAAK,IAAI,WAAW,CAE9B;IAED,SAAS,CAAC,aAAa,IAAI,IAAI;IAa/B,SAAS,CAAC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAOlC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAWvC;;OAEG;IACH,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAOnC;;OAEG;IACH,SAAS,CAAC,GAAG,IAAI,IAAI;IAMrB;;;;OAIG;IACI,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;CAG5D"}

package/library/stream/stream-core.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IframeStreamCore = void 0;
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("../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`.
+ */
+class IframeStreamCore {
+  constructor(streamId, type, chunked, metadata, consume, mode) {
+    (0, _defineProperty2.default)(this, "_state", _constants.StreamState.PENDING);
+    (0, _defineProperty2.default)(this, "chunks", []);
+    (0, _defineProperty2.default)(this, "waiters", []);
+    this.streamId = streamId;
+    this.type = type;
+    this.chunked = chunked;
+    this.metadata = metadata;
+    this.consume = consume;
+    this.mode = mode;
+  }
+  get state() {
+    return this._state;
+  }
+  notifyWaiters() {
+    if (this.waiters.length === 0) return;
+    var list = this.waiters;
+    this.waiters = [];
+    list.forEach(fn => {
+      try {
+        fn();
+      } catch (_unused) {
+        /** ignore */
+      }
+    });
+  }
+  waitForChange() {
+    if (this._state === _constants.StreamState.ENDED || this._state === _constants.StreamState.ERROR || this._state === _constants.StreamState.CANCELLED) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      this.waiters.push(resolve);
+    });
+  }
+  fail(error) {
+    if (this._state === _constants.StreamState.ENDED || this._state === _constants.StreamState.ERROR) return;
+    this._state = _constants.StreamState.ERROR;
+    this.terminalError = error;
+    this.notifyWaiters();
+  }
+  cancel(reason) {
+    if (this._state === _constants.StreamState.ENDED || this._state === _constants.StreamState.ERROR || this._state === _constants.StreamState.CANCELLED) return;
+    this._state = _constants.StreamState.CANCELLED;
+    this.terminalError = new Error(reason || _constants.Messages.STREAM_CANCELLED);
+    this.notifyWaiters();
+  }
+
+  /**
+   * Read-side: enqueue a decoded chunk
+   */
+  pushChunk(chunk) {
+    if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
+    this._state = _constants.StreamState.STREAMING;
+    this.chunks.push(chunk);
+    this.notifyWaiters();
+  }
+
+  /**
+   * Read-side: mark end
+   */
+  end() {
+    if (this._state === _constants.StreamState.ENDED) return;
+    this._state = _constants.StreamState.ENDED;
+    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.
+  }
+}
+exports.IframeStreamCore = IframeStreamCore;