request-iframe 0.1.1 → 0.2.1

package/library/endpoint/infra/outbox.d.ts

@@ -0,0 +1,149 @@
+import type { PostMessageData } from '../../types';
+import { MessageDispatcher } from '../../message';
+import type { IIframeWritableStream, StreamBindContext, StreamMessageData } from '../../stream/types';
+import { SyncHook } from '../../utils/hooks';
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Outbox hooks for send pipelines.
+ */
+export interface RequestIframeOutboxSendHooks<TResult> {
+    /**
+     * Runs before the actual operation.
+     */
+    before?: () => MaybePromise<void>;
+    /**
+     * Runs on success (before finally).
+     */
+    end?: (result: TResult) => MaybePromise<void>;
+    /**
+     * Runs on error.
+     * - If provided, its return value becomes the final result (and the error is swallowed).
+     * - If not provided, error will be thrown.
+     */
+    error?: (err: any) => MaybePromise<TResult>;
+    /**
+     * Runs in finally (always).
+     */
+    finally?: () => MaybePromise<void>;
+}
+/**
+ * Stream send pipeline params.
+ */
+export interface RequestIframeOutboxSendStreamParams<TResult> extends RequestIframeOutboxSendHooks<TResult> {
+    stream: IIframeWritableStream;
+    bind: Parameters<RequestIframeEndpointOutbox['createStreamBindContext']>[0];
+    /**
+     * Default true. If false, stream.start() will be triggered but not awaited.
+     * (Used by client request-body streams: REQUEST must be sent first.)
+     */
+    awaitStart?: boolean;
+    /**
+     * Hook before start. Return value becomes sendStream's result.
+     * (Client uses it to send REQUEST and return the pending response promise.)
+     */
+    beforeStart?: (ctx: {
+        stream: IIframeWritableStream;
+    }) => MaybePromise<TResult>;
+}
+/**
+ * File send pipeline params.
+ */
+export interface RequestIframeOutboxSendFileParams<TResult> extends RequestIframeOutboxSendHooks<TResult> {
+    content: string | Blob | File;
+    fileName?: string;
+    mimeType?: string;
+    chunked?: boolean;
+    autoResolve?: boolean;
+    defaultFileName?: string;
+    defaultMimeType?: string;
+    /**
+     * Called after file stream is created (before stream start).
+     * Useful for response to set headers based on inferred fileName/mimeType.
+     */
+    onFileInfo?: (info: {
+        fileName?: string;
+        mimeType: string;
+    }) => MaybePromise<void>;
+    stream: Omit<RequestIframeOutboxSendStreamParams<TResult>, 'stream'>;
+}
+/**
+ * Universal send pipeline params.
+ */
+export interface RequestIframeOutboxSendParams<TResult> extends RequestIframeOutboxSendHooks<TResult> {
+    data: any;
+    onOther: (data: any) => MaybePromise<TResult>;
+    onStream?: (stream: IIframeWritableStream) => MaybePromise<TResult>;
+    onFileOrBlob?: (fileOrBlob: Blob | File) => MaybePromise<TResult>;
+}
+/**
+ * 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 declare class RequestIframeEndpointOutbox {
+    readonly hooks: {
+        beforeSendRaw: SyncHook<[message: PostMessageData]>;
+        afterSendRaw: SyncHook<[message: PostMessageData, ok: boolean]>;
+        sendRawError: SyncHook<[message: PostMessageData, error: any]>;
+        beforeSendMessage: SyncHook<[type: "error" | "request" | "ack" | "async" | "response" | "ping" | "pong" | "stream_start" | "stream_data" | "stream_end" | "stream_error" | "stream_cancel" | "stream_pull", requestId: string, payload: any]>;
+        afterSendMessage: SyncHook<[type: "error" | "request" | "ack" | "async" | "response" | "ping" | "pong" | "stream_start" | "stream_data" | "stream_end" | "stream_error" | "stream_cancel" | "stream_pull", requestId: string, payload: any, ok: boolean]>;
+        sendMessageError: SyncHook<[type: "error" | "request" | "ack" | "async" | "response" | "ping" | "pong" | "stream_start" | "stream_data" | "stream_end" | "stream_error" | "stream_cancel" | "stream_pull", requestId: string, payload: any, error: any]>;
+    };
+    readonly dispatcher: MessageDispatcher;
+    readonly targetWindow: Window;
+    readonly targetOrigin: string;
+    defaultTargetId?: string;
+    constructor(dispatcher: MessageDispatcher, targetWindow: Window, targetOrigin: string, defaultTargetId?: string);
+    setDefaultTargetId(targetId?: string): void;
+    get secretKey(): string | undefined;
+    get channel(): import("../../message").MessageChannel;
+    private runWithHooks;
+    /**
+     * 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: {
+        requestId: string;
+        registerStreamHandler?: (streamId: string, handler: (data: StreamMessageData) => void) => void;
+        unregisterStreamHandler?: (streamId: string) => void;
+        heartbeat?: () => Promise<boolean>;
+        serverId?: string;
+        clientId?: string;
+        targetId?: string;
+    }): StreamBindContext;
+    /**
+     * 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: IIframeWritableStream, params: Parameters<RequestIframeEndpointOutbox['createStreamBindContext']>[0]): Promise<void>;
+    /**
+     * Universal send - dispatch by data type, then call hooks to implement differences.
+     */
+    send<TResult>(params: RequestIframeOutboxSendParams<TResult>): Promise<TResult>;
+    private runStreamSend;
+    /**
+     * Send writable stream via peer.
+     */
+    sendStream<TResult = void>(params: RequestIframeOutboxSendStreamParams<TResult>): Promise<TResult>;
+    /**
+     * Send File/Blob/string as a file stream via peer.
+     */
+    sendFile<TResult>(params: RequestIframeOutboxSendFileParams<TResult>): Promise<TResult>;
+    /**
+     * Send typed message with peer pre-bound.
+     */
+    sendMessage(type: PostMessageData['type'], requestId: string, data?: Partial<Omit<PostMessageData, '__requestIframe__' | 'type' | 'requestId' | 'timestamp' | 'role' | 'creatorId'>>): boolean;
+    /**
+     * Send raw message with peer pre-bound.
+     */
+    sendRaw(message: PostMessageData): boolean;
+}
+export {};
+//# sourceMappingURL=outbox.d.ts.map

