request-iframe 0.0.6 → 0.1.0

package/esm/index.js

@@ -0,0 +1,21 @@
+// API
+export { requestIframeClient, clearRequestIframeClientCache } from './api/client';
+export { requestIframeServer, clearRequestIframeServerCache } from './api/server';
+// Implementation classes
+export { RequestIframeClientImpl } from './core/client';
+export { RequestIframeServerImpl } from './core/server';
+export { RequestIframeClientServer } from './core/client-server';
+// MessageChannel and MessageDispatcher
+export { MessageChannel, ChannelType, MessageDispatcher } from './message';
+// Cache utilities
+export { getOrCreateMessageChannel, releaseMessageChannel, clearMessageChannelCache } from './utils/cache';
+export { ServerRequestImpl } from './core/request';
+export { ServerResponseImpl } from './core/response';
+// Stream
+export { IframeWritableStream, IframeReadableStream, IframeFileWritableStream, IframeFileReadableStream, isIframeReadableStream, isIframeFileReadableStream, isIframeFileWritableStream, isIframeWritableStream } from './stream';
+// Types and utilities
+export * from './types';
+export { detectContentType, blobToBase64, RequestIframeError } from './utils';
+export { InterceptorManager, RequestInterceptorManager, ResponseInterceptorManager } from './interceptors';
+// Constants
+export * from './constants';

package/esm/interceptors/index.js

