request-iframe 0.0.5 → 0.1.0

package/esm/utils/cache.js

@@ -0,0 +1,147 @@
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.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
+ */
+function getServerCacheForWindow(win) {
+  if (!(SERVER_CACHE_SYMBOL in win)) {
+    win[SERVER_CACHE_SYMBOL] = new Map();
+  }
+  return win[SERVER_CACHE_SYMBOL];
+}
+
+/**
+ * Generate server cache key
+ * Cache key format: "secretKey:id" or "secretKey:" when no id
+ */
+function getServerCacheKey(secretKey, id) {
+  return `${secretKey !== null && secretKey !== void 0 ? secretKey : ''}:${id !== null && id !== void 0 ? id : ''}`;
+}
+
+/**
+ * Get cached server instance or null
+ * @param secretKey secret key for message isolation
+ * @param id server instance ID
+ */
+export function getCachedServer(secretKey, id) {
+  if (!id) return null;
+  var cache = getServerCacheForWindow(window);
+  var key = getServerCacheKey(secretKey, id);
+  return cache.get(key) || null;
+}
+
+/**
+ * Cache server instance
+ * @param server server instance
+ * @param secretKey secret key for message isolation
+ * @param id server instance ID
+ */
+export function cacheServer(server, secretKey, id) {
+  if (!id) return;
+  var cache = getServerCacheForWindow(window);
+  var key = getServerCacheKey(secretKey, id);
+  cache.set(key, server);
+}
+
+/**
+ * Remove server from cache
+ * @param secretKey secret key for message isolation
+ * @param id server instance ID
+ */
+export function removeCachedServer(secretKey, id) {
+  if (!id) return;
+  var cache = getServerCacheForWindow(window);
+  var key = getServerCacheKey(secretKey, id);
+  cache.delete(key);
+}
+
+/**
+ * Clear all server cache (mainly for testing)
+ */
+export function clearServerCache() {
+  var cache = getServerCacheForWindow(window);
+  cache.forEach(server => {
+    server.destroy();
+  });
+  cache.clear();
+}

package/esm/utils/cookie.js

