request-iframe 0.1.1 → 0.2.1

package/esm/endpoint/infra/outbox.js

@@ -0,0 +1,408 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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 _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.promise.finally.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import { isIframeWritableStream } from '../../stream';
+import { createIframeFileWritableStreamFromContent } from '../stream/file-writable';
+import { SyncHook } from '../../utils/hooks';
+
+/**
+ * Outbox hooks for send pipelines.
+ */
+
+/**
+ * Stream send pipeline params.
+ */
+
+/**
+ * File send pipeline params.
+ */
+
+/**
+ * Universal send pipeline params.
+ */
+
+function safeIsFile(data) {
+  try {
+    return typeof File !== 'undefined' && data instanceof File;
+  } catch (_unused) {
+    return false;
+  }
+}
+function safeIsBlob(data) {
+  try {
+    return typeof Blob !== 'undefined' && data instanceof Blob;
+  } catch (_unused2) {
+    return false;
+  }
+}
+
+/**
+ * RequestIframeEndpointOutbox
+ *
+ * A lightweight "built-in sender" bound to a fixed peer (targetWindow/targetOrigin).
+ * Used by request/response-side objects to send messages without repeatedly passing
+ * targetWindow/targetOrigin.
+ */
+export class RequestIframeEndpointOutbox {
+  constructor(dispatcher, targetWindow, targetOrigin, defaultTargetId) {
+    _defineProperty(this, "hooks", {
+      beforeSendRaw: new SyncHook(),
+      afterSendRaw: new SyncHook(),
+      sendRawError: new SyncHook(),
+      beforeSendMessage: new SyncHook(),
+      afterSendMessage: new SyncHook(),
+      sendMessageError: new SyncHook()
+    });
+    this.dispatcher = dispatcher;
+    this.targetWindow = targetWindow;
+    this.targetOrigin = targetOrigin;
+    this.defaultTargetId = defaultTargetId;
+  }
+  setDefaultTargetId(targetId) {
+    this.defaultTargetId = targetId;
+  }
+  get secretKey() {
+    return this.dispatcher.secretKey;
+  }
+  get channel() {
+    return this.dispatcher.getChannel();
+  }
+  runWithHooks(hooks, fn) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var result, _t;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            if (!hooks.before) {
+              _context.next = 1;
+              break;
+            }
+            _context.next = 1;
+            return hooks.before();
+          case 1:
+            _context.next = 2;
+            return fn();
+          case 2:
+            result = _context.sent;
+            if (!hooks.end) {
+              _context.next = 3;
+              break;
+            }
+            _context.next = 3;
+            return hooks.end(result);
+          case 3:
+            return _context.abrupt("return", result);
+          case 4:
+            _context.prev = 4;
+            _t = _context["catch"](0);
+            if (!hooks.error) {
+              _context.next = 6;
+              break;
+            }
+            _context.next = 5;
+            return hooks.error(_t);
+          case 5:
+            return _context.abrupt("return", _context.sent);
+          case 6:
+            throw _t;
+          case 7:
+            _context.prev = 7;
+            if (!hooks.finally) {
+              _context.next = 8;
+              break;
+            }
+            _context.next = 8;
+            return hooks.finally();
+          case 8:
+            return _context.finish(7);
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 4, 7, 9]]);
+    }))();
+  }
+
+  /**
+   * Create a stream bind context using this peer's fixed target info.
+   *
+   * This helps unify the duplicated `_bind({ targetWindow, targetOrigin, secretKey, channel, ... })` logic
+   * across client/server response implementations.
+   */
+  createStreamBindContext(params) {
+    var _params$targetId;
+    return {
+      requestId: params.requestId,
+      targetWindow: this.targetWindow,
+      targetOrigin: this.targetOrigin,
+      secretKey: this.secretKey,
+      channel: this.channel,
+      registerStreamHandler: params.registerStreamHandler,
+      unregisterStreamHandler: params.unregisterStreamHandler,
+      heartbeat: params.heartbeat,
+      serverId: params.serverId,
+      clientId: params.clientId,
+      targetId: (_params$targetId = params.targetId) !== null && _params$targetId !== void 0 ? _params$targetId : this.defaultTargetId
+    };
+  }
+
+  /**
+   * Bind and start a writable stream to this peer.
+   *
+   * Note:
+   * - Client-side request-body streams may need to delay `start()` until after REQUEST is sent.
+   *   For that case, prefer `createStreamBindContext()` + manual `stream.start()`.
+   */
+  sendWritableStream(stream, params) {
+    var _this = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            stream._bind(_this.createStreamBindContext(params));
+            _context2.next = 1;
+            return stream.start();
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  }
+
+  /**
+   * Universal send - dispatch by data type, then call hooks to implement differences.
+   */
+  send(params) {
+    var _this2 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      return _regeneratorRuntime.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            return _context4.abrupt("return", _this2.runWithHooks(params, /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+              var data;
+              return _regeneratorRuntime.wrap(function (_context3) {
+                while (1) switch (_context3.prev = _context3.next) {
+                  case 0:
+                    data = params.data;
+                    if (!isIframeWritableStream(data)) {
+                      _context3.next = 4;
+                      break;
+                    }
+                    if (!params.onStream) {
+                      _context3.next = 2;
+                      break;
+                    }
+                    _context3.next = 1;
+                    return params.onStream(data);
+                  case 1:
+                    return _context3.abrupt("return", _context3.sent);
+                  case 2:
+                    _context3.next = 3;
+                    return params.onOther(data);
+                  case 3:
+                    return _context3.abrupt("return", _context3.sent);
+                  case 4:
+                    if (!(safeIsFile(data) || safeIsBlob(data))) {
+                      _context3.next = 8;
+                      break;
+                    }
+                    if (!params.onFileOrBlob) {
+                      _context3.next = 6;
+                      break;
+                    }
+                    _context3.next = 5;
+                    return params.onFileOrBlob(data);
+                  case 5:
+                    return _context3.abrupt("return", _context3.sent);
+                  case 6:
+                    _context3.next = 7;
+                    return params.onOther(data);
+                  case 7:
+                    return _context3.abrupt("return", _context3.sent);
+                  case 8:
+                    _context3.next = 9;
+                    return params.onOther(data);
+                  case 9:
+                    return _context3.abrupt("return", _context3.sent);
+                  case 10:
+                  case "end":
+                    return _context3.stop();
+                }
+              }, _callee3);
+            }))));
+          case 1:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  }
+  runStreamSend(params) {
+    var _this3 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+      var resultPromise, result;
+      return _regeneratorRuntime.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            params.stream._bind(_this3.createStreamBindContext(params.bind));
+            resultPromise = params.beforeStart ? params.beforeStart({
+              stream: params.stream
+            }) : undefined;
+            if (!(params.awaitStart === false)) {
+              _context5.next = 2;
+              break;
+            }
+            /**
+             * Fire-and-forget:
+             * - request-body stream must start after REQUEST is sent (beforeStart is expected to send REQUEST synchronously)
+             * - we must NOT await the response promise before starting stream, otherwise server will time out waiting stream_start
+             */
+            void params.stream.start();
+            _context5.next = 1;
+            return resultPromise;
+          case 1:
+            return _context5.abrupt("return", _context5.sent);
+          case 2:
+            _context5.next = 3;
+            return resultPromise;
+          case 3:
+            result = _context5.sent;
+            _context5.next = 4;
+            return params.stream.start();
+          case 4:
+            return _context5.abrupt("return", result);
+          case 5:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }))();
+  }
+
+  /**
+   * Send writable stream via peer.
+   */
+  sendStream(params) {
+    var _this4 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+      return _regeneratorRuntime.wrap(function (_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            return _context7.abrupt("return", _this4.runWithHooks(params, /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+              return _regeneratorRuntime.wrap(function (_context6) {
+                while (1) switch (_context6.prev = _context6.next) {
+                  case 0:
+                    _context6.next = 1;
+                    return _this4.runStreamSend(params);
+                  case 1:
+                    return _context6.abrupt("return", _context6.sent);
+                  case 2:
+                  case "end":
+                    return _context6.stop();
+                }
+              }, _callee6);
+            }))));
+          case 1:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    }))();
+  }
+
+  /**
+   * Send File/Blob/string as a file stream via peer.
+   */
+  sendFile(params) {
+    var _this5 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+      return _regeneratorRuntime.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            return _context9.abrupt("return", _this5.runWithHooks(params, /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+              var _params$onFileInfo;
+              var created;
+              return _regeneratorRuntime.wrap(function (_context8) {
+                while (1) switch (_context8.prev = _context8.next) {
+                  case 0:
+                    _context8.next = 1;
+                    return createIframeFileWritableStreamFromContent({
+                      content: params.content,
+                      fileName: params.fileName,
+                      mimeType: params.mimeType,
+                      chunked: params.chunked,
+                      autoResolve: params.autoResolve,
+                      defaultFileName: params.defaultFileName,
+                      defaultMimeType: params.defaultMimeType
+                    });
+                  case 1:
+                    created = _context8.sent;
+                    _context8.next = 2;
+                    return (_params$onFileInfo = params.onFileInfo) === null || _params$onFileInfo === void 0 ? void 0 : _params$onFileInfo.call(params, {
+                      fileName: created.fileName,
+                      mimeType: created.mimeType
+                    });
+                  case 2:
+                    _context8.next = 3;
+                    return _this5.runStreamSend(_objectSpread(_objectSpread({}, params.stream), {}, {
+                      stream: created.stream
+                    }));
+                  case 3:
+                    return _context8.abrupt("return", _context8.sent);
+                  case 4:
+                  case "end":
+                    return _context8.stop();
+                }
+              }, _callee8);
+            }))));
+          case 1:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    }))();
+  }
+
+  /**
+   * Send typed message with peer pre-bound.
+   */
+  sendMessage(type, requestId, data) {
+    var payload = _objectSpread({}, data || {});
+    if (payload.targetId === undefined && this.defaultTargetId !== undefined) {
+      payload.targetId = this.defaultTargetId;
+    }
+    this.hooks.beforeSendMessage.call(type, requestId, payload);
+    try {
+      var _ok = this.dispatcher.sendMessage(this.targetWindow, this.targetOrigin, type, requestId, payload);
+      this.hooks.afterSendMessage.call(type, requestId, payload, _ok);
+      return _ok;
+    } catch (e) {
+      this.hooks.sendMessageError.call(type, requestId, payload, e);
+      throw e;
+    }
+  }
+
+  /**
+   * Send raw message with peer pre-bound.
+   */
+  sendRaw(message) {
+    this.hooks.beforeSendRaw.call(message);
+    try {
+      var _ok2 = this.dispatcher.send(this.targetWindow, message, this.targetOrigin);
+      this.hooks.afterSendRaw.call(message, _ok2);
+      return _ok2;
+    } catch (e) {
+      this.hooks.sendRawError.call(message, e);
+      throw e;
+    }
+  }
+}

