request-iframe 0.0.1

package/library/stream/writable-stream.js

@@ -0,0 +1,348 @@
+"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
+});
+exports.IframeWritableStream = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+require("core-js/modules/es.symbol.description.js");
+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.regexp.to-string.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _utils = require("../utils");
+var _constants = require("../constants");
+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; }
+function _asyncIterator(r) { var n, t, o, e = 2; for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { if (t && null != (n = r[t])) return n.call(r); if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); t = "@@asyncIterator", o = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
+function AsyncFromSyncIterator(r) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var n = r.done; return Promise.resolve(r.value).then(function (r) { return { value: r, done: n }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) { this.s = r, this.n = r.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(r) { var n = this.s.return; return void 0 === n ? Promise.resolve({ value: r, done: !0 }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); }, throw: function _throw(r) { var n = this.s.return; return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(r); }
+/**
+ * Generate a unique stream ID
+ */
+function generateStreamId() {
+  return `stream_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+
+/**
+ * IframeWritableStream - Server-side writable stream
+ * Used to send stream data to the client
+ */
+class IframeWritableStream {
+  constructor(options = {}) {
+    var _options$type, _options$chunked;
+    (0, _defineProperty2.default)(this, "_state", _constants.StreamState.PENDING);
+    (0, _defineProperty2.default)(this, "context", null);
+    this.streamId = generateStreamId();
+    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.iterator = options.iterator;
+    this.nextFn = options.next;
+    this.metadata = options.metadata;
+  }
+
+  /** Get stream state */
+  get state() {
+    return this._state;
+  }
+
+  /**
+   * Bind to request context
+   * Called during res.sendStream()
+   */
+  _bind(context) {
+    this.context = context;
+  }
+
+  /**
+   * Send message to client
+   */
+  sendMessage(type, data) {
+    if (!this.context) {
+      throw new Error(_constants.Messages.STREAM_NOT_BOUND);
+    }
+    var message = (0, _utils.createPostMessage)(type, this.context.requestId, {
+      secretKey: this.context.secretKey,
+      body: _objectSpread({
+        streamId: this.streamId
+      }, data)
+    });
+
+    // Use channel if available, otherwise use direct postMessage
+    if (this.context.channel) {
+      this.context.channel.send(this.context.targetWindow, message, this.context.targetOrigin);
+    } else {
+      this.context.targetWindow.postMessage(message, this.context.targetOrigin);
+    }
+  }
+
+  /**
+   * Start stream transfer
+   */
+  start() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var _t;
+      return _regenerator.default.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (_this.context) {
+              _context.next = 1;
+              break;
+            }
+            throw new Error(_constants.Messages.STREAM_NOT_BOUND);
+          case 1:
+            if (!(_this._state !== _constants.StreamState.PENDING)) {
+              _context.next = 2;
+              break;
+            }
+            throw new Error(_constants.Messages.STREAM_ALREADY_STARTED);
+          case 2:
+            _this._state = _constants.StreamState.STREAMING;
+
+            // Send stream start message
+            _this.sendMessage(_constants.MessageType.STREAM_START, {
+              type: _this.type,
+              chunked: _this.chunked,
+              metadata: _this.metadata
+            });
+            _context.prev = 3;
+            if (!_this.iterator) {
+              _context.next = 5;
+              break;
+            }
+            _context.next = 4;
+            return _this.streamFromIterator();
+          case 4:
+            _context.next = 8;
+            break;
+          case 5:
+            if (!_this.nextFn) {
+              _context.next = 7;
+              break;
+            }
+            _context.next = 6;
+            return _this.streamFromNext();
+          case 6:
+            _context.next = 8;
+            break;
+          case 7:
+            // No data source, end directly
+            _this.end();
+          case 8:
+            _context.next = 10;
+            break;
+          case 9:
+            _context.prev = 9;
+            _t = _context["catch"](3);
+            _this.error(_t.message || String(_t));
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[3, 9]]);
+    }))();
+  }
+
+  /**
+   * Generate data from iterator
+   */
+  streamFromIterator() {
+    var _this2 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var gen, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, chunk, _t2, _t3;
+      return _regenerator.default.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (_this2.iterator) {
+              _context2.next = 1;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 1:
+            gen = _this2.iterator();
+            _context2.prev = 2;
+            _iteratorAbruptCompletion = false;
+            _didIteratorError = false;
+            _context2.prev = 3;
+            _iterator = _asyncIterator(gen);
+          case 4:
+            _context2.next = 5;
+            return _iterator.next();
+          case 5:
+            if (!(_iteratorAbruptCompletion = !(_step = _context2.sent).done)) {
+              _context2.next = 8;
+              break;
+            }
+            chunk = _step.value;
+            if (!(_this2._state !== _constants.StreamState.STREAMING)) {
+              _context2.next = 6;
+              break;
+            }
+            return _context2.abrupt("continue", 8);
+          case 6:
+            _this2.sendData(chunk);
+          case 7:
+            _iteratorAbruptCompletion = false;
+            _context2.next = 4;
+            break;
+          case 8:
+            _context2.next = 10;
+            break;
+          case 9:
+            _context2.prev = 9;
+            _t2 = _context2["catch"](3);
+            _didIteratorError = true;
+            _iteratorError = _t2;
+          case 10:
+            _context2.prev = 10;
+            _context2.prev = 11;
+            if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
+              _context2.next = 12;
+              break;
+            }
+            _context2.next = 12;
+            return _iterator.return();
+          case 12:
+            _context2.prev = 12;
+            if (!_didIteratorError) {
+              _context2.next = 13;
+              break;
+            }
+            throw _iteratorError;
+          case 13:
+            return _context2.finish(12);
+          case 14:
+            return _context2.finish(10);
+          case 15:
+            if (_this2._state === _constants.StreamState.STREAMING) {
+              _this2.end();
+            }
+            _context2.next = 17;
+            break;
+          case 16:
+            _context2.prev = 16;
+            _t3 = _context2["catch"](2);
+            if (_this2._state === _constants.StreamState.STREAMING) {
+              _this2.error(_t3.message || String(_t3));
+            }
+          case 17:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[2, 16], [3, 9, 10, 15], [11,, 12, 14]]);
+    }))();
+  }
+
+  /**
+   * Generate data from next function
+   */
+  streamFromNext() {
+    var _this3 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var result, _t4;
+      return _regenerator.default.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            if (_this3.nextFn) {
+              _context3.next = 1;
+              break;
+            }
+            return _context3.abrupt("return");
+          case 1:
+            _context3.prev = 1;
+          case 2:
+            if (!(_this3._state === _constants.StreamState.STREAMING)) {
+              _context3.next = 5;
+              break;
+            }
+            _context3.next = 3;
+            return Promise.resolve(_this3.nextFn());
+          case 3:
+            result = _context3.sent;
+            if (!result.done) {
+              _context3.next = 4;
+              break;
+            }
+            _this3.sendData(result.data, true);
+            _this3.end();
+            return _context3.abrupt("continue", 5);
+          case 4:
+            _this3.sendData(result.data);
+            _context3.next = 2;
+            break;
+          case 5:
+            _context3.next = 7;
+            break;
+          case 6:
+            _context3.prev = 6;
+            _t4 = _context3["catch"](1);
+            if (_this3._state === _constants.StreamState.STREAMING) {
+              _this3.error(_t4.message || String(_t4));
+            }
+          case 7:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[1, 6]]);
+    }))();
+  }
+
+  /**
+   * Send data chunk
+   */
+  sendData(data, done = false) {
+    this.sendMessage(_constants.MessageType.STREAM_DATA, {
+      data: this.encodeData(data),
+      done
+    });
+  }
+
+  /**
+   * Encode data (subclasses can override, e.g., FileStream needs Base64 encoding)
+   */
+  encodeData(data) {
+    return data;
+  }
+
+  /**
+   * End stream
+   */
+  end() {
+    if (this._state !== _constants.StreamState.STREAMING) return;
+    this._state = _constants.StreamState.ENDED;
+    this.sendMessage(_constants.MessageType.STREAM_END);
+  }
+
+  /**
+   * Send error
+   */
+  error(message) {
+    if (this._state !== _constants.StreamState.STREAMING) return;
+    this._state = _constants.StreamState.ERROR;
+    this.sendMessage(_constants.MessageType.STREAM_ERROR, {
+      error: message
+    });
+  }
+
+  /**
+   * Cancel stream transfer
+   */
+  cancel(reason) {
+    if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
+    this._state = _constants.StreamState.CANCELLED;
+    if (this.context) {
+      this.sendMessage(_constants.MessageType.STREAM_CANCEL, {
+        reason
+      });
+    }
+  }
+}
+exports.IframeWritableStream = IframeWritableStream;