@@ -0,0 +1,122 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+/**
+ * Interceptor manager
+ */
+export class InterceptorManager {
+  constructor() {
+    _defineProperty(this, "handlers", []);
+  }
+  /**
+   * Add interceptor
+   */
+  use(fulfilled, rejected) {
+    this.handlers.push({
+      fulfilled,
+      rejected
+    });
+    return this.handlers.length - 1;
+  }
+
+  /**
+   * Remove interceptor
+   */
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+
+  /**
+   * Clear all interceptors
+   */
+  clear() {
+    this.handlers.length = 0;
+  }
+
+  /**
+   * Iterate over all interceptors
+   */
+  forEach(fn) {
+    this.handlers.forEach(h => {
+      if (h !== null) {
+        fn(h);
+      }
+    });
+  }
+}
+
+/**
+ * Request interceptor manager
+ */
+export class RequestInterceptorManager extends InterceptorManager {}
+
+/**
+ * Response interceptor manager
+ */
+export class ResponseInterceptorManager extends InterceptorManager {}
+
+/**
+ * Execute request interceptor chain
+ */
+export function runRequestInterceptors(_x, _x2) {
+  return _runRequestInterceptors.apply(this, arguments);
+}
+
+/**
+ * Execute response interceptor chain
+ */
+function _runRequestInterceptors() {
+  _runRequestInterceptors = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(interceptors, config) {
+    var promise;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          promise = Promise.resolve(config);
+          interceptors.forEach(interceptor => {
+            promise = promise.then(config => interceptor.fulfilled(config), error => {
+              if (interceptor.rejected) {
+                return interceptor.rejected(error);
+              }
+              return Promise.reject(error);
+            });
+          });
+          return _context.abrupt("return", promise);
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _runRequestInterceptors.apply(this, arguments);
+}
+export function runResponseInterceptors(_x3, _x4) {
+  return _runResponseInterceptors.apply(this, arguments);
+}
+function _runResponseInterceptors() {
+  _runResponseInterceptors = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(interceptors, response) {
+    var promise;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          promise = Promise.resolve(response);
+          interceptors.forEach(interceptor => {
+            promise = promise.then(response => interceptor.fulfilled(response), error => {
+              if (interceptor.rejected) {
+                return interceptor.rejected(error);
+              }
+              return Promise.reject(error);
+            });
+          });
+          return _context2.abrupt("return", promise);
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _runResponseInterceptors.apply(this, arguments);
+}

package/esm/message/channel.js

@@ -0,0 +1,181 @@
+import _defineProperty from "@babel/runtime/helpers/esm/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) { _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.filter.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { isValidPostMessage, createPostMessage, isWindowAvailable } from '../utils';
+
+/**
+ * Message context (extracted from MessageEvent, transport-agnostic)
+ */
+
+/**
+ * Message receiver callback
+ */
+
+/**
+ * Channel type constants
+ */
+export var ChannelType = {
+  /** postMessage channel type */
+  POST_MESSAGE: 'postMessage'
+};
+
+/**
+ * Channel type
+ */
+
+/**
+ * MessageChannel - Low-level communication channel for postMessage
+ * 
+ * Responsibilities:
+ * - Listening to window.postMessage events
+ * - Filtering messages by secretKey
+ * - Extracting transport-specific information (MessageEvent) into generic MessageContext
+ * - Forwarding received messages to registered receivers
+ * - Sending messages to target windows
+ * 
+ * This is the low-level communication layer that handles postMessage directly.
+ * All transport-specific details (like MessageEvent) are encapsulated here.
+ */
+export class MessageChannel {
+  constructor(secretKey, type = ChannelType.POST_MESSAGE) {
+    /** Channel type (used for cache isolation) */
+    /** Secret key for message isolation */
+    /** Message receiver callbacks (support multiple receivers) */
+    _defineProperty(this, "receivers", new Set());
+    /** Reference count (for cache management) */
+    _defineProperty(this, "refCount", 0);
+    this.type = type;
+    this.secretKey = secretKey;
+    this.boundOnMessage = this.onMessage.bind(this);
+    window.addEventListener('message', this.boundOnMessage);
+  }
+
+  /**
+   * Add message receiver callback
+   * When a message is received, it will be forwarded to all registered receivers
+   */
+  addReceiver(receiver) {
+    this.receivers.add(receiver);
+  }
+
+  /**
+   * Remove message receiver callback
+   */
+  removeReceiver(receiver) {
+    this.receivers.delete(receiver);
+  }
+
+  /**
+   * Increment reference count (for cache management)
+   */
+  addRef() {
+    this.refCount++;
+  }
+
+  /**
+   * Decrement reference count (for cache management)
+   * @returns current reference count
+   */
+  release() {
+    return --this.refCount;
+  }
+
+  /**
+   * Get reference count (for cache management)
+   */
+  getRefCount() {
+    return this.refCount;
+  }
+
+  /**
+   * Extract MessageContext from MessageEvent
+   * This encapsulates transport-specific details
+   */
+  extractContext(event) {
+    return {
+      source: event.source,
+      origin: event.origin
+    };
+  }
+
+  /**
+   * Message handling entry point
+   */
+  onMessage(event) {
+    var data = event.data;
+
+    // Check if this is a request-iframe framework message (basic format validation)
+    if (!isValidPostMessage(data)) {
+      return;
+    }
+
+    // secretKey isolation
+    if (this.secretKey) {
+      if (data.secretKey !== this.secretKey) return;
+    } else {
+      if (data.secretKey) return;
+    }
+
+    // Extract context from transport-specific event
+    var context = this.extractContext(event);
+
+    // Forward to all registered receivers
+    this.receivers.forEach(receiver => {
+      try {
+        receiver(data, context);
+      } catch (e) {
+        console.error('[request-iframe] Receiver error:', e);
+      }
+    });
+  }
+
+  /**
+   * Send raw message to target window
+   * @param target target window
+   * @param message message data (already formatted as PostMessageData)
+   * @param targetOrigin target origin (defaults to '*')
+   */
+  send(target, message, targetOrigin = '*') {
+    if (!isWindowAvailable(target)) {
+      return false;
+    }
+    target.postMessage(message, targetOrigin);
+    return true;
+  }
+
+  /**
+   * Send typed message to target window (creates PostMessageData automatically)
+   * @param target target window
+   * @param targetOrigin target origin
+   * @param type message type
+   * @param requestId request ID
+   * @param data additional data
+   */
+  sendMessage(target, targetOrigin, type, requestId, data) {
+    var message = createPostMessage(type, requestId, _objectSpread(_objectSpread({}, data), {}, {
+      secretKey: this.secretKey
+    }));
+    return this.send(target, message, targetOrigin);
+  }
+
+  /**
+   * Add path prefix (for secretKey isolation)
+   */
+  prefixPath(path) {
+    return this.secretKey ? `${this.secretKey}:${path}` : path;
+  }
+
+  /**
+   * Destroy channel (remove event listener)
+   */
+  destroy() {
+    window.removeEventListener('message', this.boundOnMessage);
+    this.receivers.clear();
+  }
+}

package/esm/message/dispatcher.js

@@ -0,0 +1,380 @@
+import _defineProperty from "@babel/runtime/helpers/esm/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) { _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; }
+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; }
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.sort.js";
+import "core-js/modules/es.array.splice.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.regexp.constructor.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.regexp.to-string.js";
+import { MessageRole, MessageType } from '../constants';
+import { getProtocolVersion, createPostMessage } from '../utils';
+
+/**
+ * Message handler function type
+ */
+
+/**
+ * Message type matcher
+ * - string: exact match message type
+ * - RegExp: regex match message type
+ * - function: custom match function
+ */
+
+/**
+ * Protocol version validator function
+ * @param version protocol version in message
+ * @returns true if version is compatible, false otherwise
+ */
+
+/**
+ * Message handler registration options
+ */
+
+/**
+ * Message handler entry
+ */
+
+/**
+ * MessageDispatcher - Message dispatcher for client/server interaction
+ * 
+ * Responsibilities:
+ * - Using MessageChannel for receiving and sending messages
+ * - Dispatching received messages to registered handlers
+ * - Managing handler registration/unregistration
+ * - Protocol version validation
+ * 
+ * This is the high-level interface used by client and server implementations.
+ * It works with transport-agnostic MessageContext instead of transport-specific MessageEvent.
+ */
+export class MessageDispatcher {
+  constructor(channel, role, instanceId) {
+    /** Secret key for message isolation */
+    /** Channel type */
+    /** Role of this dispatcher ('client' or 'server') */
+    /** Instance ID of the client/server that owns this dispatcher */
+    /** Underlying message channel */
+    /**
+     * Fallback target for sending auto-ack messages when MessageEvent.source is unavailable.
+     * - In real browser postMessage events, `source` should normally exist.
+     * - This is primarily used for unit tests or edge environments that synthesize MessageEvent without `source`.
+     */
+    _defineProperty(this, "fallbackTargetOrigin", '*');
+    /** Message handler list */
+    _defineProperty(this, "handlers", []);
+    /** Reference count (for determining if can be destroyed when cached) */
+    _defineProperty(this, "refCount", 0);
+    this.channel = channel;
+    this.secretKey = channel.secretKey;
+    this.type = channel.type;
+    this.role = role;
+    this.instanceId = instanceId;
+
+    // Create bound receiver callback
+    this.boundReceiver = (data, context) => {
+      this.dispatchMessage(data, context);
+    };
+
+    // Add receiver callback to handle incoming messages
+    this.channel.addReceiver(this.boundReceiver);
+  }
+
+  /**
+   * Set fallback target for outgoing auto-ack messages.
+   */
+  setFallbackTarget(targetWindow, targetOrigin = '*') {
+    this.fallbackTargetWindow = targetWindow;
+    this.fallbackTargetOrigin = targetOrigin;
+  }
+
+  // ==================== Reference Counting ====================
+
+  /**
+   * Increment reference count
+   */
+  addRef() {
+    this.refCount++;
+  }
+
+  /**
+   * Decrement reference count
+   * @returns current reference count
+   */
+  release() {
+    return --this.refCount;
+  }
+
+  /**
+   * Get reference count
+   */
+  getRefCount() {
+    return this.refCount;
+  }
+
+  // ==================== Message Handling ====================
+
+  /**
+   * Register message handler
+   * @param matcher message type matcher
+   * @param handler handler function
+   * @param options registration options (priority, version validation, etc.)
+   * @returns function to unregister
+   */
+  registerHandler(matcher, handler, options) {
+    var _opts$priority;
+    var opts = typeof options === 'number' ? {
+      priority: options
+    } : options || {};
+    var entry = {
+      matcher,
+      handler,
+      priority: (_opts$priority = opts.priority) !== null && _opts$priority !== void 0 ? _opts$priority : 0,
+      versionValidator: opts.versionValidator,
+      onVersionError: opts.onVersionError
+    };
+    this.handlers.push(entry);
+    // Sort by priority in descending order
+    this.handlers.sort((a, b) => b.priority - a.priority);
+    return () => {
+      var index = this.handlers.indexOf(entry);
+      if (index >= 0) {
+        this.handlers.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Unregister message handler
+   */
+  unregisterHandler(handler) {
+    var index = this.handlers.findIndex(entry => entry.handler === handler);
+    if (index >= 0) {
+      this.handlers.splice(index, 1);
+    }
+  }
+
+  /**
+   * Dispatch message to matching handlers
+   */
+  dispatchMessage(data, context) {
+    // If message has already been handled by another dispatcher, skip processing
+    if (context.handledBy) {
+      return;
+    }
+
+    // Role-based message filtering: only process messages from the opposite role
+    // - Server only processes messages from client (role === 'client')
+    // - Client only processes messages from server (role === 'server')
+    if (data.role !== undefined) {
+      var expectedRole = this.role === MessageRole.CLIENT ? MessageRole.SERVER : MessageRole.CLIENT;
+      if (data.role !== expectedRole) {
+        // Message is from the same role, ignore it to prevent routing confusion
+        return;
+      }
+    }
+    var type = data.type;
+    var version = getProtocolVersion(data);
+
+    /**
+     * Auto-ack state for this incoming message.
+     * - We intentionally couple this to `context.handledBy` as the "accepted/handled" signal.
+     * - For some message types we only ack if they are truly handled (e.g. response requireAck),
+     *   so we avoid incorrectly acknowledging messages when there is no pending consumer.
+     *
+     * Implementation note:
+     * We avoid using Proxy for compatibility and instead hook the `handledBy` property
+     * with a setter so handlers can trigger the ack immediately when they "accept" a message.
+     */
+    var autoAckState = {
+      sent: false
+    };
+    var originalHandledBy = context.handledBy;
+    var handledByValue = originalHandledBy;
+    try {
+      Object.defineProperty(context, 'handledBy', {
+        configurable: true,
+        enumerable: true,
+        get() {
+          return handledByValue;
+        },
+        set: value => {
+          handledByValue = value;
+          if (value && !autoAckState.sent) {
+            autoAckState.sent = true;
+            this.tryAutoAck(data, context);
+          }
+        }
+      });
+    } catch (_unused) {
+      /**
+       * In very rare cases `defineProperty` may fail (frozen object).
+       * We still proceed without auto-ack; handlers will continue to work as before.
+       */
+    }
+    var _iterator = _createForOfIteratorHelper(this.handlers),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        if (this.matchType(type, entry.matcher)) {
+          // If message has been handled by a previous handler, stop processing
+          if (context.handledBy) {
+            break;
+          }
+
+          // If handler specified version validation
+          if (entry.versionValidator && version !== undefined) {
+            if (!entry.versionValidator(version)) {
+              var _entry$onVersionError;
+              // Version incompatible, call error handler (if any)
+              (_entry$onVersionError = entry.onVersionError) === null || _entry$onVersionError === void 0 || _entry$onVersionError.call(entry, data, context, version);
+              continue; // Skip this handler, try other handlers
+            }
+          }
+          try {
+            entry.handler(data, context);
+            // After handler execution, check if it marked the message as handled
+            // If context.handledBy is set by the handler, subsequent handlers will be skipped
+          } catch (e) {
+            // Ignore handler exception, continue executing other handlers
+            console.error('[request-iframe] Handler error:', e);
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  /**
+   * Auto-ack logic (generalized requireAck workflow)
+   *
+   * Notes:
+   * - This is intentionally conservative: it only runs after the message is marked as handled
+   *   (via `context.handledBy`) to avoid acknowledging messages that no consumer will process.
+   * - For backward compatibility:
+   *   - REQUEST defaults to requiring ACK unless `requireAck === false`
+   *   - Other message types only ack when `requireAck === true`
+   */
+  tryAutoAck(data, context) {
+    var _context$source;
+    var targetWindow = (_context$source = context.source) !== null && _context$source !== void 0 ? _context$source : this.fallbackTargetWindow;
+    if (!targetWindow) return;
+    var targetOrigin = context.source ? context.origin : this.fallbackTargetOrigin || context.origin;
+    var type = data.type;
+
+    // Don't auto-ack ack messages (avoid loops)
+    if (type === MessageType.ACK || type === MessageType.RECEIVED) return;
+    var shouldAckRequest = type === MessageType.REQUEST && data.requireAck !== false;
+    var shouldAckPing = type === MessageType.PING && data.requireAck === true;
+    var shouldAckResponse = (type === MessageType.RESPONSE || type === MessageType.ERROR) && data.requireAck === true;
+    if ((shouldAckRequest || shouldAckPing) && context.accepted === true) {
+      // Delivery acknowledgment for request/ping
+      this.sendMessage(targetWindow, targetOrigin, MessageType.ACK, data.requestId, {
+        path: data.path,
+        targetId: data.creatorId,
+        ackMeta: data.ackMeta
+      });
+      return;
+    }
+    if (shouldAckResponse && context.accepted === true) {
+      // Receipt acknowledgment for response/error
+      this.sendMessage(targetWindow, targetOrigin, MessageType.RECEIVED, data.requestId, {
+        path: data.path,
+        targetId: data.creatorId,
+        ackMeta: data.ackMeta
+      });
+    }
+  }
+
+  /**
+   * Check if message type matches
+   */
+  matchType(type, matcher) {
+    if (typeof matcher === 'string') {
+      return type === matcher;
+    }
+    if (matcher instanceof RegExp) {
+      return matcher.test(type);
+    }
+    if (typeof matcher === 'function') {
+      return matcher(type);
+    }
+    return false;
+  }
+
+  // ==================== Sending (Delegated to Channel) ====================
+
+  /**
+   * Send raw message to target window
+   * @param target target window
+   * @param message message data (already formatted as PostMessageData)
+   * @param targetOrigin target origin (defaults to '*')
+   */
+  send(target, message, targetOrigin = '*') {
+    // Automatically set role and creatorId if not already set (for backward compatibility)
+    if (message.role === undefined) {
+      message.role = this.role;
+    }
+    if (message.creatorId === undefined && this.instanceId) {
+      message.creatorId = this.instanceId;
+    }
+    return this.channel.send(target, message, targetOrigin);
+  }
+
+  /**
+   * Send typed message to target window (creates PostMessageData automatically)
+   * @param target target window
+   * @param targetOrigin target origin
+   * @param type message type
+   * @param requestId request ID
+   * @param data additional data
+   */
+  sendMessage(target, targetOrigin, type, requestId, data) {
+    // Automatically set role, creatorId, and secretKey based on dispatcher's properties
+    // Create message with role, creatorId, and secretKey using createPostMessage directly
+    var message = createPostMessage(type, requestId, _objectSpread(_objectSpread({}, data), {}, {
+      role: this.role,
+      creatorId: this.instanceId,
+      secretKey: this.secretKey
+    }));
+    return this.channel.send(target, message, targetOrigin);
+  }
+
+  // ==================== Utilities ====================
+
+  /**
+   * Add path prefix
+   */
+  prefixPath(path) {
+    return this.channel.prefixPath(path);
+  }
+
+  /**
+   * Get the underlying message channel
+   */
+  getChannel() {
+    return this.channel;
+  }
+
+  /**
+   * Destroy dispatcher (clear handlers, but don't destroy channel as it may be shared)
+   */
+  destroy() {
+    this.handlers.length = 0;
+    this.channel.removeReceiver(this.boundReceiver);
+  }
+}