request-iframe 0.0.1

package/library/stream/readable-stream.d.ts

@@ -0,0 +1,83 @@
+import { StreamType, StreamState, ReadableStreamOptions, IIframeReadableStream, StreamMessageData } from './types';
+/**
+ * Stream message handler interface
+ */
+export interface StreamMessageHandler {
+    /** Register stream message handler */
+    registerStreamHandler(streamId: string, handler: (data: StreamMessageData) => void): void;
+    /** Unregister handler */
+    unregisterStreamHandler(streamId: string): void;
+    /** Post message */
+    postMessage(message: any): void;
+}
+/**
+ * IframeReadableStream - Client-side readable stream
+ * Used to receive stream data sent from the server
+ */
+export declare class IframeReadableStream<T = any> implements IIframeReadableStream<T> {
+    readonly streamId: string;
+    readonly type: StreamType;
+    readonly chunked: boolean;
+    readonly metadata?: Record<string, any>;
+    private _state;
+    private readonly chunks;
+    private resolveRead?;
+    private rejectRead?;
+    private onEndCallback?;
+    private onErrorCallback?;
+    private readonly messageHandler;
+    private readonly requestId;
+    private readonly secretKey?;
+    constructor(streamId: string, requestId: string, messageHandler: StreamMessageHandler, options?: ReadableStreamOptions);
+    /** Get stream state */
+    get state(): StreamState;
+    /**
+     * Handle stream message
+     */
+    private handleStreamMessage;
+    /**
+     * Handle data chunk (internal method)
+     */
+    private handleData;
+    /**
+     * Decode data (subclasses can override, e.g., FileStream needs Base64 decoding)
+     */
+    protected decodeData(data: any): T;
+    /**
+     * Stream ended (internal handling)
+     */
+    private handleEnd;
+    /**
+     * Merge data chunks (subclasses can override)
+     */
+    protected mergeChunks(): T;
+    /**
+     * Stream error (internal method)
+     */
+    private handleError;
+    /**
+     * Stream cancelled (internal method)
+     */
+    private handleCancel;
+    /**
+     * Read all data
+     */
+    read(): Promise<T>;
+    /**
+     * Async iterator
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /**
+     * Cancel stream
+     */
+    cancel(reason?: string): void;
+    /**
+     * Listen for stream end
+     */
+    onEnd(callback: () => void): void;
+    /**
+     * Listen for stream error
+     */
+    onError(callback: (error: Error) => void): void;
+}
+//# sourceMappingURL=readable-stream.d.ts.map

package/library/stream/readable-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readable-stream.d.ts","sourceRoot":"","sources":["../../src/stream/readable-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAIjB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,sCAAsC;IACtC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1F,yBAAyB;IACzB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,mBAAmB;IACnB,WAAW,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;CACjC;AAED;;;GAGG;AACH,qBAAa,oBAAoB,CAAC,CAAC,GAAG,GAAG,CAAE,YAAW,qBAAqB,CAAC,CAAC,CAAC;IAC5E,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,UAAU,CAAC;IACjC,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE/C,OAAO,CAAC,MAAM,CAA4C;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,WAAW,CAAC,CAAqB;IACzC,OAAO,CAAC,UAAU,CAAC,CAAyB;IAC5C,OAAO,CAAC,aAAa,CAAC,CAAa;IACnC,OAAO,CAAC,eAAe,CAAC,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAS;gBAGlC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,oBAAoB,EACpC,OAAO,GAAE,qBAA0B;IAcrC,uBAAuB;IACvB,IAAW,KAAK,IAAI,WAAW,CAE9B;IAED;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;OAEG;IACH,OAAO,CAAC,UAAU;IAYlB;;OAEG;IACH,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC;IAIlC;;OAEG;IACH,OAAO,CAAC,SAAS;IAiBjB;;OAEG;IACH,SAAS,CAAC,WAAW,IAAI,CAAC;IAW1B;;OAEG;IACH,OAAO,CAAC,WAAW;IAenB;;OAEG;IACH,OAAO,CAAC,YAAY;IAgBpB;;OAEG;IACI,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC;IAiBzB;;OAEG;IACI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;IAoBjD;;OAEG;IACI,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAkBpC;;OAEG;IACI,KAAK,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAOxC;;OAEG;IACI,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;CAGvD"}

