@metamask-previews/messenger 0.0.0-preview-2fd8e984 → 0.0.0-preview-343f3d69

package/CHANGELOG.md

@@ -10,11 +10,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Migrate `Messenger` class from `@metamask/base-controller` package ([#6127](https://github.com/MetaMask/core/pull/6127))
+- Add `delegate` and `revoke` methods ([#6132](https://github.com/MetaMask/core/pull/6132))
+  - These allow delegating or revoking capabilities (actions or events) from one `Messenger` instance to another.
+  - This allows passing capabilities through chains of messengers of arbitrary length
+  - See this ADR for details: https://github.com/MetaMask/decisions/blob/main/decisions/core/0012-messenger-delegation.md
 
 ### Changed
 
+- **BREAKING:** Add `Namespace` type parameter and required `namespace` constructor parameter ([#6132](https://github.com/MetaMask/core/pull/6132))
+  - All published events and registered actions should fall under the given namespace. Typically the namespace is the controller or service name. This is the equivalent to the `Namespace` parameter from the old `RestrictedMessenger` class.
+- **BREAKING:** The `type` property of `ActionConstraint` and `EventConstraint` is now a `NamespacedName` rather than a string ([#6132](https://github.com/MetaMask/core/pull/6132))
 - Add default for `ReturnHandler` type parameter of `SelectorEventHandler` and `SelectorFunction` ([#6262](https://github.com/MetaMask/core/pull/6262), [#6264](https://github.com/MetaMask/core/pull/6264))
 
+### Removed
+
+- **BREAKING:** Remove `RestrictedMessenger` class ([#6132](https://github.com/MetaMask/core/pull/6132))
+  - Existing `RestrictedMessenger` instances should be replaced with a `Messenger`. We can now use the same class everywhere, passing capabilities using `delegate`.
+  - See this ADR for details: https://github.com/MetaMask/decisions/blob/main/decisions/core/0012-messenger-delegation.md
+
 ### Fixed
 
 - Update `unsubscribe` type signature to support selector event handlers ([#6262](https://github.com/MetaMask/core/pull/6262))

package/dist/Messenger.cjs

@@ -1,27 +1,50 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Messenger_actions, _Messenger_events, _Messenger_initialEventPayloadGetters, _Messenger_eventPayloadCache;
+var _Messenger_instances, _Messenger_namespace, _Messenger_actions, _Messenger_events, _Messenger_subscriptionDelegationTargets, _Messenger_actionDelegationTargets, _Messenger_initialEventPayloadGetters, _Messenger_eventPayloadCache, _Messenger_registerActionHandler, _Messenger_unregisterActionHandler, _Messenger_registerInitialEventPayload, _Messenger_publish, _Messenger_subscribe, _Messenger_isInCurrentNamespace;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Messenger = void 0;
-const RestrictedMessenger_1 = require("./RestrictedMessenger.cjs");
 /**
  * A message broker for "actions" and "events".
  *
  * The messenger allows registering functions as 'actions' that can be called elsewhere,
  * and it allows publishing and subscribing to events. Both actions and events are identified by
- * unique strings.
+ * unique strings prefixed by a namespace (which is delimited by a colon, e.g.
+ * `Namespace:actionName`).
  *
  * @template Action - A type union of all Action types.
  * @template Event - A type union of all Event types.
+ * @template Namespace - The namespace for the messenger.
  */
 class Messenger {
-    constructor() {
+    /**
+     * Construct a messenger.
+     *
+     * @param args - Constructor arguments
+     * @param args.namespace - The messenger namespace.
+     */
+    constructor({ namespace }) {
+        _Messenger_instances.add(this);
+        _Messenger_namespace.set(this, void 0);
         _Messenger_actions.set(this, new Map());
         _Messenger_events.set(this, new Map());
+        /**
+         * The set of messengers we've delegated events to and their event handlers, by event type.
+         */
+        _Messenger_subscriptionDelegationTargets.set(this, new Map());
+        /**
+         * The set of messengers we've delegated actions to, by action type.
+         */
+        _Messenger_actionDelegationTargets.set(this, new Map());
         /**
          * A map of functions for getting the initial event payload.
          *
@@ -32,23 +55,27 @@ class Messenger {
          * A cache of selector return values for their respective handlers.
          */
         _Messenger_eventPayloadCache.set(this, new Map());
+        __classPrivateFieldSet(this, _Messenger_namespace, namespace, "f");
     }
     /**
      * Register an action handler.
      *
      * This will make the registered function available to call via the `call` method.
      *
+     * The action being registered must be under the same namespace as the messenger.
+     *
      * @param actionType - The action type. This is a unique identifier for this action.
      * @param handler - The action handler. This function gets called when the `call` method is
      * invoked with the given action type.
      * @throws Will throw when a handler has been registered for this action type already.
-     * @template ActionType - A type union of Action type strings.
+     * @template ActionType - A type union of Action type strings under this messenger's namespace.
      */
     registerActionHandler(actionType, handler) {
-        if (__classPrivateFieldGet(this, _Messenger_actions, "f").has(actionType)) {
-            throw new Error(`A handler for ${actionType} has already been registered`);
+        /* istanbul ignore if */ // Branch unreachable with valid types
+        if (!__classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_isInCurrentNamespace).call(this, actionType)) {
+            throw new Error(`Only allowed registering action handlers prefixed by '${__classPrivateFieldGet(this, _Messenger_namespace, "f")}:'`);
         }
-        __classPrivateFieldGet(this, _Messenger_actions, "f").set(actionType, handler);
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_registerActionHandler).call(this, actionType, handler);
     }
     /**
      * Registers action handlers for a list of methods on a messenger client
@@ -73,11 +100,17 @@ class Messenger {
      *
      * This will prevent this action from being called.
      *
+     * The action being unregistered must be under the same namespace as the messenger.
+     *
      * @param actionType - The action type. This is a unique identifier for this action.
-     * @template ActionType - A type union of Action type strings.
+     * @template ActionType - A type union of Action type strings under this messenger's namespace.
      */
     unregisterActionHandler(actionType) {
-        __classPrivateFieldGet(this, _Messenger_actions, "f").delete(actionType);
+        /* istanbul ignore if */ // Branch unreachable with valid types
+        if (!__classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_isInCurrentNamespace).call(this, actionType)) {
+            throw new Error(`Only allowed unregistering action handlers prefixed by '${__classPrivateFieldGet(this, _Messenger_namespace, "f")}:'`);
+        }
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_unregisterActionHandler).call(this, actionType);
     }
     /**
      * Unregister all action handlers.
@@ -85,7 +118,9 @@ class Messenger {
      * This prevents all actions from being called.
      */
     clearActions() {
-        __classPrivateFieldGet(this, _Messenger_actions, "f").clear();
+        for (const actionType of __classPrivateFieldGet(this, _Messenger_actions, "f").keys()) {
+            __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_unregisterActionHandler).call(this, actionType);
+        }
     }
     /**
      * Call an action.
@@ -114,13 +149,19 @@ class Messenger {
      * Registering a function for getting the payload allows event selectors to have a point of
      * comparison the first time state changes.
      *
+     * The event type must be under the same namespace as the messenger.
+     *
      * @param args - The arguments to this function
      * @param args.eventType - The event type to register a payload for.
      * @param args.getPayload - A function for retrieving the event payload.
-     * @template EventType - A type union of Event type strings.
+     * @template EventType - A type union of Event type strings under this messenger's namespace.
      */
     registerInitialEventPayload({ eventType, getPayload, }) {
-        __classPrivateFieldGet(this, _Messenger_initialEventPayloadGetters, "f").set(eventType, getPayload);
+        /* istanbul ignore if */ // Branch unreachable with valid types
+        if (!__classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_isInCurrentNamespace).call(this, eventType)) {
+            throw new Error(`Only allowed registering initial payloads for events prefixed by '${__classPrivateFieldGet(this, _Messenger_namespace, "f")}:'`);
+        }
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_registerInitialEventPayload).call(this, { eventType, getPayload });
     }
     /**
      * Publish an event.
@@ -130,48 +171,25 @@ class Messenger {
      * Note that this method should never throw directly. Any errors from
      * subscribers are captured and re-thrown in a timeout handler.
      *
+     * The event being published must be under the same namespace as the messenger.
+     *
      * @param eventType - The event type. This is a unique identifier for this event.
      * @param payload - The event payload. The type of the parameters for each event handler must
      * match the type of this payload.
-     * @template EventType - A type union of Event type strings.
+     * @template EventType - A type union of Event type strings under this messenger's namespace.
      */
     publish(eventType, ...payload) {
-        const subscribers = __classPrivateFieldGet(this, _Messenger_events, "f").get(eventType);
-        if (subscribers) {
-            for (const [handler, { selector }] of subscribers.entries()) {
-                try {
-                    if (selector) {
-                        const previousValue = __classPrivateFieldGet(this, _Messenger_eventPayloadCache, "f").get(handler);
-                        const newValue = selector(...payload);
-                        if (newValue !== previousValue) {
-                            __classPrivateFieldGet(this, _Messenger_eventPayloadCache, "f").set(handler, newValue);
-                            handler(newValue, previousValue);
-                        }
-                    }
-                    else {
-                        handler(...payload);
-                    }
-                }
-                catch (error) {
-                    // Throw error after timeout so that it is capured as a console error
-                    // (and by Sentry) without interrupting the event publishing.
-                    setTimeout(() => {
-                        throw error;
-                    });
-                }
-            }
+        /* istanbul ignore if */ // Branch unreachable with valid types
+        if (!__classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_isInCurrentNamespace).call(this, eventType)) {
+            throw new Error(`Only allowed publishing events prefixed by '${__classPrivateFieldGet(this, _Messenger_namespace, "f")}:'`);
         }
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_publish).call(this, eventType, ...payload);
     }
     subscribe(eventType, handler, selector) {
-        let subscribers = __classPrivateFieldGet(this, _Messenger_events, "f").get(eventType);
-        if (!subscribers) {
-            subscribers = new Map();
-            __classPrivateFieldGet(this, _Messenger_events, "f").set(eventType, subscribers);
-        }
         // Widen type of event handler by dropping ReturnType parameter.
         //
         // We need to drop it here because it's used as the parameter to the event handler, and
-        // functions in general are contravarient over the parameter type. This means the type is no
+        // functions in general are contravariant over the parameter type. This means the type is no
         // longer valid once it's added to a broader type union with other handlers (because as far
         // as TypeScript knows, we might call the handler with output from a different selector).
         //
@@ -180,7 +198,7 @@ class Messenger {
         // called, but past that point we need to make sure of that with manual review and tests
         // instead.
         const widenedHandler = handler;
-        subscribers.set(widenedHandler, { selector });
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_subscribe).call(this, eventType, widenedHandler, { delegation: false, selector });
         if (selector) {
             const getPayload = __classPrivateFieldGet(this, _Messenger_initialEventPayloadGetters, "f").get(eventType);
             if (getPayload) {
@@ -205,17 +223,20 @@ class Messenger {
         // Widen type of event handler by dropping ReturnType parameter.
         //
         // We need to drop it here because it's used as the parameter to the event handler, and
-        // functions in general are contravarient over the parameter type. This means the type is no
+        // functions in general are contravariant over the parameter type. This means the type is no
         // longer valid once it's added to a broader type union with other handlers (because as far
         // as TypeScript knows, we might call the handler with output from a different selector).
         //
         // This poses no risk in this case, since we never call the handler past this point.
         const widenedHandler = handler;
-        if (!subscribers || !subscribers.has(widenedHandler)) {
+        if (!subscribers) {
             throw new Error(`Subscription not found for event: ${eventType}`);
         }
         const metadata = subscribers.get(widenedHandler);
-        if (metadata?.selector) {
+        if (!metadata) {
+            throw new Error(`Subscription not found for event: ${eventType}`);
+        }
+        if (metadata.selector) {
             __classPrivateFieldGet(this, _Messenger_eventPayloadCache, "f").delete(widenedHandler);
         }
         subscribers.delete(widenedHandler);
@@ -223,57 +244,295 @@ class Messenger {
     /**
      * Clear subscriptions for a specific event.
      *
-     * This will remove all subscribed handlers for this event.
+     * This will remove all subscribed handlers for this event registered from this messenger. The
+     * event may still have subscribers if it has been delegated to another messenger.
      *
      * @param eventType - The event type. This is a unique identifier for this event.
      * @template EventType - A type union of Event type strings.
      */
     clearEventSubscriptions(eventType) {
-        __classPrivateFieldGet(this, _Messenger_events, "f").delete(eventType);
+        const subscriptions = __classPrivateFieldGet(this, _Messenger_events, "f").get(eventType);
+        if (!subscriptions) {
+            return;
+        }
+        for (const [handler, metadata] of subscriptions.entries()) {
+            if (metadata.delegation) {
+                continue;
+            }
+            subscriptions.delete(handler);
+        }
+        if (subscriptions.size === 0) {
+            __classPrivateFieldGet(this, _Messenger_events, "f").delete(eventType);
+        }
     }
     /**
      * Clear all subscriptions.
      *
-     * This will remove all subscribed handlers for all events.
+     * This will remove all subscribed handlers for all events registered from this messenger. Events
+     * may still have subscribers if they are delegated to another messenger.
      */
     clearSubscriptions() {
-        __classPrivateFieldGet(this, _Messenger_events, "f").clear();
+        for (const eventType of __classPrivateFieldGet(this, _Messenger_events, "f").keys()) {
+            this.clearEventSubscriptions(eventType);
+        }
     }
     /**
-     * Get a restricted messenger
-     *
-     * Returns a wrapper around the messenger instance that restricts access to actions and events.
-     * The provided allowlists grant the ability to call the listed actions and subscribe to the
-     * listed events. The "name" provided grants ownership of any actions and events under that
-     * namespace. Ownership allows registering actions and publishing events, as well as
-     * unregistering actions and clearing event subscriptions.
-     *
-     * @param options - Messenger options.
-     * @param options.name - The name of the thing this messenger will be handed to (e.g. the
-     * controller name). This grants "ownership" of actions and events under this namespace to the
-     * restricted messenger returned.
-     * @param options.allowedActions - The list of actions that this restricted messenger should be
-     * allowed to call.
-     * @param options.allowedEvents - The list of events that this restricted messenger should be
-     * allowed to subscribe to.
-     * @template Namespace - The namespace for this messenger. Typically this is the name of the
-     * module that this messenger has been created for. The authority to publish events and register
-     * actions under this namespace is granted to this restricted messenger instance.
-     * @template AllowedAction - A type union of the 'type' string for any allowed actions.
-     * This must not include internal actions that are in the messenger's namespace.
-     * @template AllowedEvent - A type union of the 'type' string for any allowed events.
-     * This must not include internal events that are in the messenger's namespace.
-     * @returns The restricted messenger.
+     * Delegate actions and/or events to another messenger.
+     *
+     * The messenger these actions/events are delegated to will be able to call these actions and
+     * subscribe to these events.
+     *
+     * Note that the messenger these actions/events are delegated to must still have these
+     * actions/events included in its type definition (as part of the Action and Event type
+     * parameters). Actions and events are statically type checked, they cannot be delegated
+     * dynamically at runtime.
+     *
+     * @param args - Arguments.
+     * @param args.actions - The action types to delegate.
+     * @param args.events - The event types to delegate.
+     * @param args.messenger - The messenger to delegate to.
+     * @template Delegatee - The messenger the actions/events are delegated to.
+     * @template DelegatedActions - An array of delegated action types.
+     * @template DelegatedEvents - An array of delegated event types.
      */
-    getRestricted({ name, allowedActions, allowedEvents, }) {
-        return new RestrictedMessenger_1.RestrictedMessenger({
-            messenger: this,
-            name,
-            allowedActions,
-            allowedEvents,
-        });
+    delegate({ actions, events, messenger, }) {
+        for (const actionType of actions || []) {
+            const delegatedActionHandler = (...args) => {
+                // Cast to get more specific type, for this specific action
+                // The types get collapsed by `this.#actions`
+                const actionHandler = __classPrivateFieldGet(this, _Messenger_actions, "f").get(actionType);
+                if (!actionHandler) {
+                    throw new Error(`Cannot call '${actionType}', action not registered.`);
+                }
+                return actionHandler(...args);
+            };
+            let delegationTargets = __classPrivateFieldGet(this, _Messenger_actionDelegationTargets, "f").get(actionType);
+            if (!delegationTargets) {
+                delegationTargets = new Set();
+                __classPrivateFieldGet(this, _Messenger_actionDelegationTargets, "f").set(actionType, delegationTargets);
+            }
+            if (delegationTargets.has(messenger)) {
+                throw new Error(`The action '${actionType}' has already been delegated to this messenger`);
+            }
+            delegationTargets.add(messenger);
+            messenger._internalRegisterDelegatedActionHandler(actionType, delegatedActionHandler);
+        }
+        for (const eventType of events || []) {
+            const untypedSubscriber = (...payload) => {
+                messenger._internalPublishDelegated(eventType, ...payload);
+            };
+            // Cast to get more specific subscriber type for this specific event.
+            // The types get collapsed here to the type union of all delegated
+            // events, rather than the single subscriber type corresponding to this
+            // event.
+            const subscriber = untypedSubscriber;
+            let delegatedEventSubscriptions = __classPrivateFieldGet(this, _Messenger_subscriptionDelegationTargets, "f").get(eventType);
+            if (!delegatedEventSubscriptions) {
+                delegatedEventSubscriptions = new Map();
+                __classPrivateFieldGet(this, _Messenger_subscriptionDelegationTargets, "f").set(eventType, delegatedEventSubscriptions);
+            }
+            if (delegatedEventSubscriptions.has(messenger)) {
+                throw new Error(`The event '${eventType}' has already been delegated to this messenger`);
+            }
+            delegatedEventSubscriptions.set(messenger, subscriber);
+            const getPayload = __classPrivateFieldGet(this, _Messenger_initialEventPayloadGetters, "f").get(eventType);
+            if (getPayload) {
+                messenger._internalRegisterDelegatedInitialEventPayload({
+                    eventType,
+                    getPayload,
+                });
+            }
+            __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_subscribe).call(this, eventType, subscriber, { delegation: true });
+        }
+    }
+    /**
+     * Revoke delegated actions and/or events from another messenger.
+     *
+     * The messenger these actions/events are delegated to will no longer be able to call these
+     * actions or subscribe to these events.
+     *
+     * @param args - Arguments.
+     * @param args.actions - The action types to revoke.
+     * @param args.events - The event types to revoke.
+     * @param args.messenger - The messenger these actions/events were delegated to.
+     * @template Delegatee - The messenger the actions/events are being revoked from.
+     * @template DelegatedActions - An array of delegated action types.
+     * @template DelegatedEvents - An array of delegated event types.
+     */
+    revoke({ actions, events, messenger, }) {
+        for (const actionType of actions || []) {
+            const delegationTargets = __classPrivateFieldGet(this, _Messenger_actionDelegationTargets, "f").get(actionType);
+            if (!delegationTargets || !delegationTargets.has(messenger)) {
+                // Nothing to revoke
+                continue;
+            }
+            messenger._internalUnregisterDelegatedActionHandler(actionType);
+            delegationTargets.delete(messenger);
+            if (delegationTargets.size === 0) {
+                __classPrivateFieldGet(this, _Messenger_actionDelegationTargets, "f").delete(actionType);
+            }
+        }
+        for (const eventType of events || []) {
+            const delegationTargets = __classPrivateFieldGet(this, _Messenger_subscriptionDelegationTargets, "f").get(eventType);
+            if (!delegationTargets) {
+                // Nothing to revoke
+                continue;
+            }
+            const delegatedSubscriber = delegationTargets.get(messenger);
+            if (!delegatedSubscriber) {
+                // Nothing to revoke
+                continue;
+            }
+            this.unsubscribe(eventType, delegatedSubscriber);
+            delegationTargets.delete(messenger);
+            if (delegationTargets.size === 0) {
+                __classPrivateFieldGet(this, _Messenger_subscriptionDelegationTargets, "f").delete(eventType);
+            }
+        }
+    }
+    /**
+     * Register an action handler for an action delegated from another messenger.
+     *
+     * This will make the registered function available to call via the `call` method.
+     *
+     * Note: This is an internal method. Never access this property from another module. This must be
+     * exposed as a public property so that these methods can be called internally on other messenger
+     * instances.
+     *
+     * @deprecated Internal use only. Use the `delegate` method for delegation.
+     * @param actionType - The action type. This is a unique identifier for this action.
+     * @param handler - The action handler. This function gets called when the `call` method is
+     * invoked with the given action type.
+     * @throws Will throw when a handler has been registered for this action type already.
+     * @template ActionType - A type union of Action type strings.
+     */
+    _internalRegisterDelegatedActionHandler(actionType, 
+    // Using wider `ActionConstraint` type here rather than `Action` because the `Action` type is
+    // contravariant over the handler parameter type. Using `Action` would lead to a type error
+    // here because the messenger we've delegated to supports _additional_ actions.
+    handler) {
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_registerActionHandler).call(this, actionType, handler);
+    }
+    /**
+     * Unregister an action handler for an action delegated from another messenger.
+     *
+     * This will prevent this action from being called.
+     *
+     * Note: This is an internal method. Never access this property from another module. This must be
+     * exposed as a public property so that these methods can be called internally on other messenger
+     * instances.
+     *
+     * @deprecated Internal use only. Use the `delegate` method for delegation.
+     * @param actionType - The action type. This is a unqiue identifier for this action.
+     * @template ActionType - A type union of Action type strings.
+     */
+    _internalUnregisterDelegatedActionHandler(actionType) {
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_unregisterActionHandler).call(this, actionType);
+    }
+    /**
+     * Register a function for getting the initial payload for an event that has been delegated from
+     * another messenger.
+     *
+     * This is used for events that represent a state change, where the payload is the state.
+     * Registering a function for getting the payload allows event selectors to have a point of
+     * comparison the first time state changes.
+     *
+     * Note: This is an internal method. Never access this property from another module. This must be
+     * exposed as a public property so that these methods can be called internally on other messenger
+     * instances.
+     *
+     * @deprecated Internal use only. Use the `delegate` method for delegation.
+     * @param args - The arguments to this function
+     * @param args.eventType - The event type to register a payload for.
+     * @param args.getPayload - A function for retrieving the event payload.
+     */
+    _internalRegisterDelegatedInitialEventPayload({ eventType, getPayload, }) {
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_registerInitialEventPayload).call(this, { eventType, getPayload });
+    }
+    /**
+     * Publish an event that was delegated from another messenger.
+     *
+     * Publishes the given payload to all subscribers of the given event type.
+     *
+     * Note that this method should never throw directly. Any errors from
+     * subscribers are captured and re-thrown in a timeout handler.
+     *
+     * Note: This is an internal method. Never access this property from another module. This must be
+     * exposed as a public property so that these methods can be called internally on other messenger
+     * instances.
+     *
+     * @deprecated Internal use only. Use the `delegate` method for delegation.
+     * @param eventType - The event type. This is a unique identifier for this event.
+     * @param payload - The event payload. The type of the parameters for each event handler must
+     * match the type of this payload.
+     * @template EventType - A type union of Event type strings.
+     */
+    _internalPublishDelegated(eventType, ...payload) {
+        __classPrivateFieldGet(this, _Messenger_instances, "m", _Messenger_publish).call(this, eventType, ...payload);
     }
 }
 exports.Messenger = Messenger;
-_Messenger_actions = new WeakMap(), _Messenger_events = new WeakMap(), _Messenger_initialEventPayloadGetters = new WeakMap(), _Messenger_eventPayloadCache = new WeakMap();
+_Messenger_namespace = new WeakMap(), _Messenger_actions = new WeakMap(), _Messenger_events = new WeakMap(), _Messenger_subscriptionDelegationTargets = new WeakMap(), _Messenger_actionDelegationTargets = new WeakMap(), _Messenger_initialEventPayloadGetters = new WeakMap(), _Messenger_eventPayloadCache = new WeakMap(), _Messenger_instances = new WeakSet(), _Messenger_registerActionHandler = function _Messenger_registerActionHandler(actionType, handler) {
+    if (__classPrivateFieldGet(this, _Messenger_actions, "f").has(actionType)) {
+        throw new Error(`A handler for ${actionType} has already been registered`);
+    }
+    __classPrivateFieldGet(this, _Messenger_actions, "f").set(actionType, handler);
+}, _Messenger_unregisterActionHandler = function _Messenger_unregisterActionHandler(actionType) {
+    __classPrivateFieldGet(this, _Messenger_actions, "f").delete(actionType);
+    const delegationTargets = __classPrivateFieldGet(this, _Messenger_actionDelegationTargets, "f").get(actionType);
+    if (!delegationTargets) {
+        return;
+    }
+    for (const messenger of delegationTargets) {
+        messenger._internalUnregisterDelegatedActionHandler(actionType);
+    }
+    __classPrivateFieldGet(this, _Messenger_actionDelegationTargets, "f").delete(actionType);
+}, _Messenger_registerInitialEventPayload = function _Messenger_registerInitialEventPayload({ eventType, getPayload, }) {
+    __classPrivateFieldGet(this, _Messenger_initialEventPayloadGetters, "f").set(eventType, getPayload);
+    const delegationTargets = __classPrivateFieldGet(this, _Messenger_subscriptionDelegationTargets, "f").get(eventType);
+    if (!delegationTargets) {
+        return;
+    }
+    for (const messenger of delegationTargets.keys()) {
+        messenger._internalRegisterDelegatedInitialEventPayload({
+            eventType,
+            getPayload,
+        });
+    }
+}, _Messenger_publish = function _Messenger_publish(eventType, ...payload) {
+    const subscribers = __classPrivateFieldGet(this, _Messenger_events, "f").get(eventType);
+    if (subscribers) {
+        for (const [handler, { selector }] of subscribers.entries()) {
+            try {
+                if (selector) {
+                    const previousValue = __classPrivateFieldGet(this, _Messenger_eventPayloadCache, "f").get(handler);
+                    const newValue = selector(...payload);
+                    if (newValue !== previousValue) {
+                        __classPrivateFieldGet(this, _Messenger_eventPayloadCache, "f").set(handler, newValue);
+                        handler(newValue, previousValue);
+                    }
+                }
+                else {
+                    handler(...payload);
+                }
+            }
+            catch (error) {
+                // Throw error after timeout so that it is capured as a console error
+                // (and by Sentry) without interrupting the event publishing.
+                setTimeout(() => {
+                    throw error;
+                });
+            }
+        }
+    }
+}, _Messenger_subscribe = function _Messenger_subscribe(eventType, handler, metadata) {
+    let subscribers = __classPrivateFieldGet(this, _Messenger_events, "f").get(eventType);
+    if (!subscribers) {
+        subscribers = new Map();
+        __classPrivateFieldGet(this, _Messenger_events, "f").set(eventType, subscribers);
+    }
+    subscribers.set(handler, metadata);
+}, _Messenger_isInCurrentNamespace = function _Messenger_isInCurrentNamespace(name) {
+    return name.startsWith(`${__classPrivateFieldGet(this, _Messenger_namespace, "f")}:`);
+};
 //# sourceMappingURL=Messenger.cjs.map