request-iframe 0.0.6 → 0.1.0

package/esm/core/client-server.js

@@ -0,0 +1,329 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.set.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 { MessageDispatcher } from '../message';
+import { getOrCreateMessageChannel, releaseMessageChannel } from '../utils/cache';
+import { isCompatibleVersion } from '../utils';
+import { MessageType, DefaultTimeout, ProtocolVersion, Messages, formatMessage, MessageRole } from '../constants';
+
+/**
+ * Stream message handler callback
+ */
+
+/**
+ * Pending acknowledgment response
+ */
+
+/**
+ * Pending request awaiting response
+ */
+
+/**
+ * ClientServer configuration options
+ */
+
+/**
+ * RequestIframeClientServer - Client-side message server
+ * Only handles responses, not requests
+ * Uses shared MessageDispatcher (backed by MessageChannel) to listen for and send messages
+ */
+export class RequestIframeClientServer {
+  constructor(options, instanceId) {
+    var _options$ackTimeout, _options$versionValid;
+    /** Pending responses awaiting client acknowledgment */
+    _defineProperty(this, "pendingAcks", new Map());
+    /** Pending requests awaiting response */
+    _defineProperty(this, "pendingRequests", new Map());
+    /**
+     * Avoid spamming logs for the same requestId when closed/destroyed
+     */
+    _defineProperty(this, "warnedMissingPendingWhenClosed", new Set());
+    /** List of unregister handler functions */
+    _defineProperty(this, "unregisterFns", []);
+    /** Whether opened */
+    _defineProperty(this, "_isOpen", false);
+    this.ackTimeout = (_options$ackTimeout = options === null || options === void 0 ? void 0 : options.ackTimeout) !== null && _options$ackTimeout !== void 0 ? _options$ackTimeout : DefaultTimeout.ACK;
+    this.versionValidator = (_options$versionValid = options === null || options === void 0 ? void 0 : options.versionValidator) !== null && _options$versionValid !== void 0 ? _options$versionValid : isCompatibleVersion;
+
+    // Get or create shared channel and create dispatcher
+    var channel = getOrCreateMessageChannel(options === null || options === void 0 ? void 0 : options.secretKey);
+    this.dispatcher = new MessageDispatcher(channel, MessageRole.CLIENT, instanceId);
+
+    // Auto-open by default (unless explicitly set to false)
+    if ((options === null || options === void 0 ? void 0 : options.autoOpen) !== false) {
+      this.open();
+    }
+  }
+
+  /**
+   * Open message handling (register message handlers)
+   */
+  open() {
+    if (this._isOpen) return;
+    this._isOpen = true;
+    this.registerHandlers();
+  }
+
+  /**
+   * Close message handling (unregister message handlers, but don't release channel)
+   */
+  close() {
+    if (!this._isOpen) return;
+    this._isOpen = false;
+
+    // Unregister all handlers
+    this.unregisterFns.forEach(fn => fn());
+    this.unregisterFns.length = 0;
+  }
+
+  /**
+   * Whether opened
+   */
+  get isOpen() {
+    return this._isOpen;
+  }
+
+  /**
+   * Register message handlers
+   */
+  registerHandlers() {
+    var handlerOptions = {
+      versionValidator: this.versionValidator,
+      onVersionError: this.handleVersionError.bind(this)
+    };
+
+    // Bind handleClientResponse to ensure correct 'this' context
+    var boundHandleClientResponse = this.handleClientResponse.bind(this);
+
+    // Handle ACK messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.ACK, boundHandleClientResponse, handlerOptions));
+
+    // Handle ASYNC messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.ASYNC, boundHandleClientResponse, handlerOptions));
+
+    // Handle RESPONSE messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.RESPONSE, boundHandleClientResponse, handlerOptions));
+
+    // Handle ERROR messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.ERROR, boundHandleClientResponse, handlerOptions));
+
+    // Handle RECEIVED messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.RECEIVED, this.handleReceived.bind(this), handlerOptions));
+
+    // Handle PONG messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.PONG, this.handlePong.bind(this), handlerOptions));
+
+    // Handle PING messages (server -> client heartbeat)
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.PING, this.handlePing.bind(this), handlerOptions));
+
+    // Handle stream_start messages (route to handleClientResponse so it reaches send callback)
+    // Note: stream_start is handled in send callback, not through streamCallback
+    this.unregisterFns.push(this.dispatcher.registerHandler(MessageType.STREAM_START, boundHandleClientResponse, handlerOptions));
+
+    // Handle other stream messages (stream_data, stream_end, etc.)
+    this.unregisterFns.push(this.dispatcher.registerHandler(type => type.startsWith('stream_') && type !== MessageType.STREAM_START, (data, context) => {
+      var _this$streamCallback;
+      return (_this$streamCallback = this.streamCallback) === null || _this$streamCallback === void 0 ? void 0 : _this$streamCallback.call(this, data, context);
+    }, handlerOptions));
+  }
+  handlePing(data, context) {
+    if (!context.source) return;
+    // Mark accepted so MessageDispatcher can auto-send ACK when requireAck === true
+    if (!context.handledBy) {
+      context.accepted = true;
+      context.handledBy = 'client';
+    }
+    // Reply PONG
+    this.dispatcher.sendMessage(context.source, context.origin, MessageType.PONG, data.requestId, {
+      targetId: data.creatorId
+    });
+  }
+
+  /**
+   * Handle protocol version error
+   */
+  handleVersionError(data, context, version) {
+    // For response messages, we need to notify the waiting request
+    var pending = this.pendingRequests.get(data.requestId);
+    if (pending) {
+      this.pendingRequests.delete(data.requestId);
+      pending.reject(new Error(formatMessage(Messages.PROTOCOL_VERSION_TOO_LOW, version, ProtocolVersion.MIN_SUPPORTED)));
+    }
+  }
+
+  /**
+   * Handle client response
+   */
+  handleClientResponse(data, context) {
+    var pending = this.pendingRequests.get(data.requestId);
+    if (!pending) {
+      /**
+       * Pending request not found - ignore by default.
+       *
+       * If client server is already closed/destroyed, emit a warning to help debugging:
+       * this usually means the client was recreated/unmounted before the response arrived.
+       */
+      if (!this._isOpen) {
+        var key = data.requestId;
+        if (!this.warnedMissingPendingWhenClosed.has(key)) {
+          this.warnedMissingPendingWhenClosed.add(key);
+          // eslint-disable-next-line no-console
+          console.warn(formatMessage(Messages.CLIENT_SERVER_IGNORED_MESSAGE_WHEN_CLOSED, data.type, data.requestId));
+        }
+      }
+      return;
+    }
+
+    // Validate origin
+    if (pending.originValidator) {
+      try {
+        if (!pending.originValidator(context.origin, data, context)) {
+          return;
+        }
+      } catch (_unused) {
+        // If validator throws, treat as disallowed
+        return;
+      }
+    } else if (pending.origin && pending.origin !== '*' && context.origin !== pending.origin) {
+      return;
+    }
+
+    /**
+     * Mark as handled so:
+     * - other client instances sharing the same channel won't also process it
+     * - MessageDispatcher can run its generalized requireAck auto-ack logic
+     */
+    if (!context.handledBy) {
+      context.accepted = true;
+      context.handledBy = 'client';
+    }
+
+    // ack, async, and stream_start don't delete pending (stream_start needs to keep pending for stream_data/stream_end)
+    if (data.type === MessageType.ACK || data.type === MessageType.ASYNC || data.type === MessageType.STREAM_START) {
+      pending.resolve(data);
+      return;
+    }
+
+    // response and error delete pending
+    this.pendingRequests.delete(data.requestId);
+    pending.resolve(data);
+  }
+
+  /**
+   * Handle received acknowledgment
+   */
+  handleReceived(data) {
+    var pending = this.pendingAcks.get(data.requestId);
+    if (pending) {
+      clearTimeout(pending.timeoutId);
+      this.pendingAcks.delete(data.requestId);
+      pending.resolve(true);
+    }
+  }
+
+  /**
+   * Handle pong
+   */
+  handlePong(data, context) {
+    var pending = this.pendingRequests.get(data.requestId);
+    if (pending) {
+      if (pending.originValidator) {
+        try {
+          if (!pending.originValidator(context.origin, data, context)) {
+            return;
+          }
+        } catch (_unused2) {
+          return;
+        }
+      } else if (pending.origin && pending.origin !== '*' && context.origin !== pending.origin) {
+        return;
+      }
+      if (!context.handledBy) {
+        context.accepted = true;
+        context.handledBy = 'client';
+      }
+      this.pendingRequests.delete(data.requestId);
+      pending.resolve(data);
+    }
+  }
+
+  /**
+   * Set stream message handler callback
+   */
+  setStreamCallback(callback) {
+    this.streamCallback = callback;
+  }
+
+  /** Get secretKey */
+  get secretKey() {
+    return this.dispatcher.secretKey;
+  }
+
+  /** Get the underlying MessageDispatcher */
+  get messageDispatcher() {
+    return this.dispatcher;
+  }
+
+  /**
+   * Register pending acknowledgment response
+   */
+  _registerPendingAck(requestId, resolve, reject) {
+    var timeoutId = setTimeout(() => {
+      this.pendingAcks.delete(requestId);
+      resolve(false);
+    }, this.ackTimeout);
+    this.pendingAcks.set(requestId, {
+      resolve,
+      reject,
+      timeoutId
+    });
+  }
+
+  /**
+   * Register pending request awaiting response
+   */
+  _registerPendingRequest(requestId, resolve, reject, origin, originValidator) {
+    this.pendingRequests.set(requestId, {
+      resolve,
+      reject,
+      origin,
+      originValidator
+    });
+  }
+
+  /**
+   * Cancel pending response
+   */
+  _unregisterPendingRequest(requestId) {
+    this.pendingRequests.delete(requestId);
+  }
+
+  /**
+   * Send ping message
+   */
+  sendPing(targetWindow, targetOrigin, requestId) {
+    this.dispatcher.sendMessage(targetWindow, targetOrigin, MessageType.PING, requestId);
+  }
+
+  /**
+   * Destroy (close and release channel reference)
+   */
+  destroy() {
+    // Close first
+    this.close();
+
+    // Clear pending
+    this.pendingRequests.clear();
+    this.pendingAcks.forEach(pending => clearTimeout(pending.timeoutId));
+    this.pendingAcks.clear();
+    this.warnedMissingPendingWhenClosed.clear();
+
+    // Destroy dispatcher and release channel reference
+    this.dispatcher.destroy();
+    releaseMessageChannel(this.dispatcher.getChannel());
+  }
+}