request-iframe 0.0.5 → 0.1.0

package/esm/constants/index.js

@@ -0,0 +1,257 @@
+/**
+ * Protocol version constants
+ * Used to identify the protocol version of messages, for compatibility handling in future version upgrades
+ * 
+ * Version compatibility strategy:
+ * - Only check minimum supported version, reject deprecated old versions
+ * - Don't check maximum version, as new versions usually maintain backward compatibility with old message formats
+ * - This way new version servers can be compatible with old version clients, without forcing client upgrades
+ */
+export var ProtocolVersion = {
+  /** Current protocol version */
+  CURRENT: 2,
+  /** Minimum supported protocol version (messages below this version will be rejected) */
+  MIN_SUPPORTED: 1
+};
+
+/**
+ * Protocol version type
+ */
+
+/**
+ * Protocol validation result
+ */
+
+/**
+ * HTTP status code constants
+ */
+export var HttpStatus = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  REQUEST_TIMEOUT: 408,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503
+};
+
+/**
+ * HTTP status text constants
+ */
+export var HttpStatusText = {
+  [HttpStatus.OK]: 'OK',
+  [HttpStatus.CREATED]: 'Created',
+  [HttpStatus.NO_CONTENT]: 'No Content',
+  [HttpStatus.BAD_REQUEST]: 'Bad Request',
+  [HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+  [HttpStatus.FORBIDDEN]: 'Forbidden',
+  [HttpStatus.NOT_FOUND]: 'Not Found',
+  [HttpStatus.REQUEST_TIMEOUT]: 'Request Timeout',
+  [HttpStatus.TOO_MANY_REQUESTS]: 'Too Many Requests',
+  [HttpStatus.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+  [HttpStatus.BAD_GATEWAY]: 'Bad Gateway',
+  [HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable'
+};
+
+/**
+ * Get status text
+ */
+export function getStatusText(code) {
+  return HttpStatusText[code] || 'Unknown';
+}
+
+/**
+ * Error code constants
+ */
+export var ErrorCode = {
+  /** ACK confirmation timeout */
+  ACK_TIMEOUT: 'ACK_TIMEOUT',
+  /** Request timeout (synchronous) */
+  TIMEOUT: 'TIMEOUT',
+  /** Async request timeout */
+  ASYNC_TIMEOUT: 'ASYNC_TIMEOUT',
+  /** Request error */
+  REQUEST_ERROR: 'REQUEST_ERROR',
+  /** Method not found */
+  METHOD_NOT_FOUND: 'METHOD_NOT_FOUND',
+  /** No response */
+  NO_RESPONSE: 'NO_RESPONSE',
+  /** Protocol version not supported */
+  PROTOCOL_UNSUPPORTED: 'PROTOCOL_UNSUPPORTED',
+  /** iframe not ready */
+  IFRAME_NOT_READY: 'IFRAME_NOT_READY',
+  /** Stream error */
+  STREAM_ERROR: 'STREAM_ERROR',
+  /** Stream cancelled */
+  STREAM_CANCELLED: 'STREAM_CANCELLED',
+  /** Stream not bound */
+  STREAM_NOT_BOUND: 'STREAM_NOT_BOUND',
+  /** Target window closed */
+  TARGET_WINDOW_CLOSED: 'TARGET_WINDOW_CLOSED',
+  /** Too many concurrent requests (rate limiting) */
+  TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
+  /** Stream start not received in time */
+  STREAM_START_TIMEOUT: 'STREAM_START_TIMEOUT'
+};
+
+/**
+ * Message type constants
+ */
+export var MessageType = {
+  /** Request message */
+  REQUEST: 'request',
+  /** Acknowledge request received */
+  ACK: 'ack',
+  /** Async task notification */
+  ASYNC: 'async',
+  /** Response message */
+  RESPONSE: 'response',
+  /** Error message */
+  ERROR: 'error',
+  /** Client confirms response received */
+  RECEIVED: 'received',
+  /** Ping message (for connection detection) */
+  PING: 'ping',
+  /** Pong message (for connection detection) */
+  PONG: 'pong',
+  /** Stream start */
+  STREAM_START: 'stream_start',
+  /** Stream data chunk */
+  STREAM_DATA: 'stream_data',
+  /** Stream end */
+  STREAM_END: 'stream_end',
+  /** Stream error */
+  STREAM_ERROR: 'stream_error',
+  /** Stream cancel */
+  STREAM_CANCEL: 'stream_cancel',
+  /** Stream pull (receiver requests next chunks) */
+  STREAM_PULL: 'stream_pull',
+  /** Stream ack (receiver acknowledges a chunk) */
+  STREAM_ACK: 'stream_ack'
+};
+export var MessageRole = {
+  /** Server role */
+  SERVER: 'server',
+  /** Client role */
+  CLIENT: 'client'
+};
+/**
+ * Default timeout configuration (milliseconds)
+ */
+export var DefaultTimeout = {
+  /** 
+   * ACK confirmation timeout: 1000ms (1s)
+   * Used for both client waiting for server ACK and server waiting for client RECEIVED.
+   * Increased from 500ms to accommodate slower environments or busy browsers where postMessage
+   * serialization/deserialization may take longer.
+   */
+  ACK: 1000,
+  /** Request timeout: 5s */
+  REQUEST: 5000,
+  /** Async request timeout: 120s */
+  ASYNC: 120000
+};
+
+/**
+ * HTTP Header name constants
+ */
+export var HttpHeader = {
+  /** Set-Cookie (server sets cookie) */
+  SET_COOKIE: 'Set-Cookie',
+  /** Content-Type */
+  CONTENT_TYPE: 'Content-Type',
+  /** Content-Disposition (for file downloads) */
+  CONTENT_DISPOSITION: 'Content-Disposition',
+  /** Authorization */
+  AUTHORIZATION: 'Authorization',
+  /** Cookie (cookies carried in request) */
+  COOKIE: 'Cookie'
+};
+
+/**
+ * HTTP Header name type
+ */
+
+/**
+ * Message type union type
+ */
+
+/**
+ * Error code union type
+ */
+
+/**
+ * Stream type constants
+ */
+export var StreamType = {
+  /** Normal data stream */
+  DATA: 'data',
+  /** File stream */
+  FILE: 'file'
+};
+
+/**
+ * Stream mode constants
+ * - PULL: receiver pulls next chunks (backpressure)
+ * - PUSH: producer pushes via write()
+ */
+export var StreamMode = {
+  PULL: 'pull',
+  PUSH: 'push'
+};
+/**
+ * Stream internal message type constants (for stream internal message handling)
+ * Note: These are MessageType.STREAM_* values with the stream_ prefix removed
+ */
+export var StreamInternalMessageType = {
+  /** Data message */
+  DATA: 'data',
+  /** End message */
+  END: 'end',
+  /** Error message */
+  ERROR: 'error',
+  /** Cancel message */
+  CANCEL: 'cancel',
+  /** Pull message */
+  PULL: 'pull',
+  /** Ack message */
+  ACK: 'ack'
+};
+
+/**
+ * Stream internal message type value type
+ */
+
+/**
+ * Stream type value type
+ */
+
+/**
+ * Stream state constants
+ */
+export var StreamState = {
+  /** Pending */
+  PENDING: 'pending',
+  /** Streaming */
+  STREAMING: 'streaming',
+  /** Ended */
+  ENDED: 'ended',
+  /** Error */
+  ERROR: 'error',
+  /** Cancelled */
+  CANCELLED: 'cancelled'
+};
+
+/**
+ * Stream state value type
+ */
+
+/**
+ * Message constants (for multi-language support)
+ */
+export { Messages, formatMessage, setMessages, resetMessages, getMessages } from './messages';

package/esm/constants/messages.js

@@ -0,0 +1,155 @@
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+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; }
+/**
+ * Message constants (for multi-language support)
+ * 
+ * Usage:
+ * 1. Direct use: Messages.REQUEST_FAILED
+ * 2. Messages with parameters: Messages.formatMessage(Messages.CONNECT_TIMEOUT, timeout)
+ * 
+ * Multi-language extension:
+ * You can use the setMessages() method to replace message content for multi-language support
+ */
+
+/**
+ * Default message definitions
+ */
+var defaultMessages = {
+  /** Protocol related errors */
+  INVALID_PROTOCOL_VERSION_FORMAT: 'Invalid protocol version format',
+  PROTOCOL_VERSION_TOO_LOW: 'Protocol version {0} is too low, minimum supported version is {1}',
+  PROTOCOL_VERSION_UNSUPPORTED: 'Protocol Version Unsupported',
+  /** Message format errors */
+  INVALID_MESSAGE_FORMAT_NOT_OBJECT: 'Invalid message format: not an object',
+  INVALID_MESSAGE_FORMAT_MISSING_PROTOCOL: 'Invalid message format: missing __requestIframe__ field',
+  INVALID_MESSAGE_FORMAT_MISSING_TYPE: 'Invalid message format: missing or invalid type field',
+  INVALID_MESSAGE_FORMAT_MISSING_REQUEST_ID: 'Invalid message format: missing or invalid requestId field',
+  /** Timeout errors */
+  ACK_TIMEOUT: 'ACK timeout after {0}ms',
+  REQUEST_TIMEOUT: 'Request timeout after {0}ms',
+  ASYNC_REQUEST_TIMEOUT: 'Async request timeout after {0}ms',
+  /** Request/response errors */
+  REQUEST_FAILED: 'Request failed',
+  METHOD_NOT_FOUND: 'Method not found',
+  NO_RESPONSE_SENT: 'Handler completed but no response sent',
+  MIDDLEWARE_ERROR: 'Middleware error',
+  ERROR: 'Error',
+  TOO_MANY_REQUESTS: 'Too many concurrent requests (limit: {0})',
+  /** Client errors */
+  IFRAME_NOT_READY: 'iframe.contentWindow is not available',
+  TARGET_WINDOW_CLOSED: 'Target window is closed or no longer available',
+  /** ClientServer warnings */
+  CLIENT_SERVER_IGNORED_MESSAGE_WHEN_CLOSED: 'Ignored message because client server is closed/destroyed (type: {0}, requestId: {1})',
+  /** Stream related messages */
+  STREAM_NOT_BOUND: 'Stream is not bound to a request context',
+  STREAM_ALREADY_STARTED: 'Stream has already started',
+  STREAM_CANCELLED: 'Stream was cancelled: {0}',
+  STREAM_ERROR: 'Stream error: {0}',
+  STREAM_TIMEOUT: 'Stream idle timeout after {0}ms',
+  STREAM_EXPIRED: 'Stream expired after {0}ms',
+  STREAM_START_TIMEOUT: 'Stream start timeout after {0}ms',
+  STREAM_ENDED: 'Stream has ended',
+  STREAM_READ_ERROR: 'Failed to read stream data',
+  STREAM_WRITE_ONLY_IN_PUSH_MODE: 'Stream write() is only available when mode is "push"',
+  /** Debug messages - Client */
+  DEBUG_CLIENT_REQUEST_START: '📤 [Client] Request Start',
+  DEBUG_CLIENT_REQUEST_SUCCESS: '✅ [Client] Request Success',
+  DEBUG_CLIENT_REQUEST_SUCCESS_FILE: '✅ [Client] Request Success (File)',
+  DEBUG_CLIENT_REQUEST_SUCCESS_STREAM: '✅ [Client] Request Success (Stream)',
+  DEBUG_CLIENT_REQUEST_FAILED: '❌ [Client] Request Failed',
+  DEBUG_CLIENT_RECEIVED_ACK: '📥 [Client] Received ACK',
+  DEBUG_CLIENT_RECEIVED_ASYNC: '⏳ [Client] Received ASYNC Notification',
+  DEBUG_CLIENT_RECEIVED_STREAM_START: '🌊 [Client] Received Stream Start',
+  DEBUG_CLIENT_RECEIVED_STREAM_DATA: '🌊 [Client] Received Stream Data',
+  DEBUG_CLIENT_RECEIVED_STREAM_END: '🌊 [Client] Received Stream End',
+  DEBUG_CLIENT_RECEIVED_RESPONSE: '📥 [Client] Received Response',
+  DEBUG_CLIENT_RECEIVED_ERROR: '📥 [Client] Received Error',
+  DEBUG_CLIENT_REQUEST_TIMEOUT: '⏱️ [Client] Request Timeout',
+  DEBUG_CLIENT_SENDING_REQUEST: '📤 [Client] Sending Request',
+  DEBUG_CLIENT_SENDING_PING: '📤 [Client] Sending Ping',
+  DEBUG_CLIENT_SENDING_RECEIVED_ACK: '📤 [Client] Sending Received ACK',
+  /** Debug messages - Server */
+  DEBUG_SERVER_RECEIVED_REQUEST: '📥 [Server] Received Request',
+  DEBUG_SERVER_SETTING_STATUS_CODE: '📝 [Server] Setting Status Code',
+  DEBUG_SERVER_SETTING_HEADER: '📝 [Server] Setting Header',
+  DEBUG_SERVER_SENDING_RESPONSE: '📤 [Server] Sending Response',
+  DEBUG_SERVER_SENDING_JSON_RESPONSE: '📤 [Server] Sending JSON Response',
+  DEBUG_SERVER_SENDING_FILE: '📤 [Server] Sending File',
+  DEBUG_SERVER_SENDING_STREAM: '📤 [Server] Sending Stream',
+  DEBUG_SERVER_SENDING_ACK: '📤 [Server] Sending ACK',
+  DEBUG_SERVER_SENDING_ASYNC: '📤 [Server] Sending ASYNC Notification',
+  DEBUG_SERVER_SENDING_STREAM_START: '🌊 [Server] Sending Stream Start',
+  DEBUG_SERVER_SENDING_STREAM_DATA: '🌊 [Server] Sending Stream Data',
+  DEBUG_SERVER_SENDING_STREAM_END: '🌊 [Server] Sending Stream End',
+  DEBUG_SERVER_SENDING_ERROR: '📤 [Server] Sending Error',
+  DEBUG_SERVER_SENDING_RESPONSE_VIA_DISPATCHER: '📤 [Server] Sending Response (via dispatcher)',
+  DEBUG_SERVER_HANDLING_REQUEST: '📥 [Server] Handling Request',
+  DEBUG_SERVER_EXECUTING_MIDDLEWARE_CHAIN: '⚙️ [Server] Executing Middleware Chain',
+  DEBUG_SERVER_MIDDLEWARE_CHAIN_COMPLETED: '✅ [Server] Middleware Chain Completed'
+};
+
+/**
+ * Message type
+ */
+
+/**
+ * Current message configuration
+ */
+var currentMessages = _objectSpread({}, defaultMessages);
+
+/**
+ * Message constants object
+ */
+export var Messages = new Proxy(currentMessages, {
+  get(target, prop) {
+    return target[prop] || prop;
+  }
+});
+
+/**
+ * Set message content (for multi-language support)
+ * @param messages Custom message content (partial or full)
+ */
+export function setMessages(messages) {
+  currentMessages = _objectSpread(_objectSpread({}, defaultMessages), messages);
+}
+
+/**
+ * Reset to default messages
+ */
+export function resetMessages() {
+  currentMessages = _objectSpread({}, defaultMessages);
+}
+
+/**
+ * Format message (replace placeholders)
+ * @param template Message template, using {0}, {1}, etc. as placeholders
+ * @param args Replacement parameters
+ * @returns Formatted message
+ * 
+ * @example
+ * formatMessage('Connect timeout after {0}ms', 5000)
+ * // => 'Connect timeout after 5000ms'
+ * 
+ * formatMessage('Protocol version {0} is too low, minimum supported version is {1}', 0, 1)
+ * // => 'Protocol version 0 is too low, minimum supported version is 1'
+ */
+export function formatMessage(template, ...args) {
+  return template.replace(/\{(\d+)\}/g, (match, index) => {
+    var argIndex = parseInt(index, 10);
+    return argIndex < args.length ? String(args[argIndex]) : match;
+  });
+}
+
+/**
+ * Get current message configuration
+ */
+export function getMessages() {
+  return _objectSpread({}, currentMessages);
+}