package/library/stream/readable-stream.js

@@ -0,0 +1,249 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IframeReadableStream = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.symbol.async-iterator.js");
+require("core-js/modules/es.promise.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("../utils");
+var _constants = require("../constants");
+/**
+ * Stream message handler interface
+ */
+
+/**
+ * IframeReadableStream - Client-side readable stream
+ * Used to receive stream data sent from the server
+ */
+class IframeReadableStream {
+  constructor(streamId, requestId, messageHandler, options = {}) {
+    var _options$type, _options$chunked;
+    (0, _defineProperty2.default)(this, "_state", _constants.StreamState.PENDING);
+    (0, _defineProperty2.default)(this, "chunks", []);
+    this.streamId = streamId;
+    this.requestId = requestId;
+    this.messageHandler = messageHandler;
+    this.type = (_options$type = options.type) !== null && _options$type !== void 0 ? _options$type : _constants.StreamType.DATA;
+    this.chunked = (_options$chunked = options.chunked) !== null && _options$chunked !== void 0 ? _options$chunked : true;
+    this.metadata = options.metadata;
+    this.secretKey = options.secretKey;
+
+    // Register stream message handler
+    this.messageHandler.registerStreamHandler(streamId, this.handleStreamMessage.bind(this));
+  }
+
+  /** Get stream state */
+  get state() {
+    return this._state;
+  }
+
+  /**
+   * Handle stream message
+   */
+  handleStreamMessage(data) {
+    switch (data.type) {
+      case _constants.StreamInternalMessageType.DATA:
+        this.handleData(data.data, data.done);
+        break;
+      case _constants.StreamInternalMessageType.END:
+        this.handleEnd();
+        break;
+      case _constants.StreamInternalMessageType.ERROR:
+        this.handleError(new Error(data.error || _constants.Messages.STREAM_ERROR));
+        break;
+      case _constants.StreamInternalMessageType.CANCEL:
+        this.handleCancel(data.reason);
+        break;
+    }
+  }
+
+  /**
+   * Handle data chunk (internal method)
+   */
+  handleData(data, done) {
+    if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
+    this._state = _constants.StreamState.STREAMING;
+    var decoded = this.decodeData(data);
+    this.chunks.push(decoded);
+    if (done) {
+      this.handleEnd();
+    }
+  }
+
+  /**
+   * Decode data (subclasses can override, e.g., FileStream needs Base64 decoding)
+   */
+  decodeData(data) {
+    return data;
+  }
+
+  /**
+   * Stream ended (internal handling)
+   */
+  handleEnd() {
+    var _this$onEndCallback;
+    if (this._state === _constants.StreamState.ENDED) return;
+    this._state = _constants.StreamState.ENDED;
+    this.messageHandler.unregisterStreamHandler(this.streamId);
+    if (this.resolveRead) {
+      // Merge all data chunks
+      var result = this.mergeChunks();
+      this.resolveRead(result);
+      this.resolveRead = undefined;
+      this.rejectRead = undefined;
+    }
+    (_this$onEndCallback = this.onEndCallback) === null || _this$onEndCallback === void 0 || _this$onEndCallback.call(this);
+  }
+
+  /**
+   * Merge data chunks (subclasses can override)
+   */
+  mergeChunks() {
+    if (this.chunks.length === 0) {
+      return undefined;
+    }
+    if (this.chunks.length === 1) {
+      return this.chunks[0];
+    }
+    // Default returns array
+    return this.chunks;
+  }
+
+  /**
+   * Stream error (internal method)
+   */
+  handleError(error) {
+    var _this$onErrorCallback;
+    if (this._state === _constants.StreamState.ENDED || this._state === _constants.StreamState.ERROR) return;
+    this._state = _constants.StreamState.ERROR;
+    this.messageHandler.unregisterStreamHandler(this.streamId);
+    if (this.rejectRead) {
+      this.rejectRead(error);
+      this.resolveRead = undefined;
+      this.rejectRead = undefined;
+    }
+    (_this$onErrorCallback = this.onErrorCallback) === null || _this$onErrorCallback === void 0 || _this$onErrorCallback.call(this, error);
+  }
+
+  /**
+   * Stream cancelled (internal method)
+   */
+  handleCancel(reason) {
+    var _this$onErrorCallback2;
+    if (this._state === _constants.StreamState.ENDED || this._state === _constants.StreamState.ERROR || this._state === _constants.StreamState.CANCELLED) return;
+    this._state = _constants.StreamState.CANCELLED;
+    this.messageHandler.unregisterStreamHandler(this.streamId);
+    var error = new Error(reason || _constants.Messages.STREAM_CANCELLED);
+    if (this.rejectRead) {
+      this.rejectRead(error);
+      this.resolveRead = undefined;
+      this.rejectRead = undefined;
+    }
+    (_this$onErrorCallback2 = this.onErrorCallback) === null || _this$onErrorCallback2 === void 0 || _this$onErrorCallback2.call(this, error);
+  }
+
+  /**
+   * Read all data
+   */
+  read() {
+    return new Promise((resolve, reject) => {
+      if (this._state === _constants.StreamState.ENDED) {
+        resolve(this.mergeChunks());
+        return;
+      }
+      if (this._state === _constants.StreamState.ERROR || this._state === _constants.StreamState.CANCELLED) {
+        reject(new Error(_constants.Messages.STREAM_READ_ERROR));
+        return;
+      }
+      this.resolveRead = resolve;
+      this.rejectRead = reject;
+    });
+  }
+
+  /**
+   * Async iterator
+   */
+  [Symbol.asyncIterator]() {
+    var index = 0;
+    var stream = this;
+    return {
+      next() {
+        return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+          return _regenerator.default.wrap(function (_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                if (!(index >= stream.chunks.length)) {
+                  _context.next = 3;
+                  break;
+                }
+                if (!(stream._state === _constants.StreamState.ENDED || stream._state === _constants.StreamState.ERROR || stream._state === _constants.StreamState.CANCELLED)) {
+                  _context.next = 1;
+                  break;
+                }
+                return _context.abrupt("return", {
+                  done: true,
+                  value: undefined
+                });
+              case 1:
+                _context.next = 2;
+                return new Promise(resolve => setTimeout(resolve, 10));
+              case 2:
+                _context.next = 0;
+                break;
+              case 3:
+                return _context.abrupt("return", {
+                  done: false,
+                  value: stream.chunks[index++]
+                });
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }))();
+      }
+    };
+  }
+
+  /**
+   * Cancel stream
+   */
+  cancel(reason) {
+    if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
+    this._state = _constants.StreamState.CANCELLED;
+
+    // Notify server to cancel
+    var message = (0, _utils.createPostMessage)(_constants.MessageType.STREAM_CANCEL, this.requestId, {
+      secretKey: this.secretKey,
+      body: {
+        streamId: this.streamId,
+        reason
+      }
+    });
+    this.messageHandler.postMessage(message);
+    this.messageHandler.unregisterStreamHandler(this.streamId);
+  }
+
+  /**
+   * Listen for stream end
+   */
+  onEnd(callback) {
+    this.onEndCallback = callback;
+    if (this._state === _constants.StreamState.ENDED) {
+      callback();
+    }
+  }
+
+  /**
+   * Listen for stream error
+   */
+  onError(callback) {
+    this.onErrorCallback = callback;
+  }
+}
+exports.IframeReadableStream = IframeReadableStream;

