request-iframe 0.1.1 → 0.2.1

package/esm/stream/writable-stream.js

@@ -13,9 +13,12 @@ import "core-js/modules/es.object.get-own-property-descriptors.js";
 import "core-js/modules/es.regexp.to-string.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 import "core-js/modules/web.dom-collections.iterator.js";
-import { createPostMessage, generateRequestId } from '../utils';
-import { MessageType, Messages, StreamType as StreamTypeConstant, StreamState as StreamStateConstant, StreamMode as StreamModeConstant, MessageRole, formatMessage, DefaultTimeout, StreamInternalMessageType, StreamEvent } from '../constants';
+import { createPostMessage } from '../utils/protocol';
+import { generateRequestId } from '../utils/id';
+import { isFunction } from '../utils/is';
+import { MessageType, Messages, StreamType as StreamTypeConstant, StreamState as StreamStateConstant, StreamMode as StreamModeConstant, MessageRole, formatMessage, DefaultTimeout, StreamInternalMessageType, StreamEvent, ErrorCode } from '../constants';
 import { IframeStreamCore } from './stream-core';
+import { RequestIframeStreamError } from './error';
 
 /**
  * Generate a unique stream ID
@@ -68,14 +71,26 @@ export class IframeWritableStream extends IframeStreamCore {
   enqueue(item) {
     var max = this.maxPendingChunks;
     if (typeof max === 'number' && max > 0 && this.pendingQueue.length >= max) {
-      throw new Error(formatMessage(Messages.STREAM_PENDING_QUEUE_OVERFLOW, max));
+      var _this$context;
+      throw new RequestIframeStreamError({
+        message: formatMessage(Messages.STREAM_PENDING_QUEUE_OVERFLOW, max),
+        code: ErrorCode.STREAM_PENDING_QUEUE_OVERFLOW,
+        streamId: this.streamId,
+        requestId: (_this$context = this.context) === null || _this$context === void 0 ? void 0 : _this$context.requestId
+      });
     }
     var bytes = this.estimateChunkBytes(item.data);
     var maxBytes = this.maxPendingBytes;
     if (typeof maxBytes === 'number' && maxBytes > 0) {
       var next = this.pendingBytes + bytes;
       if (!Number.isFinite(next) || next > maxBytes) {
-        throw new Error(formatMessage(Messages.STREAM_PENDING_BYTES_OVERFLOW, maxBytes));
+        var _this$context2;
+        throw new RequestIframeStreamError({
+          message: formatMessage(Messages.STREAM_PENDING_BYTES_OVERFLOW, maxBytes),
+          code: ErrorCode.STREAM_PENDING_BYTES_OVERFLOW,
+          streamId: this.streamId,
+          requestId: (_this$context2 = this.context) === null || _this$context2 === void 0 ? void 0 : _this$context2.requestId
+        });
       }
     }
     this.pendingQueue.push(_objectSpread(_objectSpread({}, item), {}, {
@@ -143,13 +158,13 @@ export class IframeWritableStream extends IframeStreamCore {
     this.context = context;
   }
   registerControlHandler() {
-    var _this$context;
-    if (!((_this$context = this.context) !== null && _this$context !== void 0 && _this$context.registerStreamHandler)) return;
+    var _this$context3;
+    if (!((_this$context3 = this.context) !== null && _this$context3 !== void 0 && _this$context3.registerStreamHandler)) return;
     this.context.registerStreamHandler(this.streamId, this.handleControlMessage.bind(this));
   }
   unregisterControlHandler() {
-    var _this$context2;
-    if (!((_this$context2 = this.context) !== null && _this$context2 !== void 0 && _this$context2.unregisterStreamHandler)) return;
+    var _this$context4;
+    if (!((_this$context4 = this.context) !== null && _this$context4 !== void 0 && _this$context4.unregisterStreamHandler)) return;
     this.context.unregisterStreamHandler(this.streamId);
   }
   handleControlMessage(data) {
@@ -188,11 +203,11 @@ export class IframeWritableStream extends IframeStreamCore {
   performHeartbeat() {
     var _this = this;
     return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var _this$context3;
+      var _this$context5;
       return _regeneratorRuntime.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            if ((_this$context3 = _this.context) !== null && _this$context3 !== void 0 && _this$context3.heartbeat) {
+            if ((_this$context5 = _this.context) !== null && _this$context5 !== void 0 && _this$context5.heartbeat) {
               _context.next = 1;
               break;
             }
@@ -268,7 +283,11 @@ export class IframeWritableStream extends IframeStreamCore {
   sendMessage(type, data) {
     var _this$context$serverI;
     if (!this.context) {
-      throw new Error(Messages.STREAM_NOT_BOUND);
+      throw new RequestIframeStreamError({
+        message: Messages.STREAM_NOT_BOUND,
+        code: ErrorCode.STREAM_NOT_BOUND,
+        streamId: this.streamId
+      });
     }
     var isClientStream = this.context.clientId !== undefined && this.context.serverId === undefined;
     var role = isClientStream ? MessageRole.CLIENT : MessageRole.SERVER;
@@ -288,7 +307,12 @@ export class IframeWritableStream extends IframeStreamCore {
       this.clearExpireTimer();
       // For most stream messages, if we cannot send, treat as a hard cancellation signal
       // so callers can stop further processing immediately.
-      throw new Error(formatMessage(Messages.STREAM_CANCELLED, 'Target window closed'));
+      throw new RequestIframeStreamError({
+        message: formatMessage(Messages.STREAM_CANCELLED, Messages.TARGET_WINDOW_CLOSED),
+        code: ErrorCode.TARGET_WINDOW_CLOSED,
+        streamId: this.streamId,
+        requestId: this.context.requestId
+      });
     }
     return true;
   }
@@ -296,13 +320,13 @@ export class IframeWritableStream extends IframeStreamCore {
     if (this.ackReceiverRegistered) return;
     if (!this.context) return;
     var ch = this.context.channel;
-    if (typeof ch.addReceiver !== 'function' || typeof ch.removeReceiver !== 'function') return;
+    if (!isFunction(ch.addReceiver) || !isFunction(ch.removeReceiver)) return;
     this.ackReceiver = (data, context) => {
       if (!data || data.type !== MessageType.ACK) return;
       var pending = this.ackWaiters.get(data.requestId);
       if (!pending) return;
       if (context && !context.handledBy) {
-        context.handledBy = `stream:${this.streamId}`;
+        context.markHandledBy(`stream:${this.streamId}`);
       }
       clearTimeout(pending.timeoutId);
       this.ackWaiters.delete(data.requestId);
@@ -319,7 +343,7 @@ export class IframeWritableStream extends IframeStreamCore {
     this.ackWaiters.clear();
     if (this.ackReceiverRegistered && this.ackReceiver && this.context) {
       var ch = this.context.channel;
-      if (typeof ch.removeReceiver === 'function') {
+      if (isFunction(ch.removeReceiver)) {
         try {
           ch.removeReceiver(this.ackReceiver);
         } catch (_unused6) {
@@ -377,13 +401,22 @@ export class IframeWritableStream extends IframeStreamCore {
               _context3.next = 1;
               break;
             }
-            throw new Error(Messages.STREAM_NOT_BOUND);
+            throw new RequestIframeStreamError({
+              message: Messages.STREAM_NOT_BOUND,
+              code: ErrorCode.STREAM_NOT_BOUND,
+              streamId: _this3.streamId
+            });
           case 1:
             if (!(_this3._state !== StreamStateConstant.PENDING)) {
               _context3.next = 2;
               break;
             }
-            throw new Error(Messages.STREAM_ALREADY_STARTED);
+            throw new RequestIframeStreamError({
+              message: Messages.STREAM_ALREADY_STARTED,
+              code: ErrorCode.STREAM_ALREADY_STARTED,
+              streamId: _this3.streamId,
+              requestId: _this3.context.requestId
+            });
           case 2:
             _this3.completionPromise = new Promise((resolve, reject) => {
               _this3.resolveCompletion = resolve;
@@ -456,16 +489,34 @@ export class IframeWritableStream extends IframeStreamCore {
   write(data, doneOrOptions = false, options) {
     var _opts$ackTimeout;
     if (this.mode !== StreamModeConstant.PUSH) {
-      throw new Error(Messages.STREAM_WRITE_ONLY_IN_PUSH_MODE);
+      var _this$context6;
+      throw new RequestIframeStreamError({
+        message: Messages.STREAM_WRITE_ONLY_IN_PUSH_MODE,
+        code: ErrorCode.STREAM_WRITE_ONLY_IN_PUSH_MODE,
+        streamId: this.streamId,
+        requestId: (_this$context6 = this.context) === null || _this$context6 === void 0 ? void 0 : _this$context6.requestId
+      });
     }
     if (this._state === StreamStateConstant.PENDING) {
+      var _this$context7;
       /**
        * In push mode, users must call start() first so STREAM_START is sent and binding is complete.
        */
