request-iframe 0.0.5 → 0.1.0

package/esm/message/index.js

@@ -0,0 +1,2 @@
+export { MessageChannel, ChannelType } from './channel';
+export { MessageDispatcher } from './dispatcher';

package/esm/stream/file-stream.js

@@ -0,0 +1,289 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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; }
+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.symbol.description.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.reduce.js";
+import "core-js/modules/es.array.slice.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.regexp.exec.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.typed-array.uint8-array.js";
+import "core-js/modules/es.typed-array.fill.js";
+import "core-js/modules/es.typed-array.iterator.js";
+import "core-js/modules/es.typed-array.set.js";
+import "core-js/modules/es.typed-array.sort.js";
+import "core-js/modules/es.typed-array.to-string.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { IframeWritableStream } from './writable-stream';
+import { IframeReadableStream } from './readable-stream';
+import { StreamType as StreamTypeConstant } from '../constants';
+
+/**
+ * Convert Uint8Array to Base64 string
+ */
+function uint8ArrayToBase64(uint8Array) {
+  /**
+   * Avoid O(n^2) string concatenation for large buffers.
+   * Note: btoa still needs a single binary string, so this mainly improves conversion cost.
+   */
+  var chunkSize = 0x8000; // 32KB per chunk (safe for fromCharCode/apply limits)
+  var parts = [];
+  for (var i = 0; i < uint8Array.length; i += chunkSize) {
+    var chunk = uint8Array.subarray(i, i + chunkSize);
+    parts.push(String.fromCharCode.apply(null, chunk));
+  }
+  return btoa(parts.join(''));
+}
+
+/**
+ * Convert Base64 string to Uint8Array
+ */
+function base64ToUint8Array(base64) {
+  var binary = atob(base64);
+  var uint8Array = new Uint8Array(binary.length);
+  for (var i = 0; i < binary.length; i++) {
+    uint8Array[i] = binary.charCodeAt(i);
+  }
+  return uint8Array;
+}
+
+/**
+ * IframeFileWritableStream - Server-side file writable stream
+ * Automatically handles Base64 encoding of file content
+ */
+export class IframeFileWritableStream extends IframeWritableStream {
+  constructor(options) {
+    super(_objectSpread(_objectSpread({}, options), {}, {
+      type: StreamTypeConstant.FILE,
+      metadata: _objectSpread(_objectSpread({}, options.metadata), {}, {
+        filename: options.filename,
+        mimeType: options.mimeType || 'application/octet-stream',
+        size: options.size
+      })
+    }));
+    this.filename = options.filename;
+    this.mimeType = options.mimeType || 'application/octet-stream';
+    this.size = options.size;
+  }
+
+  /**
+   * Override encode method to convert Uint8Array to Base64
+   */
+  encodeData(data) {
+    if (data instanceof Uint8Array) {
+      return uint8ArrayToBase64(data);
+    }
+    if (data instanceof ArrayBuffer) {
+      return uint8ArrayToBase64(new Uint8Array(data));
+    }
+    if (typeof data === 'string') {
+      // Already a base64 string
+      return data;
+    }
+    // Try to convert other types
+    return String(data);
+  }
+}
+
+/**
+ * IframeFileReadableStream - Client-side file readable stream
+ * Automatically handles Base64 decoding of file content
+ */
+export class IframeFileReadableStream extends IframeReadableStream {
+  constructor(streamId, requestId, messageHandler, options = {}) {
+    var _options$metadata, _options$metadata2, _options$metadata3;
+    super(streamId, requestId, messageHandler, _objectSpread(_objectSpread({}, options), {}, {
+      type: StreamTypeConstant.FILE
+    }));
+    this.filename = options.filename || ((_options$metadata = options.metadata) === null || _options$metadata === void 0 ? void 0 : _options$metadata.filename);
+    this.mimeType = options.mimeType || ((_options$metadata2 = options.metadata) === null || _options$metadata2 === void 0 ? void 0 : _options$metadata2.mimeType);
+    this.size = options.size || ((_options$metadata3 = options.metadata) === null || _options$metadata3 === void 0 ? void 0 : _options$metadata3.size);
+  }
+
+  /**
+   * Override decode method to convert Base64 to Uint8Array
+   */
+  decodeData(data) {
+    if (typeof data === 'string') {
+      return base64ToUint8Array(data);
+    }
+    if (data instanceof Uint8Array) {
+      return data;
+    }
+    if (data instanceof ArrayBuffer) {
+      return new Uint8Array(data);
+    }
+    return new Uint8Array();
+  }
+
+  /**
+   * Override merge method to merge all Uint8Array chunks
+   */
+  mergeChunks() {
+    var chunks = this.chunks;
+    if (chunks.length === 0) {
+      return new Uint8Array();
+    }
+    if (chunks.length === 1) {
+      return chunks[0];
+    }
+
+    // Calculate total length
+    var totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    var result = new Uint8Array(totalLength);
+
+    // Merge all chunks
+    var offset = 0;
+    var _iterator = _createForOfIteratorHelper(chunks),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var chunk = _step.value;
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result;
+  }
+
+  /**
+   * Read all data as a merged Uint8Array (file stream default behavior)
+   */
+  read() {
+    var _superprop_getRead = () => super.read,
+      _this = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 1;
+            return _superprop_getRead().call(_this);
+          case 1:
+            return _context.abrupt("return", _context.sent);
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
+
+  /**
+   * Read as Blob
+   */
+  readAsBlob() {
+    var _this2 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var data, buffer;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 1;
+            return _this2.read();
+          case 1:
+            data = _context2.sent;
+            // Use slice to create a pure ArrayBuffer copy to avoid type issues
+            buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            return _context2.abrupt("return", new Blob([buffer], {
+              type: _this2.mimeType || 'application/octet-stream'
+            }));
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  }
+
+  /**
+   * Read as File
+   * @param fileName Optional file name (if not provided, uses stream's filename)
+   */
+  readAsFile(fileName) {
+    var _this3 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var data, buffer, name;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 1;
+            return _this3.read();
+          case 1:
+            data = _context3.sent;
+            // Use slice to create a pure ArrayBuffer copy to avoid type issues
+            buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            name = fileName || _this3.filename || 'file';
+            return _context3.abrupt("return", new File([buffer], name, {
+              type: _this3.mimeType || 'application/octet-stream'
+            }));
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  }
+
+  /**
+   * Read as ArrayBuffer
+   */
+  readAsArrayBuffer() {
+    var _this4 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      var data, buffer;
+      return _regeneratorRuntime.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 1;
+            return _this4.read();
+          case 1:
+            data = _context4.sent;
+            // Create a new ArrayBuffer copy
+            buffer = new ArrayBuffer(data.byteLength);
+            new Uint8Array(buffer).set(data);
+            return _context4.abrupt("return", buffer);
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  }
+
+  /**
+   * Read as Data URL
+   */
+  readAsDataURL() {
+    var _this5 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+      var data, base64;
+      return _regeneratorRuntime.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.next = 1;
+            return _this5.read();
+          case 1:
+            data = _context5.sent;
+            base64 = uint8ArrayToBase64(data);
+            return _context5.abrupt("return", `data:${_this5.mimeType || 'application/octet-stream'};base64,${base64}`);
+          case 2:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }))();
+  }
+}