package/esm/endpoint/stream/dispatcher.js

@@ -0,0 +1,58 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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 "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+/**
+ * Endpoint Stream integration layer (`src/endpoint/stream`)
+ *
+ * This directory integrates postMessage `stream_*` messages with the stream object system in `src/stream`:
+ * - Demultiplex `stream_*` frames by streamId to the bound handler
+ * - Does NOT implement the stream protocol itself (protocol lives in `src/stream`)
+ *
+ * RequestIframeStreamDispatcher
+ *
+ * - Maintains streamId -> handler mapping
+ * - Dispatches incoming `stream_*` PostMessageData to the mapped handler
+ */
+export class RequestIframeStreamDispatcher {
+  constructor(params) {
+    _defineProperty(this, "handlers", new Map());
+    this.handledBy = params.handledBy;
+  }
+  register(streamId, handler) {
+    this.handlers.set(streamId, handler);
+  }
+  unregister(streamId) {
+    this.handlers.delete(streamId);
+  }
+  clear() {
+    this.handlers.clear();
+  }
+
+  /**
+   * Dispatch a framework stream_* PostMessageData to its streamId handler.
+   *
+   * - If context is provided, dispatcher will mark accepted/handledBy when handler exists.
+   * - If context is omitted, dispatcher will skip marking (useful when origin was validated upstream).
+   */
+  dispatch(data, context) {
+    var body = data.body;
+    if (!(body !== null && body !== void 0 && body.streamId)) return;
+    var handler = this.handlers.get(body.streamId);
+    if (!handler) return;
+    if (context) {
+      context.markAcceptedBy(this.handledBy);
+    }
+    var messageType = data.type.replace('stream_', '');
+    handler(_objectSpread(_objectSpread({}, body), {}, {
+      type: messageType
+    }));
+  }
+}

