request-iframe 0.0.6 → 0.1.1

package/esm/stream/readable-stream.js

@@ -0,0 +1,539 @@
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.symbol.async-iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.promise.finally.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+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) { _defineProperty(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; }
+import { createPostMessage } from '../utils';
+import { MessageType, Messages, StreamType as StreamTypeConstant, StreamState as StreamStateConstant, StreamInternalMessageType, formatMessage, StreamEvent } from '../constants';
+import { IframeStreamCore } from './stream-core';
+
+/**
+ * Stream message handler interface
+ */
+
+/**
+ * IframeReadableStream - Client-side readable stream
+ * Used to receive stream data sent from the server
+ */
+export class IframeReadableStream extends IframeStreamCore {
+  constructor(streamId, requestId, messageHandler, options = {}) {
+    var _options$type, _options$chunked, _options$consume;
+    super(streamId, (_options$type = options.type) !== null && _options$type !== void 0 ? _options$type : StreamTypeConstant.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);
+    _defineProperty(this, "heartbeatInFlight", null);
+    _defineProperty(this, "lastActivityAt", Date.now());
+    /** pull/ack protocol */
+    _defineProperty(this, "pullScheduled", false);
+    _defineProperty(this, "highWaterMark", 16);
+    this.requestId = requestId;
+    this.messageHandler = messageHandler;
+    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);
+
+    // Observable: constructed and ready to receive data
+    this.emit(StreamEvent.START, {
+      streamId: this.streamId,
+      type: this.type,
+      chunked: this.chunked,
+      mode: this.mode,
+      metadata: this.metadata
+    });
+  }
+  postControl(type, body) {
+    var message = 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 !== StreamStateConstant.PENDING && this._state !== StreamStateConstant.STREAMING) return;
+    try {
+      this.postControl(MessageType.STREAM_PULL, {
+        credit
+      });
+      this.emit(StreamEvent.PULL, {
+        credit
+      });
+    } catch (_unused) {
+      /** ignore */
+    }
+  }
+  schedulePullIfNeeded() {
+    if (this.pullScheduled) return;
+    this.pullScheduled = true;
+    Promise.resolve().then(() => {
+      this.pullScheduled = false;
+      if (this._state !== StreamStateConstant.PENDING && this._state !== StreamStateConstant.STREAMING) return;
+      var need = Math.max(0, this.highWaterMark - this.chunks.length);
+      if (need > 0) {
+        this.requestMore(need);
+      }
+    });
+  }
+
+  /** Get stream state */
+  get state() {
+    return super.state;
+  }
+
+  /**
+   * Handle stream message
+   */
+  handleStreamMessage(data) {
+    // Mark activity on any incoming stream message
+    this.lastActivityAt = Date.now();
+    switch (data.type) {
+      case StreamInternalMessageType.DATA:
+        this.handleData(data.data, data.done, data.seq);
+        break;
+      case StreamInternalMessageType.END:
+        this.handleEnd();
+        break;
+      case StreamInternalMessageType.ERROR:
+        this.handleError(new Error(data.error || Messages.STREAM_ERROR));
+        break;
+      case StreamInternalMessageType.CANCEL:
+        this.handleCancel(data.reason);
+        break;
+      case StreamInternalMessageType.PULL:
+        // Control messages for writer side; ignore in readable stream
+        break;
+    }
+  }
+
+  /**
+   * Handle data chunk (internal method)
+   */
+  handleData(data, done, seq) {
+    if (this._state !== StreamStateConstant.PENDING && this._state !== StreamStateConstant.STREAMING) return;
+    this._state = StreamStateConstant.STREAMING;
+    var decoded = this.decodeData(data);
+    this.chunks.push(decoded);
+    this.emit(StreamEvent.DATA, {
+      chunk: decoded,
+      done,
+      seq
+    });
+    this.emit(StreamEvent.STATE, {
+      state: this._state
+    });
+    this.notifyWaiters();
+    this.schedulePullIfNeeded();
+    if (done) {
+      this.handleEnd();
+    }
+  }
+
+  /**
+   * Decode data (subclasses can override, e.g., FileStream needs Base64 decoding)
+   */
+  decodeData(data) {
+    return data;
+  }
+
+  /**
+   * Stream ended (internal handling)
+   */
+  handleEnd() {
+    var _this$onEndCallback;
+    if (this._state === StreamStateConstant.ENDED) return;
+    super.end();
+    this.messageHandler.unregisterStreamHandler(this.streamId);
+    this.notifyWaiters();
+    (_this$onEndCallback = this.onEndCallback) === null || _this$onEndCallback === void 0 || _this$onEndCallback.call(this);
+    this.clearAllListeners();
+  }
+
+  /**
+   * Merge data chunks (subclasses can override)
+   */
+  mergeChunks() {
+    if (this.chunks.length === 0) {
+      return undefined;
+    }
+    if (this.chunks.length === 1) {
+      return this.chunks[0];
+    }
+    // Default returns array
+    return this.chunks;
+  }
+
+  /**
+   * Stream error (internal method)
+   */
+  handleError(error) {
+    var _this$onErrorCallback;
+    if (this._state === StreamStateConstant.ENDED || this._state === StreamStateConstant.ERROR) return;
+    super.fail(error);
+    this.messageHandler.unregisterStreamHandler(this.streamId);
+    this.notifyWaiters();
+    (_this$onErrorCallback = this.onErrorCallback) === null || _this$onErrorCallback === void 0 || _this$onErrorCallback.call(this, error);
+    this.clearAllListeners();
+  }
+
+  /**
+   * Stream cancelled (internal method)
+   */
+  handleCancel(reason) {
+    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 === StreamStateConstant.ENDED || this._state === StreamStateConstant.ERROR || this._state === StreamStateConstant.CANCELLED) return;
+    super.cancel(formatMessage(Messages.STREAM_CANCELLED, reason || ''));
+    this.notifyWaiters();
+    this.emit(StreamEvent.CANCEL, {
+      reason,
+      remote: notifyRemote
+    });
+    if (notifyRemote) {
+      try {
+        /** Notify server to cancel */
+        var _message = createPostMessage(MessageType.STREAM_CANCEL, this.requestId, {
+          secretKey: this.secretKey,
+          body: {
+            streamId: this.streamId,
+            reason
+          }
+        });
+        this.messageHandler.postMessage(_message);
+      } catch (_unused2) {
+        /** ignore send failures on cancel/abort */
+      }
+    }
+    this.messageHandler.unregisterStreamHandler(this.streamId);
+    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(Messages.STREAM_CANCELLED));
+    }
+    this.clearAllListeners();
+  }
+  performHeartbeat() {
+    var _this = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.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 _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var state0, snapshot, timerId, stateAfter, ok;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            state0 = _this2._state;
+            if (!(state0 === StreamStateConstant.ENDED || state0 === StreamStateConstant.ERROR || state0 === StreamStateConstant.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 === StreamStateConstant.ENDED || stateAfter === StreamStateConstant.ERROR || stateAfter === StreamStateConstant.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.emit(StreamEvent.TIMEOUT, {
+              timeout: _this2.idleTimeout
+            });
+            _this2.handleError(new Error(formatMessage(Messages.STREAM_TIMEOUT, _this2.idleTimeout)));
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  }
+
+  /**
+   * Read all data
+   */
+  read() {
+    var _this3 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var merged, _merged;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!(_this3._state === StreamStateConstant.ENDED)) {
+              _context3.next = 1;
+              break;
+            }
+            merged = _this3.mergeChunks();
+            _this3.emit(StreamEvent.READ, {
+              value: merged
+            });
+            return _context3.abrupt("return", merged);
+          case 1:
+            if (!(_this3._state === StreamStateConstant.ERROR || _this3._state === StreamStateConstant.CANCELLED)) {
+              _context3.next = 2;
+              break;
+            }
+            throw _this3.terminalError || new Error(Messages.STREAM_READ_ERROR);
+          case 2:
+            if (!(_this3._state === StreamStateConstant.PENDING || _this3._state === StreamStateConstant.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 === StreamStateConstant.ENDED)) {
+              _context3.next = 5;
+              break;
+            }
+            _merged = _this3.mergeChunks();
+            _this3.emit(StreamEvent.READ, {
+              value: _merged
+            });
+            return _context3.abrupt("return", _merged);
+          case 5:
+            throw _this3.terminalError || new Error(Messages.STREAM_READ_ERROR);
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  }
+
+  /**
+   * Read all chunks as an array
+   */
+  readAll() {
+    var _this4 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      var list, _list;
+      return _regeneratorRuntime.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!(_this4._state === StreamStateConstant.ENDED)) {
+              _context4.next = 1;
+              break;
+            }
+            list = _this4.chunks.slice();
+            _this4.emit(StreamEvent.READ, {
+              value: list
+            });
+            return _context4.abrupt("return", list);
+          case 1:
+            if (!(_this4._state === StreamStateConstant.ERROR || _this4._state === StreamStateConstant.CANCELLED)) {
+              _context4.next = 2;
+              break;
+            }
+            throw _this4.terminalError || new Error(Messages.STREAM_READ_ERROR);
+          case 2:
+            if (!(_this4._state === StreamStateConstant.PENDING || _this4._state === StreamStateConstant.STREAMING)) {
+              _context4.next = 4;
+              break;
+            }
+            _this4.schedulePullIfNeeded();
+            _context4.next = 3;
+            return _this4.waitForChangeWithIdleTimeout();
+          case 3:
+            _context4.next = 2;
+            break;
+          case 4:
+            if (!(_this4._state === StreamStateConstant.ENDED)) {
+              _context4.next = 5;
+              break;
+            }
+            _list = _this4.chunks.slice();
+            _this4.emit(StreamEvent.READ, {
+              value: _list
+            });
+            return _context4.abrupt("return", _list);
+          case 5:
+            throw _this4.terminalError || new Error(Messages.STREAM_READ_ERROR);
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  }
+
+  /**
+   * Async iterator
+   */
+  [Symbol.asyncIterator]() {
+    var index = 0;
+    var stream = this;
+    return {
+      next() {
+        return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+          var value;
+          return _regeneratorRuntime.wrap(function (_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
+              case 0:
+                if (!(index >= stream.chunks.length)) {
+                  _context5.next = 3;
+                  break;
+                }
+                if (!(stream._state === StreamStateConstant.ENDED || stream._state === StreamStateConstant.ERROR || stream._state === StreamStateConstant.CANCELLED)) {
+                  _context5.next = 1;
+                  break;
+                }
+                return _context5.abrupt("return", {
+                  done: true,
+                  value: undefined
+                });
+              case 1:
+                // Consumer is ready: request at least 1 chunk
+                stream.requestMore(1);
+                _context5.next = 2;
+                return stream.waitForChangeWithIdleTimeout();
+              case 2:
+                _context5.next = 0;
+                break;
+              case 3:
+                value = stream.chunks[index++];
+                stream.emit(StreamEvent.READ, {
+                  value
+                });
+                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
+                });
+              case 4:
+              case "end":
+                return _context5.stop();
+            }
+          }, _callee5);
+        }))();
+      }
+    };
+  }
+
+  /**
+   * Abort stream (is alias of cancel method)
+   */
+  abort(reason) {
+    this.cancelInternal(reason, true);
+  }
+
+  /**
+   * Cancel stream
+   */
+  cancel(reason) {
+    this.cancelInternal(reason, true);
+  }
+
+  /**
+   * Listen for stream end
+   */
+  onEnd(callback) {
+    this.onEndCallback = callback;
+    if (this._state === StreamStateConstant.ENDED) {
+      callback();
+    }
+  }
+
+  /**
+   * Listen for stream error
+   */
+  onError(callback) {
+    this.onErrorCallback = callback;
+  }
+}