request-iframe 0.0.1

package/library/constants/index.d.ts

@@ -0,0 +1,209 @@
+/**
+ * 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 declare const ProtocolVersion: {
+    /** Current protocol version */
+    readonly CURRENT: 1;
+    /** Minimum supported protocol version (messages below this version will be rejected) */
+    readonly MIN_SUPPORTED: 1;
+};
+/**
+ * Protocol version type
+ */
+export type ProtocolVersionValue = typeof ProtocolVersion[keyof typeof ProtocolVersion];
+/**
+ * Protocol validation result
+ */
+export interface ProtocolValidationResult {
+    /** Whether valid */
+    valid: boolean;
+    /** Protocol version (if valid) */
+    version?: number;
+    /** Error message (if invalid) */
+    error?: string;
+    /** Error code (if invalid) */
+    errorCode?: 'INVALID_FORMAT' | 'VERSION_TOO_LOW';
+}
+/**
+ * HTTP status code constants
+ */
+export declare const HttpStatus: {
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly NO_CONTENT: 204;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+};
+/**
+ * HTTP status text constants
+ */
+export declare const HttpStatusText: Record<number, string>;
+/**
+ * Get status text
+ */
+export declare function getStatusText(code: number): string;
+/**
+ * Error code constants
+ */
+export declare const ErrorCode: {
+    /** ACK confirmation timeout */
+    readonly ACK_TIMEOUT: "ACK_TIMEOUT";
+    /** Request timeout (synchronous) */
+    readonly TIMEOUT: "TIMEOUT";
+    /** Async request timeout */
+    readonly ASYNC_TIMEOUT: "ASYNC_TIMEOUT";
+    /** Request error */
+    readonly REQUEST_ERROR: "REQUEST_ERROR";
+    /** Method not found */
+    readonly METHOD_NOT_FOUND: "METHOD_NOT_FOUND";
+    /** No response */
+    readonly NO_RESPONSE: "NO_RESPONSE";
+    /** Protocol version not supported */
+    readonly PROTOCOL_UNSUPPORTED: "PROTOCOL_UNSUPPORTED";
+    /** iframe not ready */
+    readonly IFRAME_NOT_READY: "IFRAME_NOT_READY";
+    /** Stream error */
+    readonly STREAM_ERROR: "STREAM_ERROR";
+    /** Stream cancelled */
+    readonly STREAM_CANCELLED: "STREAM_CANCELLED";
+    /** Stream not bound */
+    readonly STREAM_NOT_BOUND: "STREAM_NOT_BOUND";
+};
+/**
+ * Message type constants
+ */
+export declare const MessageType: {
+    /** Request message */
+    readonly REQUEST: "request";
+    /** Acknowledge request received */
+    readonly ACK: "ack";
+    /** Async task notification */
+    readonly ASYNC: "async";
+    /** Response message */
+    readonly RESPONSE: "response";
+    /** Error message */
+    readonly ERROR: "error";
+    /** Client confirms response received */
+    readonly RECEIVED: "received";
+    /** Ping message (for connection detection) */
+    readonly PING: "ping";
+    /** Pong message (for connection detection) */
+    readonly PONG: "pong";
+    /** Stream start */
+    readonly STREAM_START: "stream_start";
+    /** Stream data chunk */
+    readonly STREAM_DATA: "stream_data";
+    /** Stream end */
+    readonly STREAM_END: "stream_end";
+    /** Stream error */
+    readonly STREAM_ERROR: "stream_error";
+    /** Stream cancel */
+    readonly STREAM_CANCEL: "stream_cancel";
+};
+/**
+ * Default timeout configuration (milliseconds)
+ */
+export declare const DefaultTimeout: {
+    /** ACK confirmation timeout: 500ms (client waiting for server confirmation) */
+    readonly ACK: 500;
+    /** Request timeout: 5s */
+    readonly REQUEST: 5000;
+    /** Async request timeout: 120s */
+    readonly ASYNC: 120000;
+    /** Server waiting for client confirmation timeout: 5s (server waiting for client to confirm response received) */
+    readonly SERVER_ACK: 5000;
+};
+/**
+ * HTTP Header name constants
+ */
+export declare const HttpHeader: {
+    /** Set-Cookie (server sets cookie) */
+    readonly SET_COOKIE: "Set-Cookie";
+    /** Content-Type */
+    readonly CONTENT_TYPE: "Content-Type";
+    /** Content-Disposition (for file downloads) */
+    readonly CONTENT_DISPOSITION: "Content-Disposition";
+    /** Authorization */
+    readonly AUTHORIZATION: "Authorization";
+    /** Cookie (cookies carried in request) */
+    readonly COOKIE: "Cookie";
+};
+/**
+ * HTTP Header name type
+ */
+export type HttpHeaderValue = typeof HttpHeader[keyof typeof HttpHeader];
+/**
+ * Message type union type
+ */
+export type MessageTypeValue = typeof MessageType[keyof typeof MessageType];
+/**
+ * Error code union type
+ */
+export type ErrorCodeValue = typeof ErrorCode[keyof typeof ErrorCode];
+/**
+ * Stream type constants
+ */
+export declare const StreamType: {
+    /** Normal data stream */
+    readonly DATA: "data";
+    /** File stream */
+    readonly FILE: "file";
+};
+/**
+ * Stream internal message type constants (for stream internal message handling)
+ * Note: These are MessageType.STREAM_* values with the stream_ prefix removed
+ */
+export declare const StreamInternalMessageType: {
+    /** Data message */
+    readonly DATA: "data";
+    /** End message */
+    readonly END: "end";
+    /** Error message */
+    readonly ERROR: "error";
+    /** Cancel message */
+    readonly CANCEL: "cancel";
+};
+/**
+ * Stream internal message type value type
+ */
+export type StreamInternalMessageTypeValue = typeof StreamInternalMessageType[keyof typeof StreamInternalMessageType];
+/**
+ * Stream type value type
+ */
+export type StreamTypeValue = typeof StreamType[keyof typeof StreamType];
+/**
+ * Stream state constants
+ */
+export declare const StreamState: {
+    /** Pending */
+    readonly PENDING: "pending";
+    /** Streaming */
+    readonly STREAMING: "streaming";
+    /** Ended */
+    readonly ENDED: "ended";
+    /** Error */
+    readonly ERROR: "error";
+    /** Cancelled */
+    readonly CANCELLED: "cancelled";
+};
+/**
+ * Stream state value type
+ */
+export type StreamStateValue = typeof StreamState[keyof typeof StreamState];
+/**
+ * Message constants (for multi-language support)
+ */
+export { Messages, formatMessage, setMessages, resetMessages, getMessages } from './messages';
+export type { MessageKey } from './messages';
+//# sourceMappingURL=index.d.ts.map