package/esm/endpoint/stream/errors.js

@@ -0,0 +1,27 @@
+import { ErrorCode, HttpStatus, HttpStatusText, Messages, formatMessage } from '../../constants';
+
+/**
+ * Endpoint Stream integration layer (`src/endpoint/stream`)
+ *
+ * This directory integrates postMessage `stream_*` messages with the stream object system in `src/stream`:
+ * - Endpoint-side composition / protocol glue (e.g. stream_start timeout error payload)
+ * - Does NOT implement the stream protocol itself (protocol lives in `src/stream`)
+ *
+ * Build the ERROR payload for stream_start timeout.
+ *
+ * Used by server-side "request-body stream handshake" when the client fails to send stream_start in time.
+ */
+export function buildStreamStartTimeoutErrorPayload(params) {
+  return {
+    path: params.path,
+    error: {
+      message: formatMessage(Messages.STREAM_START_TIMEOUT, params.timeoutMs),
+      code: ErrorCode.STREAM_START_TIMEOUT
+    },
+    status: HttpStatus.REQUEST_TIMEOUT,
+    statusText: HttpStatusText[HttpStatus.REQUEST_TIMEOUT],
+    requireAck: params.requireAck,
+    ack: params.ack,
+    targetId: params.targetId
+  };
+}

package/esm/endpoint/stream/factory.js