package/esm/stream/index.js

@@ -0,0 +1,44 @@
+// Type exports
+export * from './types';
+
+// Duplex core is internal and not exported publicly.
+
+// Writable stream (server-side)
+export { IframeWritableStream } from './writable-stream';
+export { IframeFileWritableStream } from './file-stream';
+
+// Readable stream (client-side)
+export { IframeReadableStream, StreamMessageHandler } from './readable-stream';
+export { IframeFileReadableStream } from './file-stream';
+
+// Type checking utility functions
+import { IframeReadableStream } from './readable-stream';
+import { IframeFileReadableStream, IframeFileWritableStream } from './file-stream';
+import { IframeWritableStream } from './writable-stream';
+/**
+ * Check if value is an IframeReadableStream
+ */
+export function isIframeReadableStream(value) {
+  return value instanceof IframeReadableStream;
+}
+
+/**
+ * Check if value is an IframeFileReadableStream (file stream)
+ */
+export function isIframeFileReadableStream(value) {
+  return value instanceof IframeFileReadableStream;
+}
+
+/**
+ * Check if value is an IframeWritableStream (includes IframeFileWritableStream)
+ */
+export function isIframeWritableStream(value) {
+  return value instanceof IframeWritableStream || value instanceof IframeFileWritableStream;
+}
+
+/**
+ * Check if value is an IframeFileWritableStream (file writable stream)
+ */
+export function isIframeFileWritableStream(value) {
+  return value instanceof IframeFileWritableStream;
+}