request-iframe 0.0.5 → 0.1.0

package/esm/core/request.js

@@ -0,0 +1,27 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import "core-js/modules/es.object.entries.js";
+/**
+ * ServerRequest implementation
+ */
+export class ServerRequestImpl {
+  constructor(data, context, response, params = {}) {
+    this.body = data.body;
+    // headers may contain array values (e.g., Set-Cookie), simplified to string here
+    this.headers = {};
+    if (data.headers) {
+      for (var _i = 0, _Object$entries = Object.entries(data.headers); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          key = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+        this.headers[key] = Array.isArray(value) ? value.join(', ') : value;
+      }
+    }
+    this.cookies = data.cookies || {};
+    this.path = data.path || '';
+    this.params = params;
+    this.requestId = data.requestId;
+    this.origin = context.origin;
+    this.source = context.source;
+    this.res = response;
+  }
+}

package/esm/core/response.js

@@ -0,0 +1,451 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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.iterator.js";
+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/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { createPostMessage, createSetCookie, createClearCookie, detectContentType, blobToBase64 } from '../utils';
+import { MessageType, HttpStatus, HttpHeader, getStatusText, MessageRole, ErrorCode } from '../constants';
+import { IframeFileWritableStream, isIframeWritableStream } from '../stream';
+import { isAckMetaEqual } from '../utils/ack-meta';
+
+/**
+ * Callback waiting for client acknowledgment
+ */
+
+/**
+ * ServerResponse implementation
+ */
+export class ServerResponseImpl {
+  constructor(requestId, path, secretKey, targetWindow, targetOrigin, channel, serverId, targetId, options) {
+    _defineProperty(this, "statusCode", HttpStatus.OK);
+    _defineProperty(this, "headers", {});
+    _defineProperty(this, "_sent", false);
+    this.requestId = requestId;
+    this.path = path;
+    this.secretKey = secretKey;
+    this.targetWindow = targetWindow;
+    this.targetOrigin = targetOrigin;
+    this.channel = channel;
+    this.serverId = serverId;
+    this.targetId = targetId;
+    this.registerStreamHandler = options === null || options === void 0 ? void 0 : options.registerStreamHandler;
+    this.unregisterStreamHandler = options === null || options === void 0 ? void 0 : options.unregisterStreamHandler;
+    this.heartbeat = options === null || options === void 0 ? void 0 : options.heartbeat;
+    this.onSentCallback = options === null || options === void 0 ? void 0 : options.onSent;
+  }
+
+  /**
+   * Send message via channel
+   */
+  sendMessage(message) {
+    // Window check is handled in MessageDispatcher (via channel.send -> dispatcher.send)
+    this.channel.send(this.targetWindow, message, this.targetOrigin);
+  }
+
+  /**
+   * Check if header exists (case-insensitive)
+   */
+  hasHeader(name) {
+    var lower = name.toLowerCase();
+    return Object.keys(this.headers).some(k => k.toLowerCase() === lower);
+  }
+
+  /**
+   * Detect data type and return appropriate Content-Type
+   * Returns null if Content-Type should not be auto-set
+   */
+  detectContentType(data) {
+    return detectContentType(data, {
+      checkStream: true,
+      isIframeWritableStream
+    });
+  }
+
+  /**
+   * Auto set Content-Type based on data type (only if user not set)
+   */
+  ensureContentTypeIfNeeded(data) {
+    if (this.hasHeader(HttpHeader.CONTENT_TYPE)) return;
+    var contentType = this.detectContentType(data);
+    if (contentType) {
+      this.setHeader(HttpHeader.CONTENT_TYPE, contentType);
+    }
+  }
+
+  /**
+   * Set callback waiting for client acknowledgment
+   */
+  _setOnAckCallback(callback) {
+    this.onAckCallback = callback;
+  }
+
+  /**
+   * Trigger client acknowledgment callback
+   */
+  _triggerAck(received, ackMeta) {
+    if (this.onAckCallback) {
+      this.onAckCallback(received, ackMeta);
+      this.onAckCallback = undefined;
+    }
+  }
+
+  /**
+   * Mark response as sent (and trigger onSent callback once).
+   */
+  markSent() {
+    if (this._sent) return;
+    this._sent = true;
+    if (this.onSentCallback) {
+      var cb = this.onSentCallback;
+      this.onSentCallback = undefined;
+      cb();
+    }
+  }
+
+  /**
+   * Internal: mark as sent for manual error responses.
+   */
+  _markSent() {
+    this.markSent();
+  }
+
+  /**
+   * Internal method: send raw data (used by send after type detection)
+   */
+  _sendRaw(data, options) {
+    var _options$requireAck;
+    if (this._sent) return Promise.resolve(false);
+    this.markSent();
+    var requireAck = (_options$requireAck = options === null || options === void 0 ? void 0 : options.requireAck) !== null && _options$requireAck !== void 0 ? _options$requireAck : false;
+    var expectedAckMeta = options === null || options === void 0 ? void 0 : options.ackMeta;
+    try {
+      // If acknowledgment not required, send directly and return true
+      if (!requireAck) {
+        this.sendMessage(createPostMessage(MessageType.RESPONSE, this.requestId, {
+          path: this.path,
+          secretKey: this.secretKey,
+          data,
+          status: this.statusCode,
+          statusText: getStatusText(this.statusCode),
+          headers: this.headers,
+          requireAck: false,
+          role: MessageRole.SERVER,
+          creatorId: this.serverId,
+          targetId: this.targetId
+        }));
+        return Promise.resolve(true);
+      }
+
+      // Acknowledgment required, wait for client response
+      return new Promise((resolve, reject) => {
+        try {
+          this._setOnAckCallback((received, receivedAckMeta) => {
+            if (!received) {
+              resolve(false);
+              return;
+            }
+            if (expectedAckMeta !== undefined && !isAckMetaEqual(expectedAckMeta, receivedAckMeta)) {
+              resolve(false);
+              return;
+            }
+            resolve(true);
+          });
+          this.sendMessage(createPostMessage(MessageType.RESPONSE, this.requestId, {
+            path: this.path,
+            secretKey: this.secretKey,
+            data,
+            status: this.statusCode,
+            statusText: getStatusText(this.statusCode),
+            headers: this.headers,
+            requireAck: true,
+            ackMeta: expectedAckMeta,
+            role: MessageRole.SERVER,
+            creatorId: this.serverId,
+            targetId: this.targetId
+          }));
+        } catch (error) {
+          // If window is closed, reject immediately
+          if ((error === null || error === void 0 ? void 0 : error.code) === ErrorCode.TARGET_WINDOW_CLOSED) {
+            reject(error);
+          } else {
+            throw error;
+          }
+        }
+      });
+    } catch (error) {
+      // If window is closed, return rejected promise
+      if ((error === null || error === void 0 ? void 0 : error.code) === ErrorCode.TARGET_WINDOW_CLOSED) {
+        return Promise.reject(error);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Universal send method - automatically detects data type and calls appropriate method
+   * - If data is IframeWritableStream, calls sendStream
+   * - If data is File/Blob, calls sendFile
+   * - Otherwise, sends as regular data with auto-detected Content-Type
+   */
+  send(data, options) {
+    var _this = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var fileOptions;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!_this._sent) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return", Promise.resolve(false));
+          case 1:
+            if (!isIframeWritableStream(data)) {
+              _context.next = 3;
+              break;
+            }
+            _context.next = 2;
+            return _this.sendStream(data);
+          case 2:
+            return _context.abrupt("return", true);
+          case 3:
+            if (!(typeof File !== 'undefined' && data instanceof File || typeof Blob !== 'undefined' && data instanceof Blob)) {
+              _context.next = 4;
+              break;
+            }
+            // Extract options for sendFile
+            fileOptions = _objectSpread({
+              requireAck: options === null || options === void 0 ? void 0 : options.requireAck
+            }, typeof File !== 'undefined' && data instanceof File ? {
+              mimeType: data.type,
+              fileName: data.name
+            } : {});
+            return _context.abrupt("return", _this.sendFile(data, fileOptions));
+          case 4:
+            // For other types, auto-detect and set Content-Type, then send
+            _this.ensureContentTypeIfNeeded(data);
+            return _context.abrupt("return", _this._sendRaw(data, options));
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
+  json(data, options) {
+    return this.send(data, options);
+  }
+  sendFile(content, options) {
+    var _this2 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var mimeType, fileName, fileContent, stream;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!_this2._sent) {
+              _context3.next = 1;
+              break;
+            }
+            return _context3.abrupt("return", false);
+          case 1:
+            mimeType = (options === null || options === void 0 ? void 0 : options.mimeType) || 'application/octet-stream';
+            fileName = options === null || options === void 0 ? void 0 : options.fileName;
+            if (!(typeof content === 'string')) {
+              _context3.next = 2;
+              break;
+            }
+            // If it's a plain string, convert to base64
+            fileContent = btoa(unescape(encodeURIComponent(content)));
+            _context3.next = 6;
+            break;
+          case 2:
+            if (!(content instanceof File)) {
+              _context3.next = 4;
+              break;
+            }
+            mimeType = content.type || mimeType;
+            fileName = fileName || content.name;
+            _context3.next = 3;
+            return blobToBase64(content);
+          case 3:
+            fileContent = _context3.sent;
+            _context3.next = 6;
+            break;
+          case 4:
+            _context3.next = 5;
+            return blobToBase64(content);
+          case 5:
+            fileContent = _context3.sent;
+          case 6:
+            // Set file-related headers
+            _this2.setHeader(HttpHeader.CONTENT_TYPE, mimeType);
+            if (fileName) {
+              _this2.setHeader(HttpHeader.CONTENT_DISPOSITION, `attachment; filename="${fileName}"`);
+            } else {
+              _this2.setHeader(HttpHeader.CONTENT_DISPOSITION, 'attachment');
+            }
+
+            // Create file stream with autoResolve enabled
+            stream = new IframeFileWritableStream({
+              filename: fileName || 'file',
+              mimeType,
+              chunked: false,
+              // File is sent in one chunk
+              autoResolve: true,
+              // Client will automatically resolve to fileData
+              next: function () {
+                var _next = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+                  return _regeneratorRuntime.wrap(function (_context2) {
+                    while (1) switch (_context2.prev = _context2.next) {
+                      case 0:
+                        return _context2.abrupt("return", {
+                          data: fileContent,
+                          done: true
+                        });
+                      case 1:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }, _callee2);
+                }));
+                function next() {
+                  return _next.apply(this, arguments);
+                }
+                return next;
+              }()
+            }); // Send stream (this will handle the requireAck logic internally and set _sent)
+            _context3.next = 7;
+            return _this2.sendStream(stream);
+          case 7:
+            return _context3.abrupt("return", true);
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  }
+
+  /**
+   * Send stream response
+   * Bind stream to current request context and start stream transmission
+   */
+  sendStream(stream) {
+    var _this3 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      return _regeneratorRuntime.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!_this3._sent) {
+              _context4.next = 1;
+              break;
+            }
+            return _context4.abrupt("return");
+          case 1:
+            _this3.markSent();
+
+            // Window check is handled in MessageDispatcher when stream sends messages
+
+            // Bind stream to request context
+            stream._bind({
+              requestId: _this3.requestId,
+              targetWindow: _this3.targetWindow,
+              targetOrigin: _this3.targetOrigin,
+              secretKey: _this3.secretKey,
+              channel: _this3.channel,
+              registerStreamHandler: _this3.registerStreamHandler,
+              unregisterStreamHandler: _this3.unregisterStreamHandler,
+              heartbeat: _this3.heartbeat,
+              serverId: _this3.serverId,
+              targetId: _this3.targetId
+            });
+
+            // Start stream transmission
+            _context4.next = 2;
+            return stream.start();
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  }
+  status(code) {
+    this.statusCode = code;
+    return this;
+  }
+  setHeader(name, value) {
+    // Consistent with Express, returns void
+    // Special handling for Set-Cookie, keep as array
+    if (name.toLowerCase() === HttpHeader.SET_COOKIE.toLowerCase()) {
+      var existing = this.headers[HttpHeader.SET_COOKIE];
+      if (Array.isArray(value)) {
+        this.headers[HttpHeader.SET_COOKIE] = Array.isArray(existing) ? [...existing, ...value] : value;
+      } else {
+        var newValue = String(value);
+        if (Array.isArray(existing)) {
+          existing.push(newValue);
+        } else {
+          this.headers[HttpHeader.SET_COOKIE] = [newValue];
+        }
+      }
+    } else if (Array.isArray(value)) {
+      this.headers[name] = value.join(', ');
+    } else {
+      this.headers[name] = String(value);
+    }
+  }
+  set(name, value) {
+    // Chainable version, compatible with Express res.set
+    this.setHeader(name, value);
+    return this;
+  }
+  cookie(name, value, options) {
+    /**
+     * Set Cookie (similar to HTTP Set-Cookie)
+     * Generate Set-Cookie string and add to headers[HttpHeader.SET_COOKIE] array
+     * Client will parse and save to cookie storage upon receiving
+     */
+    var setCookieStr = createSetCookie(name, value, {
+      path: options === null || options === void 0 ? void 0 : options.path,
+      expires: options === null || options === void 0 ? void 0 : options.expires,
+      maxAge: options === null || options === void 0 ? void 0 : options.maxAge,
+      httpOnly: options === null || options === void 0 ? void 0 : options.httpOnly,
+      secure: options === null || options === void 0 ? void 0 : options.secure,
+      sameSite: (options === null || options === void 0 ? void 0 : options.sameSite) === true ? 'Strict' : (options === null || options === void 0 ? void 0 : options.sameSite) === false ? undefined : options === null || options === void 0 ? void 0 : options.sameSite
+    });
+
+    // Add to Set-Cookie header array
+    var existing = this.headers[HttpHeader.SET_COOKIE];
+    if (Array.isArray(existing)) {
+      existing.push(setCookieStr);
+    } else {
+      this.headers[HttpHeader.SET_COOKIE] = [setCookieStr];
+    }
+    return this;
+  }
+  clearCookie(name, options) {
+    /**
+     * Clear specified Cookie
+     * Generate an expired Set-Cookie string, client will delete this cookie upon receiving
+     */
+    var setCookieStr = createClearCookie(name, {
+      path: options === null || options === void 0 ? void 0 : options.path
+    });
+
+    // Add to Set-Cookie header array
+    var existing = this.headers[HttpHeader.SET_COOKIE];
+    if (Array.isArray(existing)) {
+      existing.push(setCookieStr);
+    } else {
+      this.headers[HttpHeader.SET_COOKIE] = [setCookieStr];
+    }
+    return this;
+  }
+}