@@ -0,0 +1,76 @@
+import { IframeReadableStream, IframeFileReadableStream } from '../../stream';
+import { StreamType as StreamTypeConstant } from '../../constants';
+
+/**
+ * Endpoint Stream integration layer (`src/endpoint/stream`)
+ *
+ * This directory integrates postMessage `stream_*` messages with the stream object system in `src/stream`:
+ * - Parses stream_start and creates the corresponding ReadableStream (data/file)
+ * - Does NOT implement the stream protocol itself (protocol lives in `src/stream`)
+ */
+
+/**
+ * Parsed stream_start body info.
+ */
+
+/**
+ * Parse stream_start body with defaults.
+ */
+export function parseStreamStart(body) {
+  var _chunked, _autoResolve;
+  var b = body;
+  if (!(b !== null && b !== void 0 && b.streamId)) return null;
+  return {
+    streamId: b.streamId,
+    type: b.type || StreamTypeConstant.DATA,
+    mode: b.mode,
+    chunked: (_chunked = b.chunked) !== null && _chunked !== void 0 ? _chunked : true,
+    metadata: b.metadata,
+    autoResolve: (_autoResolve = b.autoResolve) !== null && _autoResolve !== void 0 ? _autoResolve : false
+  };
+}
+
+/**
+ * Create a readable stream instance from a stream_start message/body.
+ *
+ * This is shared by:
+ * - client side: receiving response stream from server
+ * - server side: receiving request-body stream from client
+ */
+export function createReadableStreamFromStart(params) {
+  var _params$secretKey;
+  var info = parseStreamStart(params.data.body);
+  if (!info) return null;
+  var secretKey = (_params$secretKey = params.secretKey) !== null && _params$secretKey !== void 0 ? _params$secretKey : params.data.secretKey;
+  if (info.type === StreamTypeConstant.FILE) {
+    var _info$metadata, _info$metadata2, _info$metadata3;
+    var fileStream = new IframeFileReadableStream(info.streamId, params.requestId, params.handler, {
+      chunked: info.chunked,
+      metadata: info.metadata,
+      secretKey,
+      mode: info.mode,
+      idleTimeout: params.idleTimeout,
+      heartbeat: params.heartbeat,
+      filename: (_info$metadata = info.metadata) === null || _info$metadata === void 0 ? void 0 : _info$metadata.filename,
+      mimeType: (_info$metadata2 = info.metadata) === null || _info$metadata2 === void 0 ? void 0 : _info$metadata2.mimeType,
+      size: (_info$metadata3 = info.metadata) === null || _info$metadata3 === void 0 ? void 0 : _info$metadata3.size
+    });
+    return {
+      stream: fileStream,
+      info
+    };
+  }
+  var readableStream = new IframeReadableStream(info.streamId, params.requestId, params.handler, {
+    type: info.type,
+    mode: info.mode,
+    chunked: info.chunked,
+    metadata: info.metadata,
+    secretKey,
+    idleTimeout: params.idleTimeout,
+    heartbeat: params.heartbeat
+  });
+  return {
+    stream: readableStream,
+    info
+  };
+}

package/esm/endpoint/stream/file-auto-resolve.js

@@ -0,0 +1,34 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.match.js";
+import { HttpHeader } from '../../constants';
+/**
+ * Endpoint Stream integration layer (`src/endpoint/stream`)
+ *
+ * This directory integrates postMessage `stream_*` messages with the stream object system in `src/stream`:
+ * - Endpoint-side file stream utilities (e.g. choose filename from header/metadata and auto-resolve)
+ * - Does NOT implement the stream protocol itself (protocol lives in `src/stream`)
+ *
+ * Parse filename from Content-Disposition header.
+ */
+export function parseFilenameFromContentDisposition(value) {
+  if (!value) return undefined;
+  var disposition = typeof value === 'string' ? value : value[0];
+  if (!disposition) return undefined;
+  var match = disposition.match(/filename="?([^"]+)"?/i);
+  return match ? match[1] : undefined;
+}
+
+/**
+ * Auto resolve a file readable stream to File/Blob.
+ *
+ * Filename priority:
+ * - Content-Disposition filename (if provided)
+ * - stream_start metadata filename (if provided)
+ * - stream.filename (if provided)
+ */
+export function autoResolveIframeFileReadableStream(params) {
+  var _params$headers, _params$info;
+  var headerFilename = parseFilenameFromContentDisposition((_params$headers = params.headers) === null || _params$headers === void 0 ? void 0 : _params$headers[HttpHeader.CONTENT_DISPOSITION]);
+  var fileName = headerFilename || ((_params$info = params.info) === null || _params$info === void 0 || (_params$info = _params$info.metadata) === null || _params$info === void 0 ? void 0 : _params$info.filename) || params.fileStream.filename;
+  return fileName ? params.fileStream.readAsFile(fileName) : params.fileStream.readAsBlob();
+}