package/library/endpoint/infra/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../../src/endpoint/infra/outbox.ts"],"names":[],"mappings":"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"}

package/library/endpoint/infra/outbox.js

@@ -0,0 +1,415 @@
+"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.RequestIframeEndpointOutbox = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.promise.finally.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _stream = require("../../stream");
+var _fileWritable = require("../stream/file-writable");
+var _hooks = require("../../utils/hooks");
+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; }
+/**
+ * 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.
+ */
+class RequestIframeEndpointOutbox {
+  constructor(dispatcher, targetWindow, targetOrigin, defaultTargetId) {
+    (0, _defineProperty2.default)(this, "hooks", {
+      beforeSendRaw: new _hooks.SyncHook(),
+      afterSendRaw: new _hooks.SyncHook(),
+      sendRawError: new _hooks.SyncHook(),
+      beforeSendMessage: new _hooks.SyncHook(),
+      afterSendMessage: new _hooks.SyncHook(),
+      sendMessageError: new _hooks.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 (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var result, _t;
+      return _regenerator.default.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 (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      return _regenerator.default.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 (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            return _context4.abrupt("return", _this2.runWithHooks(params, /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+              var data;
+              return _regenerator.default.wrap(function (_context3) {
+                while (1) switch (_context3.prev = _context3.next) {
+                  case 0:
+                    data = params.data;
+                    if (!(0, _stream.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 (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var resultPromise, result;
+      return _regenerator.default.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 (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
+      return _regenerator.default.wrap(function (_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            return _context7.abrupt("return", _this4.runWithHooks(params, /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
+              return _regenerator.default.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 (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      return _regenerator.default.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            return _context9.abrupt("return", _this5.runWithHooks(params, /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+              var _params$onFileInfo;
+              var created;
+              return _regenerator.default.wrap(function (_context8) {
+                while (1) switch (_context8.prev = _context8.next) {
+                  case 0:
+                    _context8.next = 1;
+                    return (0, _fileWritable.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;
+    }
+  }
+}
+exports.RequestIframeEndpointOutbox = RequestIframeEndpointOutbox;

package/library/endpoint/stream/dispatcher.d.ts

@@ -0,0 +1,33 @@
+import type { PostMessageData } from '../../types';
+import type { MessageContext } from '../../message';
+import type { StreamMessageData } from '../../stream';
+/**
+ * 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 declare class RequestIframeStreamDispatcher {
+    private readonly handledBy;
+    private readonly handlers;
+    constructor(params: {
+        handledBy: string;
+    });
+    register(streamId: string, handler: (data: StreamMessageData) => void): void;
+    unregister(streamId: string): void;
+    clear(): void;
+    /**
+     * 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: PostMessageData, context?: MessageContext): void;
+}
+//# sourceMappingURL=dispatcher.d.ts.map

package/library/endpoint/stream/dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../../src/endpoint/stream/dispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwD;gBAE9D,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;IAIzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,GAAG,IAAI;IAI5E,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIlC,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;CAavE"}

package/library/endpoint/stream/dispatcher.js

@@ -0,0 +1,66 @@
+"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.RequestIframeStreamDispatcher = void 0;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/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) { (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; }
+/**
+ * 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
+ */
+class RequestIframeStreamDispatcher {
+  constructor(params) {
+    (0, _defineProperty2.default)(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
+    }));
+  }
+}
+exports.RequestIframeStreamDispatcher = RequestIframeStreamDispatcher;