package/library/constants/index.d.ts.map

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

package/library/constants/index.js

@@ -0,0 +1,260 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MessageType = exports.HttpStatusText = exports.HttpStatus = exports.HttpHeader = exports.ErrorCode = exports.DefaultTimeout = void 0;
+Object.defineProperty(exports, "Messages", {
+  enumerable: true,
+  get: function get() {
+    return _messages.Messages;
+  }
+});
+exports.StreamType = exports.StreamState = exports.StreamInternalMessageType = exports.ProtocolVersion = void 0;
+Object.defineProperty(exports, "formatMessage", {
+  enumerable: true,
+  get: function get() {
+    return _messages.formatMessage;
+  }
+});
+Object.defineProperty(exports, "getMessages", {
+  enumerable: true,
+  get: function get() {
+    return _messages.getMessages;
+  }
+});
+exports.getStatusText = getStatusText;
+Object.defineProperty(exports, "resetMessages", {
+  enumerable: true,
+  get: function get() {
+    return _messages.resetMessages;
+  }
+});
+Object.defineProperty(exports, "setMessages", {
+  enumerable: true,
+  get: function get() {
+    return _messages.setMessages;
+  }
+});
+var _messages = require("./messages");
+/**
+ * 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
+ */
+var ProtocolVersion = exports.ProtocolVersion = {
+  /** Current protocol version */
+  CURRENT: 1,
+  /** Minimum supported protocol version (messages below this version will be rejected) */
+  MIN_SUPPORTED: 1
+};
+
+/**
+ * Protocol version type
+ */
+
+/**
+ * Protocol validation result
+ */
+
+/**
+ * HTTP status code constants
+ */
+var HttpStatus = exports.HttpStatus = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503
+};
+
+/**
+ * HTTP status text constants
+ */
+var HttpStatusText = exports.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.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+  [HttpStatus.BAD_GATEWAY]: 'Bad Gateway',
+  [HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable'
+};
+
+/**
+ * Get status text
+ */
+function getStatusText(code) {
+  return HttpStatusText[code] || 'Unknown';
+}
+
+/**
+ * Error code constants
+ */
+var ErrorCode = exports.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'
+};
+
+/**
+ * Message type constants
+ */
+var MessageType = exports.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'
+};
+
+/**
+ * Default timeout configuration (milliseconds)
+ */
+var DefaultTimeout = exports.DefaultTimeout = {
+  /** ACK confirmation timeout: 500ms (client waiting for server confirmation) */
+  ACK: 500,
+  /** Request timeout: 5s */
+  REQUEST: 5000,
+  /** Async request timeout: 120s */
+  ASYNC: 120000,
+  /** Server waiting for client confirmation timeout: 5s (server waiting for client to confirm response received) */
+  SERVER_ACK: 5000
+};
+
+/**
+ * HTTP Header name constants
+ */
+var HttpHeader = exports.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
+ */
+var StreamType = exports.StreamType = {
+  /** Normal data stream */
+  DATA: 'data',
+  /** File stream */
+  FILE: 'file'
+};
+
+/**
+ * Stream internal message type constants (for stream internal message handling)
+ * Note: These are MessageType.STREAM_* values with the stream_ prefix removed
+ */
+var StreamInternalMessageType = exports.StreamInternalMessageType = {
+  /** Data message */
+  DATA: 'data',
+  /** End message */
+  END: 'end',
+  /** Error message */
+  ERROR: 'error',
+  /** Cancel message */
+  CANCEL: 'cancel'
+};
+
+/**
+ * Stream internal message type value type
+ */
+
+/**
+ * Stream type value type
+ */
+
+/**
+ * Stream state constants
+ */
+var StreamState = exports.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)
+ */