package/library/stream/types.d.ts

@@ -0,0 +1,165 @@
+import { StreamType as StreamTypeConstant, StreamState as StreamStateConstant } from '../constants';
+import type { MessageChannel } from '../message';
+/**
+ * Stream type
+ */
+export type StreamType = typeof StreamTypeConstant[keyof typeof StreamTypeConstant];
+/**
+ * Stream data chunk
+ */
+export interface StreamChunk {
+    /** Chunk data */
+    data: any;
+    /** Whether this is the last chunk */
+    done: boolean;
+}
+/**
+ * Writable stream configuration options
+ */
+export interface WritableStreamOptions {
+    /** Stream type: data for regular data, file for files */
+    type?: StreamType;
+    /** Whether to use chunked transfer (true: multiple transfers, false: single transfer) */
+    chunked?: boolean;
+    /** Data generator iterator (higher priority than next) */
+    iterator?: () => AsyncGenerator<any, void, unknown>;
+    /** Data generator function (returns next chunk on each call) */
+    next?: () => Promise<StreamChunk> | StreamChunk;
+    /** Stream metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Readable stream configuration options
+ */
+export interface ReadableStreamOptions {
+    /** Stream type */
+    type?: StreamType;
+    /** Whether to use chunked transfer */
+    chunked?: boolean;
+    /** Stream metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * File writable stream configuration options
+ */
+export interface FileWritableStreamOptions extends Omit<WritableStreamOptions, 'type'> {
+    /** Filename */
+    filename: string;
+    /** MIME type */
+    mimeType?: string;
+    /** File size (optional, used for progress calculation) */
+    size?: number;
+}
+/**
+ * File readable stream configuration options
+ */
+export interface FileReadableStreamOptions extends Omit<ReadableStreamOptions, 'type'> {
+    /** Filename */
+    filename?: string;
+    /** MIME type */
+    mimeType?: string;
+    /** File size */
+    size?: number;
+}
+/**
+ * Stream bind context (associates request information)
+ */
+export interface StreamBindContext {
+    /** Request ID */
+    requestId: string;
+    /** Target window */
+    targetWindow: Window;
+    /** Target origin */
+    targetOrigin: string;
+    /** secretKey */
+    secretKey?: string;
+    /** MessageChannel for sending messages (optional, uses direct postMessage if not provided) */
+    channel?: MessageChannel;
+}
+/**
+ * Stream state
+ */
+export type StreamState = typeof StreamStateConstant[keyof typeof StreamStateConstant];
+/**
+ * Writable stream interface (server-side)
+ */
+export interface IIframeWritableStream {
+    /** Stream ID */
+    readonly streamId: string;
+    /** Stream type */
+    readonly type: StreamType;
+    /** Whether chunked */
+    readonly chunked: boolean;
+    /** Stream state */
+    readonly state: StreamState;
+    /** Bind to request context */
+    _bind(context: StreamBindContext): void;
+    /** Start stream transfer */
+    start(): Promise<void>;
+    /** Cancel stream transfer */
+    cancel(reason?: string): void;
+}
+/**
+ * Readable stream interface (client-side)
+ */
+export interface IIframeReadableStream<T = any> {
+    /** Stream ID */
+    readonly streamId: string;
+    /** Stream type */
+    readonly type: StreamType;
+    /** Whether chunked */
+    readonly chunked: boolean;
+    /** Stream state */
+    readonly state: StreamState;
+    /** Stream metadata */
+    readonly metadata?: Record<string, any>;
+    /** Read all data (for non-chunked streams or wait for chunked stream to complete) */
+    read(): Promise<T>;
+    /** Async iterator (for chunked streams) */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /** Cancel stream */
+    cancel(reason?: string): void;
+    /** Listen for stream end */
+    onEnd(callback: () => void): void;
+    /** Listen for stream error */
+    onError(callback: (error: Error) => void): void;
+}
+/**
+ * File readable stream interface
+ */
+export interface IIframeFileReadableStream extends IIframeReadableStream<Uint8Array> {
+    /** Filename */
+    readonly filename?: string;
+    /** MIME type */
+    readonly mimeType?: string;
+    /** File size */
+    readonly size?: number;
+    /** Read as Blob */
+    readAsBlob(): Promise<Blob>;
+    /** Read as ArrayBuffer */
+    readAsArrayBuffer(): Promise<ArrayBuffer>;
+    /** Read as Data URL */
+    readAsDataURL(): Promise<string>;
+}
+/**
+ * Stream message data
+ */
+export interface StreamMessageData {
+    /** Stream ID */
+    streamId: string;
+    /** Stream type */
+    type?: StreamType;
+    /** Whether chunked */
+    chunked?: boolean;
+    /** Data chunk */
+    data?: any;
+    /** Whether this is the last chunk */
+    done?: boolean;
+    /** Error message */
+    error?: string;
+    /** Cancel reason */
+    reason?: string;
+    /** Metadata */
+    metadata?: Record<string, any>;
+}
+//# sourceMappingURL=types.d.ts.map

package/library/stream/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/stream/types.ts"],"names":[],"mappings":"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"}

package/library/stream/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/library/stream/writable-stream.d.ts

@@ -0,0 +1,60 @@
+import { StreamType, StreamState, StreamBindContext, WritableStreamOptions, IIframeWritableStream } from './types';
+/**
+ * IframeWritableStream - Server-side writable stream
+ * Used to send stream data to the client
+ */
+export declare class IframeWritableStream implements IIframeWritableStream {
+    readonly streamId: string;
+    readonly type: StreamType;
+    readonly chunked: boolean;
+    private _state;
+    private context;
+    private readonly iterator?;
+    private readonly nextFn?;
+    private readonly metadata?;
+    constructor(options?: WritableStreamOptions);
+    /** Get stream state */
+    get state(): StreamState;
+    /**
+     * Bind to request context
+     * Called during res.sendStream()
+     */
+    _bind(context: StreamBindContext): void;
+    /**
+     * Send message to client
+     */
+    private sendMessage;
+    /**
+     * Start stream transfer
+     */
+    start(): Promise<void>;
+    /**
+     * Generate data from iterator
+     */
+    private streamFromIterator;
+    /**
+     * Generate data from next function
+     */
+    private streamFromNext;
+    /**
+     * Send data chunk
+     */
+    private sendData;
+    /**
+     * Encode data (subclasses can override, e.g., FileStream needs Base64 encoding)
+     */
+    protected encodeData(data: any): any;
+    /**
+     * End stream
+     */
+    private end;
+    /**
+     * Send error
+     */
+    private error;
+    /**
+     * Cancel stream transfer
+     */
+    cancel(reason?: string): void;
+}
+//# sourceMappingURL=writable-stream.d.ts.map

package/library/stream/writable-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-stream.d.ts","sourceRoot":"","sources":["../../src/stream/writable-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EAEtB,MAAM,SAAS,CAAC;AAWjB;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,qBAAqB;IAChE,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,UAAU,CAAC;IACjC,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC,OAAO,CAAC,MAAM,CAA4C;IAC1D,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAA2C;IACrE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAA2C;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAsB;gBAE7B,OAAO,GAAE,qBAA0B;IAStD,uBAAuB;IACvB,IAAW,KAAK,IAAI,WAAW,CAE9B;IAED;;;OAGG;IACI,KAAK,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAI9C;;OAEG;IACH,OAAO,CAAC,WAAW;IAqBnB;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkCnC;;OAEG;YACW,kBAAkB;IAuBhC;;OAEG;YACW,cAAc;IAsB5B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAOhB;;OAEG;IACH,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG;IAIpC;;OAEG;IACH,OAAO,CAAC,GAAG;IAOX;;OAEG;IACH,OAAO,CAAC,KAAK;IASb;;OAEG;IACI,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;CAWrC"}