request-iframe 0.1.0 → 0.2.0

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;
+}