package/library/constants/messages.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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
+ */
+declare const defaultMessages: {
+    /** Protocol related errors */
+    readonly INVALID_PROTOCOL_VERSION_FORMAT: "Invalid protocol version format";
+    readonly PROTOCOL_VERSION_TOO_LOW: "Protocol version {0} is too low, minimum supported version is {1}";
+    readonly PROTOCOL_VERSION_UNSUPPORTED: "Protocol Version Unsupported";
+    /** Message format errors */
+    readonly INVALID_MESSAGE_FORMAT_NOT_OBJECT: "Invalid message format: not an object";
+    readonly INVALID_MESSAGE_FORMAT_MISSING_PROTOCOL: "Invalid message format: missing __requestIframe__ field";
+    readonly INVALID_MESSAGE_FORMAT_MISSING_TYPE: "Invalid message format: missing or invalid type field";
+    readonly INVALID_MESSAGE_FORMAT_MISSING_REQUEST_ID: "Invalid message format: missing or invalid requestId field";
+    /** Timeout errors */
+    readonly ACK_TIMEOUT: "ACK timeout after {0}ms";
+    readonly REQUEST_TIMEOUT: "Request timeout after {0}ms";
+    readonly ASYNC_REQUEST_TIMEOUT: "Async request timeout after {0}ms";
+    /** Request/response errors */
+    readonly REQUEST_FAILED: "Request failed";
+    readonly METHOD_NOT_FOUND: "Method not found";
+    readonly NO_RESPONSE_SENT: "Handler completed but no response sent";
+    readonly MIDDLEWARE_ERROR: "Middleware error";
+    readonly ERROR: "Error";
+    /** Client errors */
+    readonly IFRAME_NOT_READY: "iframe.contentWindow is not available";
+    /** Stream related messages */
+    readonly STREAM_NOT_BOUND: "Stream is not bound to a request context";
+    readonly STREAM_ALREADY_STARTED: "Stream has already started";
+    readonly STREAM_CANCELLED: "Stream was cancelled: {0}";
+    readonly STREAM_ERROR: "Stream error: {0}";
+    readonly STREAM_ENDED: "Stream has ended";
+    readonly STREAM_READ_ERROR: "Failed to read stream data";
+};
+/**
+ * Message type
+ */
+export type MessageKey = keyof typeof defaultMessages;
+/**
+ * Message constants object
+ */
+export declare const Messages: Readonly<Record<MessageKey, string>>;
+/**
+ * Set message content (for multi-language support)
+ * @param messages Custom message content (partial or full)
+ */
+export declare function setMessages(messages: Partial<Record<MessageKey, string>>): void;
+/**
+ * Reset to default messages
+ */
+export declare function resetMessages(): void;
+/**
+ * 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 declare function formatMessage(template: string, ...args: (string | number)[]): string;
+/**
+ * Get current message configuration
+ */
+export declare function getMessages(): Readonly<Record<MessageKey, string>>;
+export {};
+//# sourceMappingURL=messages.d.ts.map

package/library/constants/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/constants/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,QAAA,MAAM,eAAe;IACnB,8BAA8B;;;;IAK9B,4BAA4B;;;;;IAM5B,qBAAqB;;;;IAKrB,8BAA8B;;;;;;IAO9B,oBAAoB;;IAGpB,8BAA8B;;;;;;;CAOtB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,eAAe,CAAC;AAOtD;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAIxD,CAAC;AAEH;;;GAGG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAE/E;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM,CAKpF;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAElE"}

package/library/constants/messages.js

@@ -0,0 +1,123 @@
+"use strict";
+
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Messages = void 0;
+exports.formatMessage = formatMessage;
+exports.getMessages = getMessages;
+exports.resetMessages = resetMessages;
+exports.setMessages = setMessages;
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/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) { (0, _defineProperty2.default)(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',
+  /** Client errors */
+  IFRAME_NOT_READY: 'iframe.contentWindow is not available',
+  /** 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_ENDED: 'Stream has ended',
+  STREAM_READ_ERROR: 'Failed to read stream data'
+};
+
+/**
+ * Message type
+ */
+
+/**
+ * Current message configuration
+ */
+var currentMessages = _objectSpread({}, defaultMessages);
+
+/**
+ * Message constants object
+ */
+var Messages = exports.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)
+ */
+function setMessages(messages) {
+  currentMessages = _objectSpread(_objectSpread({}, defaultMessages), messages);
+}
+
+/**
+ * Reset to default messages
+ */
+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'
+ */
+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
+ */
+function getMessages() {
+  return _objectSpread({}, currentMessages);
+}