-      throw new Error(Messages.STREAM_NOT_BOUND);
+      throw new RequestIframeStreamError({
+        message: Messages.STREAM_NOT_BOUND,
+        code: ErrorCode.STREAM_NOT_BOUND,
+        streamId: this.streamId,
+        requestId: (_this$context7 = this.context) === null || _this$context7 === void 0 ? void 0 : _this$context7.requestId
+      });
     }
     if (this._state !== StreamStateConstant.STREAMING) {
-      throw new Error(Messages.STREAM_ENDED);
+      var _this$context8;
+      throw new RequestIframeStreamError({
+        message: Messages.STREAM_ENDED,
+        code: ErrorCode.STREAM_ENDED,
+        streamId: this.streamId,
+        requestId: (_this$context8 = this.context) === null || _this$context8 === void 0 ? void 0 : _this$context8.requestId
+      });
     }
     var done = typeof doneOrOptions === 'boolean' ? doneOrOptions : false;
     var opts = typeof doneOrOptions === 'object' ? doneOrOptions : options;
@@ -652,7 +703,11 @@ export class IframeWritableStream extends IframeStreamCore {
   sendData(data, done = false, options) {
     var _this$context$serverI2, _options$requestId;
     if (!this.context) {
-      throw new Error(Messages.STREAM_NOT_BOUND);
+      throw new RequestIframeStreamError({
+        message: Messages.STREAM_NOT_BOUND,
+        code: ErrorCode.STREAM_NOT_BOUND,
+        streamId: this.streamId
+      });
     }
     var seq = this.seq++;
     var isClientStream = this.context.clientId !== undefined && this.context.serverId === undefined;
@@ -684,7 +739,12 @@ export class IframeWritableStream extends IframeStreamCore {
     if (!ok) {
       this._state = StreamStateConstant.CANCELLED;
       this.clearExpireTimer();
-      throw new Error(formatMessage(Messages.STREAM_CANCELLED, 'Target window closed'));
+      throw new RequestIframeStreamError({
+        message: formatMessage(Messages.STREAM_CANCELLED, Messages.TARGET_WINDOW_CLOSED),
+        code: ErrorCode.TARGET_WINDOW_CLOSED,
+        streamId: this.streamId,
+        requestId: this.context.requestId
+      });
     }
     this.emit(StreamEvent.SEND, {
       seq,
@@ -720,7 +780,7 @@ export class IframeWritableStream extends IframeStreamCore {
           this.sendData(item.data, item.done);
         }
       } catch (e) {
-        var _this$rejectCompletio;
+        var _this$rejectCompletio, _this$context9;
         // send failure treated as cancellation
         this._state = StreamStateConstant.CANCELLED;
         this.clearExpireTimer();
@@ -729,7 +789,13 @@ export class IframeWritableStream extends IframeStreamCore {
         this.pendingQueue.length = 0;
         this.pendingBytes = 0;
         this.cleanupAckWaiters();
-        (_this$rejectCompletio = this.rejectCompletion) === null || _this$rejectCompletio === void 0 || _this$rejectCompletio.call(this, e instanceof Error ? e : new Error(String(e)));
+        (_this$rejectCompletio = this.rejectCompletion) === null || _this$rejectCompletio === void 0 || _this$rejectCompletio.call(this, e instanceof Error ? e : new RequestIframeStreamError({
+          message: String(e),
+          code: ErrorCode.STREAM_ERROR,
+          streamId: this.streamId,
+          requestId: (_this$context9 = this.context) === null || _this$context9 === void 0 ? void 0 : _this$context9.requestId,
+          cause: e
+        }));
         throw e;
       }
       if (item.done) {
@@ -772,7 +838,7 @@ export class IframeWritableStream extends IframeStreamCore {
    * Send error
    */
   error(message) {
-    var _this$resolveCompleti2;
+    var _this$context0, _this$resolveCompleti2;
     if (this._state !== StreamStateConstant.STREAMING) return;
     this._state = StreamStateConstant.ERROR;
     this.clearExpireTimer();
@@ -784,7 +850,12 @@ export class IframeWritableStream extends IframeStreamCore {
       error: message
     });
     this.emit(StreamEvent.ERROR, {
-      error: new Error(message)
+      error: new RequestIframeStreamError({
+        message,
+        code: ErrorCode.STREAM_ERROR,
+        streamId: this.streamId,
+        requestId: (_this$context0 = this.context) === null || _this$context0 === void 0 ? void 0 : _this$context0.requestId
+      })
     });
     this.emit(StreamEvent.STATE, {
       state: this._state

package/esm/utils/blob.js

@@ -0,0 +1,16 @@
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.string.includes.js";
+/** Convert Blob to base64 string */
+export function blobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    var reader = new FileReader();
+    reader.onloadend = () => {
+      var result = reader.result;
+      var base64 = result.includes(',') ? result.split(',')[1] : result;
+      resolve(base64);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}

package/esm/utils/cache.js

@@ -1,85 +1,15 @@
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.map.js";
+import "core-js/modules/es.string.ends-with.js";
+import "core-js/modules/es.string.starts-with.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 import "core-js/modules/web.dom-collections.iterator.js";
-import { MessageChannel, ChannelType } from '../message';
-/**
- * Global cache Symbol (used to store MessageChannel instance cache on window)
- * Using Symbol.for() ensures multiple library copies share the same cache, avoiding multiple instance creation
- */
-var MESSAGE_CHANNEL_CACHE_SYMBOL = Symbol.for('__requestIframeMessageChannelCache__');
-
 /**
  * Global cache Symbol for server instances
  * Using Symbol.for() ensures multiple library copies share the same cache
  */
 var SERVER_CACHE_SYMBOL = Symbol.for('__requestIframeServerCache__');
 
-/**
- * Get the MessageChannel cache from window
- */
-function getChannelCacheForWindow(win) {
-  if (!(MESSAGE_CHANNEL_CACHE_SYMBOL in win)) {
-    win[MESSAGE_CHANNEL_CACHE_SYMBOL] = new Map();
-  }
-  return win[MESSAGE_CHANNEL_CACHE_SYMBOL];
-}
-
-/**
- * Generate cache key
- * Cache key format: "type:secretKey" or "type:" when no secretKey
- * Different channel types use separate cache entries
- */
-function getCacheKey(type, secretKey) {
-  return `${type}:${secretKey !== null && secretKey !== void 0 ? secretKey : ''}`;
-}
-
-/**
- * Get or create MessageChannel instance
- * - Within the same window, only one channel is created per type + secretKey combination
- * - Uses reference counting to manage lifecycle
- * @param secretKey secret key for message isolation
- * @param type channel type (defaults to postMessage)
- */
-export function getOrCreateMessageChannel(secretKey, type = ChannelType.POST_MESSAGE) {
-  var cache = getChannelCacheForWindow(window);
-  var key = getCacheKey(type, secretKey);
-  var channel = cache.get(key);
-  if (!channel) {
-    channel = new MessageChannel(secretKey, type);
-    cache.set(key, channel);
-  }
-  channel.addRef();
-  return channel;
-}
-
-/**
- * Release MessageChannel reference
- * - When reference count reaches 0, destroy channel and remove from cache
- */
-export function releaseMessageChannel(channel) {
-  var refCount = channel.release();
-  if (refCount <= 0) {
-    var cache = getChannelCacheForWindow(window);
-    var key = getCacheKey(channel.type, channel.secretKey);
-    if (cache.get(key) === channel) {
-      cache.delete(key);
-      channel.destroy();
-    }
-  }
-}
-
-/**
- * Clear all MessageChannel cache (mainly for testing)
- */
-export function clearMessageChannelCache() {
-  var cache = getChannelCacheForWindow(window);
-  cache.forEach(channel => {
-    channel.destroy();
-  });
-  cache.clear();
-}
-
 /**
  * Get the server cache from window
  */
@@ -136,12 +66,31 @@ export function removeCachedServer(secretKey, id) {
 }
 
 /**
- * Clear all server cache (mainly for testing)
+ * Clear server cache (mainly for testing).
+ *
+ * - No args: clear all cached servers
+ * - With secretKey: only clear servers under that secretKey
+ * - With { secretKey, id }: only clear the specified server instance
+ * - With { id }: clear the specified id across all secretKeys
  */
-export function clearServerCache() {
+export function clearServerCache(arg) {
   var cache = getServerCacheForWindow(window);
-  cache.forEach(server => {
+  if (!arg) {
+    cache.forEach(server => {
+      server.destroy();
+    });
+    cache.clear();
+    return;
+  }
+  var params = typeof arg === 'string' ? {
+    secretKey: arg
+  } : arg;
+  var prefix = typeof params.secretKey === 'string' ? `${params.secretKey}:` : undefined;
+  var suffix = typeof params.id === 'string' ? `:${params.id}` : undefined;
+  cache.forEach((server, key) => {
+    if (prefix && !key.startsWith(prefix)) return;
+    if (suffix && !key.endsWith(suffix)) return;
+    cache.delete(key);
     server.destroy();
   });
-  cache.clear();
 }

package/esm/utils/content-type.js

@@ -0,0 +1,81 @@
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/web.url-search-params.js";
+/**
+ * Detect Content-Type based on data type
+ * @param data The data to detect Content-Type for
+ * @param options Options for detection
+ * @param options.checkStream Whether to check for IframeWritableStream (default: false)
+ * @param options.isIframeWritableStream Optional function to check if data is a stream (required if checkStream is true)
+ * @returns The detected Content-Type, or null if Content-Type should not be auto-set
+ */
+export function detectContentType(data, options) {
+  if (data === null || data === undefined) return null;
+  var _ref = options || {},
+    _ref$checkStream = _ref.checkStream,
+    checkStream = _ref$checkStream === void 0 ? false : _ref$checkStream,
+    isIframeWritableStream = _ref.isIframeWritableStream;
+
+  /** Stream - handled separately (only for response) */
+  if (checkStream && isIframeWritableStream) {
+    if (isIframeWritableStream(data)) {
+      return null; /** Stream will be handled by sendStream */
+    }
+  }
+
+  /** File */
+  if (typeof File !== 'undefined' && data instanceof File) {
+    return data.type || 'application/octet-stream';
+  }
+
+  /** Blob */
+  if (typeof Blob !== 'undefined' && data instanceof Blob) {
+    return data.type || 'application/octet-stream';
+  }
+
+  /** ArrayBuffer */
+  if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer) {
+    return 'application/octet-stream';
+  }
+
+  /** FormData */
+  if (typeof FormData !== 'undefined' && data instanceof FormData) {
+    /** FormData typically doesn't need Content-Type header (browser sets it with boundary) */
+    return null;
+  }
+
+  /** URLSearchParams */
+  if (typeof URLSearchParams !== 'undefined' && data instanceof URLSearchParams) {
+    return 'application/x-www-form-urlencoded';
+  }
+
+  /** String - check if it's JSON string */
+  if (typeof data === 'string') {
+    /** Try to parse as JSON, if successful, treat as JSON */
+    try {
+      JSON.parse(data);
+      return 'application/json';
+    } catch (_unused) {
+      return 'text/plain; charset=utf-8';
+    }
+  }
+
+  /** Number, boolean - treat as JSON */
+  if (typeof data === 'number' || typeof data === 'boolean') {
+    return 'application/json';
+  }
+
+  /** Plain object or array - treat as JSON */
+  if (typeof data === 'object') {
+    /**
+     * Exclude common binary/file types (already checked above, but double-check for safety)
+     */
+    if (typeof Blob !== 'undefined' && data instanceof Blob) return null;
+    if (typeof File !== 'undefined' && data instanceof File) return null;
+    if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer) return null;
+    if (typeof FormData !== 'undefined' && data instanceof FormData) return null;
+    if (typeof URLSearchParams !== 'undefined' && data instanceof URLSearchParams) return null;
+    return 'application/json';
+  }
+  return null;
+}