@@ -0,0 +1,352 @@
+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; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.slice.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.regexp.to-string.js";
+import "core-js/modules/es.string.ends-with.js";
+import "core-js/modules/es.string.starts-with.js";
+import "core-js/modules/es.string.trim.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+/**
+ * Cookie management utilities
+ * Implements browser-like Cookie mechanism
+ */
+
+/**
+ * Cookie storage item
+ */
+
+/**
+ * Cookie options (for res.cookie)
+ */
+
+/**
+ * Parse Set-Cookie string to CookieItem
+ * @param setCookieStr Set-Cookie string, e.g., "token=abc; Path=/; HttpOnly"
+ */
+export function parseSetCookie(setCookieStr) {
+  if (!setCookieStr) return null;
+  var parts = setCookieStr.split(';').map(p => p.trim());
+  if (parts.length === 0) return null;
+
+  // First part is name=value
+  var firstPart = parts[0];
+  var eqIndex = firstPart.indexOf('=');
+  if (eqIndex === -1) return null;
+  var name = firstPart.substring(0, eqIndex).trim();
+  var value = firstPart.substring(eqIndex + 1).trim();
+  if (!name) return null;
+  var cookie = {
+    name,
+    value,
+    path: '/' // Default path
+  };
+
+  // Parse other attributes
+  for (var i = 1; i < parts.length; i++) {
+    var part = parts[i];
+    var attrEqIndex = part.indexOf('=');
+    if (attrEqIndex === -1) {
+      // Attribute without value
+      var attrName = part.toLowerCase();
+      if (attrName === 'httponly') {
+        cookie.httpOnly = true;
+      } else if (attrName === 'secure') {
+        cookie.secure = true;
+      }
+    } else {
+      // Attribute with value
+      var _attrName = part.substring(0, attrEqIndex).trim().toLowerCase();
+      var attrValue = part.substring(attrEqIndex + 1).trim();
+      if (_attrName === 'path') {
+        cookie.path = attrValue || '/';
+      } else if (_attrName === 'expires') {
+        var date = new Date(attrValue);
+        if (!isNaN(date.getTime())) {
+          cookie.expires = date.getTime();
+        }
+      } else if (_attrName === 'max-age') {
+        var maxAge = parseInt(attrValue, 10);
+        if (!isNaN(maxAge)) {
+          cookie.expires = Date.now() + maxAge * 1000;
+        }
+      } else if (_attrName === 'samesite') {
+        var sameSite = attrValue.charAt(0).toUpperCase() + attrValue.slice(1).toLowerCase();
+        if (sameSite === 'Strict' || sameSite === 'Lax' || sameSite === 'None') {
+          cookie.sameSite = sameSite;
+        }
+      }
+    }
+  }
+  return cookie;
+}
+
+/**
+ * Serialize CookieItem to Set-Cookie string
+ */
+export function serializeSetCookie(cookie) {
+  var str = `${cookie.name}=${cookie.value}`;
+  if (cookie.path) {
+    str += `; Path=${cookie.path}`;
+  }
+  if (cookie.expires !== undefined) {
+    str += `; Expires=${new Date(cookie.expires).toUTCString()}`;
+  }
+  if (cookie.httpOnly) {
+    str += '; HttpOnly';
+  }
+  if (cookie.secure) {
+    str += '; Secure';
+  }
+  if (cookie.sameSite) {
+    str += `; SameSite=${cookie.sameSite}`;
+  }
+  return str;
+}
+
+/**
+ * Create Set-Cookie string from CookieOptions
+ */
+export function createSetCookie(name, value, options) {
+  var _options$path;
+  var str = `${name}=${value}`;
+  var path = (_options$path = options === null || options === void 0 ? void 0 : options.path) !== null && _options$path !== void 0 ? _options$path : '/';
+  str += `; Path=${path}`;
+  if (options !== null && options !== void 0 && options.expires) {
+    str += `; Expires=${options.expires.toUTCString()}`;
+  } else if ((options === null || options === void 0 ? void 0 : options.maxAge) !== undefined) {
+    var expires = new Date(Date.now() + options.maxAge * 1000);
+    str += `; Expires=${expires.toUTCString()}`;
+    str += `; Max-Age=${options.maxAge}`;
+  }
+  if (options !== null && options !== void 0 && options.httpOnly) {
+    str += '; HttpOnly';
+  }
+  if (options !== null && options !== void 0 && options.secure) {
+    str += '; Secure';
+  }
+  if (options !== null && options !== void 0 && options.sameSite) {
+    str += `; SameSite=${options.sameSite}`;
+  }
+  return str;
+}
+
+/**
+ * Create Set-Cookie string to delete Cookie
+ */
+export function createClearCookie(name, options) {
+  var _options$path2;
+  var path = (_options$path2 = options === null || options === void 0 ? void 0 : options.path) !== null && _options$path2 !== void 0 ? _options$path2 : '/';
+  // Set expiration time to past to delete cookie
+  return `${name}=; Path=${path}; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0`;
+}
+
+/**
+ * Check if request path matches Cookie's path attribute
+ * Implements RFC 6265 path matching algorithm
+ * @param requestPath request path, e.g., "/api/users"
+ * @param cookiePath Cookie's path attribute, e.g., "/api"
+ */
+export function matchCookiePath(requestPath, cookiePath) {
+  // Normalize paths
+  var reqPath = normalizePath(requestPath);
+  var cPath = normalizePath(cookiePath);
+
+  // Exact match
+  if (reqPath === cPath) {
+    return true;
+  }
+
+  // Cookie path is prefix of request path
+  if (reqPath.startsWith(cPath)) {
+    // Cookie path ends with / or request path has / after cookie path
+    if (cPath.endsWith('/') || reqPath.charAt(cPath.length) === '/') {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Normalize path
+ */
+function normalizePath(path) {
+  if (!path || path === '') return '/';
+  // Ensure starts with /
+  if (!path.startsWith('/')) {
+    path = '/' + path;
+  }
+  // Remove trailing / (unless root path)
+  if (path.length > 1 && path.endsWith('/')) {
+    path = path.slice(0, -1);
+  }
+  return path;
+}
+
+/**
+ * Cookie storage manager
+ */
+export class CookieStore {
+  constructor() {
+    _defineProperty(this, "cookies", new Map());
+  }
+  /**
+   * Generate unique key for Cookie
+   */
+  getKey(name, path) {
+    return `${name}|${path}`;
+  }
+
+  /**
+   * Set Cookie
+   */
+  set(cookie) {
+    var key = this.getKey(cookie.name, cookie.path);
+    this.cookies.set(key, cookie);
+  }
+
+  /**
+   * Set Cookie from Set-Cookie string
+   */
+  setFromSetCookie(setCookieStr) {
+    var cookie = parseSetCookie(setCookieStr);
+    if (cookie) {
+      // Check if this is a delete operation (expiration in the past)
+      if (cookie.expires !== undefined && cookie.expires <= Date.now()) {
+        this.remove(cookie.name, cookie.path);
+      } else {
+        this.set(cookie);
+      }
+    }
+  }
+
+  /**
+   * Remove Cookie
+   */
+  remove(name, path = '/') {
+    var key = this.getKey(name, path);
+    this.cookies.delete(key);
+  }
+
+  /**
+   * Get all Cookies matching specified path
+   * @param requestPath request path
+   * @returns matching cookies, format: Record<string, string>
+   */
+  getForPath(requestPath) {
+    var result = {};
+    var now = Date.now();
+    this.cookies.forEach(cookie => {
+      // Check if expired
+      if (cookie.expires !== undefined && cookie.expires <= now) {
+        return;
+      }
+
+      // Check if path matches
+      if (matchCookiePath(requestPath, cookie.path)) {
+        // If same-name cookie already exists, use the one with longer (more specific) path
+        if (result[cookie.name] === undefined) {
+          result[cookie.name] = cookie.value;
+        }
+      }
+    });
+    return result;
+  }
+
+  /**
+   * Get Cookie value by name
+   * @param name Cookie name
+   * @param path path (optional, returns first match if not specified)
+   */
+  get(name, path) {
+    if (path) {
+      var key = this.getKey(name, path);
+      var cookie = this.cookies.get(key);
+      if (cookie && (!cookie.expires || cookie.expires > Date.now())) {
+        return cookie.value;
+      }
+      return undefined;
+    }
+
+    // If path not specified, find all cookies with same name
+    var _iterator = _createForOfIteratorHelper(this.cookies.values()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _cookie = _step.value;
+        if (_cookie.name === name) {
+          if (!_cookie.expires || _cookie.expires > Date.now()) {
+            return _cookie.value;
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return undefined;
+  }
+
+  /**
+   * Get all Cookies (with full info)
+   */
+  getAll() {
+    var now = Date.now();
+    var result = [];
+    this.cookies.forEach(cookie => {
+      if (!cookie.expires || cookie.expires > now) {
+        result.push(_objectSpread({}, cookie));
+      }
+    });
+    return result;
+  }
+
+  /**
+   * Get all Cookies (simple format)
+   */
+  getAllSimple() {
+    var result = {};
+    var now = Date.now();
+    this.cookies.forEach(cookie => {
+      if (!cookie.expires || cookie.expires > now) {
+        result[cookie.name] = cookie.value;
+      }
+    });
+    return result;
+  }
+
+  /**
+   * Clear all Cookies
+   */
+  clear() {
+    this.cookies.clear();
+  }
+
+  /**
+   * Cleanup expired Cookies
+   */
+  cleanup() {
+    var now = Date.now();
+    var keysToDelete = [];
+    this.cookies.forEach((cookie, key) => {
+      if (cookie.expires !== undefined && cookie.expires <= now) {
+        keysToDelete.push(key);
+      }
+    });
+    keysToDelete.forEach(key => this.cookies.delete(key));
+  }
+}