@metamask-previews/base-controller 8.4.2-preview-9fa15fd0 → 9.0.0-preview-46d2c977

package/dist/RestrictedMessenger.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RestrictedMessenger.mjs","sourceRoot":"","sources":["../src/RestrictedMessenger.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  ActionConstraint,\n  ActionHandler,\n  Messenger,\n  EventConstraint,\n  ExtractActionParameters,\n  ExtractActionResponse,\n  ExtractEventHandler,\n  ExtractEventPayload,\n  NamespacedName,\n  NotNamespacedBy,\n  SelectorEventHandler,\n  SelectorFunction,\n} from './Messenger';\n\n/**\n * A universal supertype of all `RestrictedMessenger` instances. This type can be assigned to any\n * `RestrictedMessenger` type.\n *\n * @template Namespace - Name of the module this messenger is for. Optionally can be used to\n * narrow this type to a constraint for the messenger of a specific module.\n */\nexport type RestrictedMessengerConstraint<Namespace extends string = string> =\n  RestrictedMessenger<\n    Namespace,\n    ActionConstraint,\n    EventConstraint,\n    string,\n    string\n  >;\n\n/**\n * A restricted messenger.\n *\n * This acts as a wrapper around the messenger instance that restricts access to actions\n * and events.\n *\n * @template Namespace - The namespace for this messenger. Typically this is the name of the controller or\n * module that this messenger has been created for. The authority to publish events and register\n * actions under this namespace is granted to this restricted messenger instance.\n * @template Action - A type union of all Action types.\n * @template Event - A type union of all Event types.\n * @template AllowedAction - A type union of the 'type' string for any allowed actions.\n * This must not include internal actions that are in the messenger's namespace.\n * @template AllowedEvent - A type union of the 'type' string for any allowed events.\n * This must not include internal events that are in the messenger's namespace.\n */\nexport class RestrictedMessenger<\n  Namespace extends string,\n  Action extends ActionConstraint,\n  Event extends EventConstraint,\n  AllowedAction extends string,\n  AllowedEvent extends string,\n> {\n  readonly #messenger: Messenger<ActionConstraint, EventConstraint>;\n\n  readonly #namespace: Namespace;\n\n  readonly #allowedActions: NotNamespacedBy<Namespace, AllowedAction>[];\n\n  readonly #allowedEvents: NotNamespacedBy<Namespace, AllowedEvent>[];\n\n  /**\n   * Constructs a restricted messenger\n   *\n   * The provided allowlists grant the ability to call the listed actions and subscribe to the\n   * listed events. The \"name\" provided grants ownership of any actions and events under that\n   * namespace. Ownership allows registering actions and publishing events, as well as\n   * unregistering actions and clearing event subscriptions.\n   *\n   * @param options - Options.\n   * @param options.messenger - The messenger instance that is being wrapped.\n   * @param options.name - The name of the thing this messenger will be handed to (e.g. the\n   * controller name). This grants \"ownership\" of actions and events under this namespace to the\n   * restricted messenger returned.\n   * @param options.allowedActions - The list of actions that this restricted messenger should be\n   * allowed to call.\n   * @param options.allowedEvents - The list of events that this restricted messenger should be\n   * allowed to subscribe to.\n   */\n  constructor({\n    messenger,\n    name,\n    allowedActions,\n    allowedEvents,\n  }: {\n    messenger?: Messenger<ActionConstraint, EventConstraint>;\n    name: Namespace;\n    allowedActions: NotNamespacedBy<Namespace, AllowedAction>[];\n    allowedEvents: NotNamespacedBy<Namespace, AllowedEvent>[];\n  }) {\n    if (!messenger) {\n      throw new Error('Messenger not provided');\n    }\n    // The above condition guarantees that one of these options is defined.\n    this.#messenger = messenger;\n    this.#namespace = name;\n    this.#allowedActions = allowedActions;\n    this.#allowedEvents = allowedEvents;\n  }\n\n  /**\n   * Register an action handler.\n   *\n   * This will make the registered function available to call via the `call` method.\n   *\n   * The action type this handler is registered under *must* be in the current namespace.\n   *\n   * @param action - The action type. This is a unique identifier for this action.\n   * @param handler - The action handler. This function gets called when the `call` method is\n   * invoked with the given action type.\n   * @throws Will throw if an action handler that is not in the current namespace is being registered.\n   * @template ActionType - A type union of Action type strings that are namespaced by Namespace.\n   */\n  registerActionHandler<\n    ActionType extends Action['type'] & NamespacedName<Namespace>,\n  >(action: ActionType, handler: ActionHandler<Action, ActionType>) {\n    /* istanbul ignore if */ // Branch unreachable with valid types\n    if (!this.#isInCurrentNamespace(action)) {\n      throw new Error(\n        `Only allowed registering action handlers prefixed by '${\n          this.#namespace\n        }:'`,\n      );\n    }\n    this.#messenger.registerActionHandler(action, handler);\n  }\n\n  /**\n   * Registers action handlers for a list of methods on a messenger client\n   *\n   * @param messengerClient - The object that is expected to make use of the messenger.\n   * @param methodNames - The names of the methods on the messenger client to register as action\n   * handlers.\n   * @template MessengerClient - The type expected to make use of the messenger.\n   * @template MethodNames - The type union of method names to register as action handlers.\n   */\n  registerMethodActionHandlers<\n    MessengerClient extends { name: string },\n    MethodNames extends keyof MessengerClient & string,\n  >(messengerClient: MessengerClient, methodNames: readonly MethodNames[]) {\n    this.#messenger.registerMethodActionHandlers(messengerClient, methodNames);\n  }\n\n  /**\n   * Unregister an action handler.\n   *\n   * This will prevent this action from being called.\n   *\n   * The action type being unregistered *must* be in the current namespace.\n   *\n   * @param action - The action type. This is a unique identifier for this action.\n   * @throws Will throw if an action handler that is not in the current namespace is being unregistered.\n   * @template ActionType - A type union of Action type strings that are namespaced by Namespace.\n   */\n  unregisterActionHandler<\n    ActionType extends Action['type'] & NamespacedName<Namespace>,\n  >(action: ActionType) {\n    /* istanbul ignore if */ // Branch unreachable with valid types\n    if (!this.#isInCurrentNamespace(action)) {\n      throw new Error(\n        `Only allowed unregistering action handlers prefixed by '${\n          this.#namespace\n        }:'`,\n      );\n    }\n    this.#messenger.unregisterActionHandler(action);\n  }\n\n  /**\n   * Call an action.\n   *\n   * This function will call the action handler corresponding to the given action type, passing\n   * along any parameters given.\n   *\n   * The action type being called must be on the action allowlist.\n   *\n   * @param actionType - The action type. This is a unique identifier for this action.\n   * @param params - The action parameters. These must match the type of the parameters of the\n   * registered action handler.\n   * @throws Will throw when no handler has been registered for the given type.\n   * @template ActionType - A type union of allowed Action type strings.\n   * @returns The action return value.\n   */\n  call<\n    ActionType extends\n      | AllowedAction\n      | (Action['type'] & NamespacedName<Namespace>),\n  >(\n    actionType: ActionType,\n    ...params: ExtractActionParameters<Action, ActionType>\n  ): ExtractActionResponse<Action, ActionType> {\n    if (!this.#isAllowedAction(actionType)) {\n      throw new Error(`Action missing from allow list: ${actionType}`);\n    }\n    const response = this.#messenger.call<ActionType>(actionType, ...params);\n\n    return response;\n  }\n\n  /**\n   * Register a function for getting the initial payload for an event.\n   *\n   * This is used for events that represent a state change, where the payload is the state.\n   * Registering a function for getting the payload allows event selectors to have a point of\n   * comparison the first time state changes.\n   *\n   * The event type *must* be in the current namespace\n   *\n   * @param args - The arguments to this function\n   * @param args.eventType - The event type to register a payload for.\n   * @param args.getPayload - A function for retrieving the event payload.\n   * @template EventType - A type union of Event type strings.\n   */\n  registerInitialEventPayload<\n    EventType extends Event['type'] & NamespacedName<Namespace>,\n  >({\n    eventType,\n    getPayload,\n  }: {\n    eventType: EventType;\n    getPayload: () => ExtractEventPayload<Event, EventType>;\n  }) {\n    /* istanbul ignore if */ // Branch unreachable with valid types\n    if (!this.#isInCurrentNamespace(eventType)) {\n      throw new Error(\n        `Only allowed publishing events prefixed by '${this.#namespace}:'`,\n      );\n    }\n    this.#messenger.registerInitialEventPayload({\n      eventType,\n      getPayload,\n    });\n  }\n\n  /**\n   * Publish an event.\n   *\n   * Publishes the given payload to all subscribers of the given event type.\n   *\n   * The event type being published *must* be in the current namespace.\n   *\n   * @param event - The event type. This is a unique identifier for this event.\n   * @param payload - The event payload. The type of the parameters for each event handler must\n   * match the type of this payload.\n   * @throws Will throw if an event that is not in the current namespace is being published.\n   * @template EventType - A type union of Event type strings that are namespaced by Namespace.\n   */\n  publish<EventType extends Event['type'] & NamespacedName<Namespace>>(\n    event: EventType,\n    ...payload: ExtractEventPayload<Event, EventType>\n  ) {\n    /* istanbul ignore if */ // Branch unreachable with valid types\n    if (!this.#isInCurrentNamespace(event)) {\n      throw new Error(\n        `Only allowed publishing events prefixed by '${this.#namespace}:'`,\n      );\n    }\n    this.#messenger.publish(event, ...payload);\n  }\n\n  /**\n   * Subscribe to an event.\n   *\n   * Registers the given function as an event handler for the given event type.\n   *\n   * The event type being subscribed to must be on the event allowlist.\n   *\n   * @param eventType - The event type. This is a unique identifier for this event.\n   * @param handler - The event handler. The type of the parameters for this event handler must\n   * match the type of the payload for this event type.\n   * @throws Will throw if the given event is not an allowed event for this messenger.\n   * @template EventType - A type union of Event type strings.\n   */\n  subscribe<\n    EventType extends\n      | AllowedEvent\n      | (Event['type'] & NamespacedName<Namespace>),\n  >(eventType: EventType, handler: ExtractEventHandler<Event, EventType>): void;\n\n  /**\n   * Subscribe to an event, with a selector.\n   *\n   * Registers the given handler function as an event handler for the given\n   * event type. When an event is published, its payload is first passed to the\n   * selector. The event handler is only called if the selector's return value\n   * differs from its last known return value.\n   *\n   * The event type being subscribed to must be on the event allowlist.\n   *\n   * @param eventType - The event type. This is a unique identifier for this event.\n   * @param handler - The event handler. The type of the parameters for this event\n   * handler must match the return type of the selector.\n   * @param selector - The selector function used to select relevant data from\n   * the event payload. The type of the parameters for this selector must match\n   * the type of the payload for this event type.\n   * @throws Will throw if the given event is not an allowed event for this messenger.\n   * @template EventType - A type union of Event type strings.\n   * @template SelectorReturnValue - The selector return value.\n   */\n  subscribe<\n    EventType extends\n      | AllowedEvent\n      | (Event['type'] & NamespacedName<Namespace>),\n    SelectorReturnValue,\n  >(\n    eventType: EventType,\n    handler: SelectorEventHandler<SelectorReturnValue>,\n    selector: SelectorFunction<Event, EventType, SelectorReturnValue>,\n  ): void;\n\n  subscribe<\n    EventType extends\n      | AllowedEvent\n      | (Event['type'] & NamespacedName<Namespace>),\n    SelectorReturnValue,\n  >(\n    event: EventType,\n    handler:\n      | ExtractEventHandler<Event, EventType>\n      | SelectorEventHandler<SelectorReturnValue>,\n    selector?: SelectorFunction<Event, EventType, SelectorReturnValue>,\n  ) {\n    if (!this.#isAllowedEvent(event)) {\n      throw new Error(`Event missing from allow list: ${event}`);\n    }\n\n    if (selector) {\n      return this.#messenger.subscribe(event, handler, selector);\n    }\n    return this.#messenger.subscribe(\n      event,\n      handler as ExtractEventHandler<Event, EventType>,\n    );\n  }\n\n  /**\n   * Unsubscribe from an event.\n   *\n   * Unregisters the given function as an event handler for the given event.\n   *\n   * The event type being unsubscribed to must be on the event allowlist.\n   *\n   * @param event - The event type. This is a unique identifier for this event.\n   * @param handler - The event handler to unregister.\n   * @throws Will throw if the given event is not an allowed event for this messenger.\n   * @template EventType - A type union of allowed Event type strings.\n   * @template SelectorReturnValue - The selector return value.\n   */\n  unsubscribe<\n    EventType extends\n      | AllowedEvent\n      | (Event['type'] & NamespacedName<Namespace>),\n    SelectorReturnValue = unknown,\n  >(\n    event: EventType,\n    handler:\n      | ExtractEventHandler<Event, EventType>\n      | SelectorEventHandler<SelectorReturnValue>,\n  ) {\n    if (!this.#isAllowedEvent(event)) {\n      throw new Error(`Event missing from allow list: ${event}`);\n    }\n    this.#messenger.unsubscribe(event, handler);\n  }\n\n  /**\n   * Clear subscriptions for a specific event.\n   *\n   * This will remove all subscribed handlers for this event.\n   *\n   * The event type being cleared *must* be in the current namespace.\n   *\n   * @param event - The event type. This is a unique identifier for this event.\n   * @throws Will throw if a subscription for an event that is not in the current namespace is being cleared.\n   * @template EventType - A type union of Event type strings that are namespaced by Namespace.\n   */\n  clearEventSubscriptions<\n    EventType extends Event['type'] & NamespacedName<Namespace>,\n  >(event: EventType) {\n    if (!this.#isInCurrentNamespace(event)) {\n      throw new Error(\n        `Only allowed clearing events prefixed by '${this.#namespace}:'`,\n      );\n    }\n    this.#messenger.clearEventSubscriptions(event);\n  }\n\n  /**\n   * Determine whether the given event type is allowed. Event types are\n   * allowed if they are in the current namespace or on the list of\n   * allowed events.\n   *\n   * @param eventType - The event type to check.\n   * @returns Whether the event type is allowed.\n   */\n  #isAllowedEvent(\n    eventType: Event['type'],\n  ): eventType is\n    | NamespacedName<Namespace>\n    | NotNamespacedBy<Namespace, AllowedEvent> {\n    // Safely upcast to allow runtime check\n    const allowedEvents: string[] | null = this.#allowedEvents;\n    return (\n      this.#isInCurrentNamespace(eventType) ||\n      (allowedEvents !== null && allowedEvents.includes(eventType))\n    );\n  }\n\n  /**\n   * Determine whether the given action type is allowed. Action types\n   * are allowed if they are in the current namespace or on the list of\n   * allowed actions.\n   *\n   * @param actionType - The action type to check.\n   * @returns Whether the action type is allowed.\n   */\n  #isAllowedAction(\n    actionType: Action['type'],\n  ): actionType is\n    | NamespacedName<Namespace>\n    | NotNamespacedBy<Namespace, AllowedAction> {\n    // Safely upcast to allow runtime check\n    const allowedActions: string[] | null = this.#allowedActions;\n    return (\n      this.#isInCurrentNamespace(actionType) ||\n      (allowedActions !== null && allowedActions.includes(actionType))\n    );\n  }\n\n  /**\n   * Determine whether the given name is within the current namespace.\n   *\n   * @param name - The name to check\n   * @returns Whether the name is within the current namespace\n   */\n  #isInCurrentNamespace(name: string): name is NamespacedName<Namespace> {\n    return name.startsWith(`${this.#namespace}:`);\n  }\n}\n"]}

package/dist/next/BaseController.cjs

@@ -1,168 +0,0 @@
-"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 _BaseController_internalState, _BaseController_messenger;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deriveStateFromMetadata = exports.BaseController = void 0;
-const immer_1 = require("immer");
-(0, immer_1.enablePatches)();
-/**
- * Controller class that provides state management, subscriptions, and state metadata
- */
-class BaseController {
-    /**
-     * Creates a BaseController instance.
-     *
-     * @param options - Controller options.
-     * @param options.messenger - The controller messenger.
-     * @param options.metadata - ControllerState metadata, describing how to "anonymize" the state, and which
-     * parts should be persisted.
-     * @param options.name - The name of the controller, used as a namespace for events and actions.
-     * @param options.state - Initial controller state.
-     */
-    constructor({ messenger, metadata, name, state, }) {
-        /**
-         * The controller state.
-         */
-        _BaseController_internalState.set(this, void 0);
-        /**
-         * The controller messenger.
-         *
-         * This is the same as the `messagingSystem` property, but has a type that only lets us use
-         * actions and events that are part of the `BaseController` class.
-         */
-        _BaseController_messenger.set(this, void 0);
-        // The parameter type validates that the expected actions/events are present
-        // We don't have a way to validate the type property because the type is invariant
-        __classPrivateFieldSet(this, _BaseController_messenger, messenger, "f");
-        this.messenger = messenger;
-        this.name = name;
-        // Here we use `freeze` from Immer to enforce that the state is deeply
-        // immutable. Note that this is a runtime check, not a compile-time check.
-        // That is, unlike `Object.freeze`, this does not narrow the type
-        // recursively to `Readonly`. The equivalent in Immer is `Immutable`, but
-        // `Immutable` does not handle recursive types such as our `Json` type.
-        __classPrivateFieldSet(this, _BaseController_internalState, (0, immer_1.freeze)(state, true), "f");
-        this.metadata = metadata;
-        __classPrivateFieldGet(this, _BaseController_messenger, "f").registerActionHandler(`${name}:getState`, () => this.state);
-        __classPrivateFieldGet(this, _BaseController_messenger, "f").registerInitialEventPayload({
-            eventType: `${name}:stateChange`,
-            getPayload: () => [this.state, []],
-        });
-    }
-    /**
-     * Retrieves current controller state.
-     *
-     * @returns The current state.
-     */
-    get state() {
-        return __classPrivateFieldGet(this, _BaseController_internalState, "f");
-    }
-    set state(_) {
-        throw new Error(`Controller state cannot be directly mutated; use 'update' method instead.`);
-    }
-    /**
-     * Updates controller state. Accepts a callback that is passed a draft copy
-     * of the controller state. If a value is returned, it is set as the new
-     * state. Otherwise, any changes made within that callback to the draft are
-     * applied to the controller state.
-     *
-     * @param callback - Callback for updating state, passed a draft state
-     * object. Return a new state object or mutate the draft to update state.
-     * @returns An object that has the next state, patches applied in the update and inverse patches to
-     * rollback the update.
-     */
-    update(callback) {
-        // We run into ts2589, "infinite type depth", if we don't cast
-        // produceWithPatches here.
-        const [nextState, patches, inversePatches] = immer_1.produceWithPatches(__classPrivateFieldGet(this, _BaseController_internalState, "f"), callback);
-        // Protect against unnecessary state updates when there is no state diff.
-        if (patches.length > 0) {
-            __classPrivateFieldSet(this, _BaseController_internalState, nextState, "f");
-            __classPrivateFieldGet(this, _BaseController_messenger, "f").publish(`${this.name}:stateChange`, nextState, patches);
-        }
-        return { nextState, patches, inversePatches };
-    }
-    /**
-     * Applies immer patches to the current state. The patches come from the
-     * update function itself and can either be normal or inverse patches.
-     *
-     * @param patches - An array of immer patches that are to be applied to make
-     * or undo changes.
-     */
-    applyPatches(patches) {
-        const nextState = (0, immer_1.applyPatches)(__classPrivateFieldGet(this, _BaseController_internalState, "f"), patches);
-        __classPrivateFieldSet(this, _BaseController_internalState, nextState, "f");
-        __classPrivateFieldGet(this, _BaseController_messenger, "f").publish(`${this.name}:stateChange`, nextState, patches);
-    }
-    /**
-     * Prepares the controller for garbage collection. This should be extended
-     * by any subclasses to clean up any additional connections or events.
-     *
-     * The only cleanup performed here is to remove listeners. While technically
-     * this is not required to ensure this instance is garbage collected, it at
-     * least ensures this instance won't be responsible for preventing the
-     * listeners from being garbage collected.
-     */
-    destroy() {
-        this.messenger.clearEventSubscriptions(`${this.name}:stateChange`);
-    }
-}
-exports.BaseController = BaseController;
-_BaseController_internalState = new WeakMap(), _BaseController_messenger = new WeakMap();
-/**
- * Use the metadata to derive state according to the given metadata property.
- *
- * @param state - The full controller state.
- * @param metadata - The controller metadata.
- * @param metadataProperty - The metadata property to use to derive state.
- * @param captureException - Reports an error to an error monitoring service.
- * @returns The metadata-derived controller state.
- */
-function deriveStateFromMetadata(state, metadata, metadataProperty, captureException) {
-    return Object.keys(state).reduce((derivedState, key) => {
-        try {
-            const stateMetadata = metadata[key];
-            if (!stateMetadata) {
-                throw new Error(`No metadata found for '${String(key)}'`);
-            }
-            const propertyMetadata = stateMetadata[metadataProperty];
-            const stateProperty = state[key];
-            if (typeof propertyMetadata === 'function') {
-                derivedState[key] = propertyMetadata(stateProperty);
-            }
-            else if (propertyMetadata) {
-                derivedState[key] = stateProperty;
-            }
-            return derivedState;
-        }
-        catch (error) {
-            // Capture error without interrupting state-related operations
-            // See [ADR core#0016](https://github.com/MetaMask/decisions/blob/main/decisions/core/0016-core-classes-error-reporting.md)
-            if (captureException) {
-                try {
-                    captureException(error instanceof Error ? error : new Error(String(error)));
-                }
-                catch (captureExceptionError) {
-                    console.error(new Error(`Error thrown when calling 'captureException'`), captureExceptionError);
-                    console.error(error);
-                }
-            }
-            else {
-                console.error(error);
-            }
-            return derivedState;
-        }
-    }, {});
-}
-exports.deriveStateFromMetadata = deriveStateFromMetadata;
-//# sourceMappingURL=BaseController.cjs.map

package/dist/next/BaseController.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseController.cjs","sourceRoot":"","sources":["../../src/next/BaseController.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  ActionConstraint,\n  EventConstraint,\n  Messenger,\n  MessengerActions,\n  MessengerEvents,\n} from '@metamask/messenger';\nimport type { Json, PublicInterface } from '@metamask/utils';\nimport { enablePatches, produceWithPatches, applyPatches, freeze } from 'immer';\nimport type { Draft, Patch } from 'immer';\n\nenablePatches();\n\n/**\n * A type that constrains the state of all controllers.\n *\n * In other words, the narrowest supertype encompassing all controller state.\n */\nexport type StateConstraint = Record<string, Json>;\n\n/**\n * A state change listener.\n *\n * This function will get called for each state change, and is given a copy of\n * the new state along with a set of patches describing the changes since the\n * last update.\n *\n * @param state - The new controller state.\n * @param patches - A list of patches describing any changes (see here for more\n * information: https://immerjs.github.io/immer/docs/patches)\n */\nexport type StateChangeListener<T> = (state: T, patches: Patch[]) => void;\n\n/**\n * An function to derive state.\n *\n * This function will accept one piece of the controller state (one property),\n * and will return some derivation of that state.\n *\n * @param value - A piece of controller state.\n * @returns Something derived from controller state.\n */\n// TODO: Either fix this lint violation or explain why it's necessary to ignore.\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport type StateDeriver<T extends Json> = (value: T) => Json;\n\n/**\n * State metadata.\n *\n * This metadata describes which parts of state should be persisted, and how to\n * get an anonymized representation of the state.\n */\n// TODO: Either fix this lint violation or explain why it's necessary to ignore.\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport type StateMetadata<T extends StateConstraint> = {\n  [P in keyof T]-?: StatePropertyMetadata<T[P]>;\n};\n\n/**\n * Metadata for a single state property\n */\nexport type StatePropertyMetadata<ControllerState extends Json> = {\n  /**\n   * Indicates whether this property should be included in debug snapshots attached to Sentry\n   * errors.\n   *\n   * Set this to false if the state may contain personally identifiable information, or if it's\n   * too large to include in a debug snapshot.\n   */\n  includeInDebugSnapshot: boolean | StateDeriver<ControllerState>;\n  /**\n   * Indicates whether this property should be included in state logs.\n   *\n   * Set this to false if the data should be kept hidden from support agents (e.g. if it contains\n   * secret keys, or personally-identifiable information that is not useful for debugging).\n   *\n   * We do allow state logs to contain some personally identifiable information to assist with\n   * diagnosing errors (e.g. transaction hashes, addresses), but we still attempt to limit the\n   * data we expose to what is most useful for helping users.\n   */\n  includeInStateLogs: boolean | StateDeriver<ControllerState>;\n  /**\n   * Indicates whether this property should be persisted.\n   *\n   * If true, the property will be persisted and saved between sessions.\n   * If false, the property will not be saved between sessions, and it will always be missing from the `state` constructor parameter.\n   */\n  persist: boolean | StateDeriver<ControllerState>;\n  /**\n   * Indicates whether this property is used by the UI.\n   *\n   * If true, the property will be accessible from the UI.\n   * If false, it will be inaccessible from the UI.\n   *\n   * Making a property accessible to the UI has a performance overhead, so it's better to set this\n   * to `false` if it's not used in the UI, especially for properties that can be large in size.\n   *\n   * Note that we disallow the use of a state derivation function here to preserve type information\n   * for the UI (the state deriver type always returns `Json`).\n   */\n  usedInUi: boolean;\n};\n\n/**\n * A universal supertype of `StateDeriver` types.\n * This type can be assigned to any `StateDeriver` type.\n */\nexport type StateDeriverConstraint = (value: never) => Json;\n\n/**\n * A universal supertype of `StatePropertyMetadata` types.\n * This type can be assigned to any `StatePropertyMetadata` type.\n */\nexport type StatePropertyMetadataConstraint = {\n  includeInDebugSnapshot: boolean | StateDeriverConstraint;\n  includeInStateLogs?: boolean | StateDeriverConstraint;\n  persist: boolean | StateDeriverConstraint;\n  usedInUi?: boolean;\n};\n\n/**\n * A universal supertype of `StateMetadata` types.\n * This type can be assigned to any `StateMetadata` type.\n */\nexport type StateMetadataConstraint = Record<\n  string,\n  StatePropertyMetadataConstraint\n>;\n\n/**\n * The widest subtype of all controller instances that inherit from `BaseController` (formerly `BaseControllerV2`).\n * Any `BaseController` subclass instance can be assigned to this type.\n */\nexport type BaseControllerInstance = Omit<\n  PublicInterface<\n    BaseController<\n      string,\n      StateConstraint,\n      // Use `any` to allow any parent to be set.\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      Messenger<string, ActionConstraint, EventConstraint, any>\n    >\n  >,\n  'metadata'\n> & {\n  metadata: StateMetadataConstraint;\n};\n\nexport type ControllerGetStateAction<\n  ControllerName extends string,\n  ControllerState extends StateConstraint,\n> = {\n  type: `${ControllerName}:getState`;\n  handler: () => ControllerState;\n};\n\nexport type ControllerStateChangeEvent<\n  ControllerName extends string,\n  ControllerState extends StateConstraint,\n> = {\n  type: `${ControllerName}:stateChange`;\n  payload: [ControllerState, Patch[]];\n};\n\nexport type ControllerActions<\n  ControllerName extends string,\n  ControllerState extends StateConstraint,\n> = ControllerGetStateAction<ControllerName, ControllerState>;\n\nexport type ControllerEvents<\n  ControllerName extends string,\n  ControllerState extends StateConstraint,\n> = ControllerStateChangeEvent<ControllerName, ControllerState>;\n\n/**\n * Controller class that provides state management, subscriptions, and state metadata\n */\nexport class BaseController<\n  ControllerName extends string,\n  ControllerState extends StateConstraint,\n  ControllerMessenger extends Messenger<\n    ControllerName,\n    ActionConstraint,\n    EventConstraint,\n    // Use `any` to allow any parent to be set. `any` is harmless in a type constraint anyway,\n    // it's the one totally safe place to use it.\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    any\n  >,\n> {\n  /**\n   * The controller state.\n   */\n  #internalState: ControllerState;\n\n  /**\n   * The controller messenger. This is used to interact with other parts of the application.\n   */\n  protected messenger: ControllerMessenger;\n\n  /**\n   * The controller messenger.\n   *\n   * This is the same as the `messagingSystem` property, but has a type that only lets us use\n   * actions and events that are part of the `BaseController` class.\n   */\n  readonly #messenger: Messenger<\n    ControllerName,\n    ControllerActions<ControllerName, ControllerState>,\n    ControllerEvents<ControllerName, ControllerState>\n  >;\n\n  /**\n   * The name of the controller.\n   *\n   * This is used by the ComposableController to construct a composed application state.\n   */\n  public readonly name: ControllerName;\n\n  public readonly metadata: StateMetadata<ControllerState>;\n\n  /**\n   * Creates a BaseController instance.\n   *\n   * @param options - Controller options.\n   * @param options.messenger - The controller messenger.\n   * @param options.metadata - ControllerState metadata, describing how to \"anonymize\" the state, and which\n   * parts should be persisted.\n   * @param options.name - The name of the controller, used as a namespace for events and actions.\n   * @param options.state - Initial controller state.\n   */\n  constructor({\n    messenger,\n    metadata,\n    name,\n    state,\n  }: {\n    messenger: ControllerActions<\n      ControllerName,\n      ControllerState\n    >['type'] extends MessengerActions<ControllerMessenger>['type']\n      ? ControllerEvents<\n          ControllerName,\n          ControllerState\n        >['type'] extends MessengerEvents<ControllerMessenger>['type']\n        ? ControllerMessenger\n        : never\n      : never;\n    metadata: StateMetadata<ControllerState>;\n    name: ControllerName;\n    state: ControllerState;\n  }) {\n    // The parameter type validates that the expected actions/events are present\n    // We don't have a way to validate the type property because the type is invariant\n    this.#messenger = messenger as unknown as Messenger<\n      ControllerName,\n      ControllerActions<ControllerName, ControllerState>,\n      ControllerEvents<ControllerName, ControllerState>\n    >;\n    this.messenger = messenger;\n    this.name = name;\n    // Here we use `freeze` from Immer to enforce that the state is deeply\n    // immutable. Note that this is a runtime check, not a compile-time check.\n    // That is, unlike `Object.freeze`, this does not narrow the type\n    // recursively to `Readonly`. The equivalent in Immer is `Immutable`, but\n    // `Immutable` does not handle recursive types such as our `Json` type.\n    this.#internalState = freeze(state, true);\n    this.metadata = metadata;\n\n    this.#messenger.registerActionHandler(`${name}:getState`, () => this.state);\n\n    this.#messenger.registerInitialEventPayload({\n      eventType: `${name}:stateChange`,\n      getPayload: () => [this.state, []],\n    });\n  }\n\n  /**\n   * Retrieves current controller state.\n   *\n   * @returns The current state.\n   */\n  get state() {\n    return this.#internalState;\n  }\n\n  set state(_) {\n    throw new Error(\n      `Controller state cannot be directly mutated; use 'update' method instead.`,\n    );\n  }\n\n  /**\n   * Updates controller state. Accepts a callback that is passed a draft copy\n   * of the controller state. If a value is returned, it is set as the new\n   * state. Otherwise, any changes made within that callback to the draft are\n   * applied to the controller state.\n   *\n   * @param callback - Callback for updating state, passed a draft state\n   * object. Return a new state object or mutate the draft to update state.\n   * @returns An object that has the next state, patches applied in the update and inverse patches to\n   * rollback the update.\n   */\n  protected update(\n    callback: (state: Draft<ControllerState>) => void | ControllerState,\n  ): {\n    nextState: ControllerState;\n    patches: Patch[];\n    inversePatches: Patch[];\n  } {\n    // We run into ts2589, \"infinite type depth\", if we don't cast\n    // produceWithPatches here.\n    const [nextState, patches, inversePatches] = (\n      produceWithPatches as unknown as (\n        state: ControllerState,\n        cb: typeof callback,\n      ) => [ControllerState, Patch[], Patch[]]\n    )(this.#internalState, callback);\n\n    // Protect against unnecessary state updates when there is no state diff.\n    if (patches.length > 0) {\n      this.#internalState = nextState;\n      this.#messenger.publish(\n        `${this.name}:stateChange` as const,\n        nextState,\n        patches,\n      );\n    }\n\n    return { nextState, patches, inversePatches };\n  }\n\n  /**\n   * Applies immer patches to the current state. The patches come from the\n   * update function itself and can either be normal or inverse patches.\n   *\n   * @param patches - An array of immer patches that are to be applied to make\n   * or undo changes.\n   */\n  protected applyPatches(patches: Patch[]) {\n    const nextState = applyPatches(this.#internalState, patches);\n    this.#internalState = nextState;\n    this.#messenger.publish(\n      `${this.name}:stateChange` as const,\n      nextState,\n      patches,\n    );\n  }\n\n  /**\n   * Prepares the controller for garbage collection. This should be extended\n   * by any subclasses to clean up any additional connections or events.\n   *\n   * The only cleanup performed here is to remove listeners. While technically\n   * this is not required to ensure this instance is garbage collected, it at\n   * least ensures this instance won't be responsible for preventing the\n   * listeners from being garbage collected.\n   */\n  protected destroy() {\n    this.messenger.clearEventSubscriptions(`${this.name}:stateChange`);\n  }\n}\n\n/**\n * Use the metadata to derive state according to the given metadata property.\n *\n * @param state - The full controller state.\n * @param metadata - The controller metadata.\n * @param metadataProperty - The metadata property to use to derive state.\n * @param captureException - Reports an error to an error monitoring service.\n * @returns The metadata-derived controller state.\n */\nexport function deriveStateFromMetadata<\n  ControllerState extends StateConstraint,\n>(\n  state: ControllerState,\n  metadata: StateMetadata<ControllerState>,\n  metadataProperty: keyof StatePropertyMetadata<Json>,\n  captureException?: (error: Error) => void,\n): Record<keyof ControllerState, Json> {\n  return (Object.keys(state) as (keyof ControllerState)[]).reduce<\n    Record<keyof ControllerState, Json>\n  >((derivedState, key) => {\n    try {\n      const stateMetadata = metadata[key];\n      if (!stateMetadata) {\n        throw new Error(`No metadata found for '${String(key)}'`);\n      }\n      const propertyMetadata = stateMetadata[metadataProperty];\n      const stateProperty = state[key];\n      if (typeof propertyMetadata === 'function') {\n        derivedState[key] = propertyMetadata(stateProperty);\n      } else if (propertyMetadata) {\n        derivedState[key] = stateProperty;\n      }\n      return derivedState;\n    } catch (error) {\n      // Capture error without interrupting state-related operations\n      // See [ADR core#0016](https://github.com/MetaMask/decisions/blob/main/decisions/core/0016-core-classes-error-reporting.md)\n      if (captureException) {\n        try {\n          captureException(\n            error instanceof Error ? error : new Error(String(error)),\n          );\n        } catch (captureExceptionError) {\n          console.error(\n            new Error(`Error thrown when calling 'captureException'`),\n            captureExceptionError,\n          );\n          console.error(error);\n        }\n      } else {\n        console.error(error);\n      }\n      return derivedState;\n    }\n  }, {} as never);\n}\n"]}

package/dist/next/BaseController.d.cts

@@ -1,206 +0,0 @@
-import type { ActionConstraint, EventConstraint, Messenger, MessengerActions, MessengerEvents } from "@metamask/messenger";
-import type { Json, PublicInterface } from "@metamask/utils";
-import type { Draft, Patch } from "immer";
-/**
- * A type that constrains the state of all controllers.
- *
- * In other words, the narrowest supertype encompassing all controller state.
- */
-export type StateConstraint = Record<string, Json>;
-/**
- * A state change listener.
- *
- * This function will get called for each state change, and is given a copy of
- * the new state along with a set of patches describing the changes since the
- * last update.
- *
- * @param state - The new controller state.
- * @param patches - A list of patches describing any changes (see here for more
- * information: https://immerjs.github.io/immer/docs/patches)
- */
-export type StateChangeListener<T> = (state: T, patches: Patch[]) => void;
-/**
- * An function to derive state.
- *
- * This function will accept one piece of the controller state (one property),
- * and will return some derivation of that state.
- *
- * @param value - A piece of controller state.
- * @returns Something derived from controller state.
- */
-export type StateDeriver<T extends Json> = (value: T) => Json;
-/**
- * State metadata.
- *
- * This metadata describes which parts of state should be persisted, and how to
- * get an anonymized representation of the state.
- */
-export type StateMetadata<T extends StateConstraint> = {
-    [P in keyof T]-?: StatePropertyMetadata<T[P]>;
-};
-/**
- * Metadata for a single state property
- */
-export type StatePropertyMetadata<ControllerState extends Json> = {
-    /**
-     * Indicates whether this property should be included in debug snapshots attached to Sentry
-     * errors.
-     *
-     * Set this to false if the state may contain personally identifiable information, or if it's
-     * too large to include in a debug snapshot.
-     */
-    includeInDebugSnapshot: boolean | StateDeriver<ControllerState>;
-    /**
-     * Indicates whether this property should be included in state logs.
-     *
-     * Set this to false if the data should be kept hidden from support agents (e.g. if it contains
-     * secret keys, or personally-identifiable information that is not useful for debugging).
-     *
-     * We do allow state logs to contain some personally identifiable information to assist with
-     * diagnosing errors (e.g. transaction hashes, addresses), but we still attempt to limit the
-     * data we expose to what is most useful for helping users.
-     */
-    includeInStateLogs: boolean | StateDeriver<ControllerState>;
-    /**
-     * Indicates whether this property should be persisted.
-     *
-     * If true, the property will be persisted and saved between sessions.
-     * If false, the property will not be saved between sessions, and it will always be missing from the `state` constructor parameter.
-     */
-    persist: boolean | StateDeriver<ControllerState>;
-    /**
-     * Indicates whether this property is used by the UI.
-     *
-     * If true, the property will be accessible from the UI.
-     * If false, it will be inaccessible from the UI.
-     *
-     * Making a property accessible to the UI has a performance overhead, so it's better to set this
-     * to `false` if it's not used in the UI, especially for properties that can be large in size.
-     *
-     * Note that we disallow the use of a state derivation function here to preserve type information
-     * for the UI (the state deriver type always returns `Json`).
-     */
-    usedInUi: boolean;
-};
-/**
- * A universal supertype of `StateDeriver` types.
- * This type can be assigned to any `StateDeriver` type.
- */
-export type StateDeriverConstraint = (value: never) => Json;
-/**
- * A universal supertype of `StatePropertyMetadata` types.
- * This type can be assigned to any `StatePropertyMetadata` type.
- */
-export type StatePropertyMetadataConstraint = {
-    includeInDebugSnapshot: boolean | StateDeriverConstraint;
-    includeInStateLogs?: boolean | StateDeriverConstraint;
-    persist: boolean | StateDeriverConstraint;
-    usedInUi?: boolean;
-};
-/**
- * A universal supertype of `StateMetadata` types.
- * This type can be assigned to any `StateMetadata` type.
- */
-export type StateMetadataConstraint = Record<string, StatePropertyMetadataConstraint>;
-/**
- * The widest subtype of all controller instances that inherit from `BaseController` (formerly `BaseControllerV2`).
- * Any `BaseController` subclass instance can be assigned to this type.
- */
-export type BaseControllerInstance = Omit<PublicInterface<BaseController<string, StateConstraint, Messenger<string, ActionConstraint, EventConstraint, any>>>, 'metadata'> & {
-    metadata: StateMetadataConstraint;
-};
-export type ControllerGetStateAction<ControllerName extends string, ControllerState extends StateConstraint> = {
-    type: `${ControllerName}:getState`;
-    handler: () => ControllerState;
-};
-export type ControllerStateChangeEvent<ControllerName extends string, ControllerState extends StateConstraint> = {
-    type: `${ControllerName}:stateChange`;
-    payload: [ControllerState, Patch[]];
-};
-export type ControllerActions<ControllerName extends string, ControllerState extends StateConstraint> = ControllerGetStateAction<ControllerName, ControllerState>;
-export type ControllerEvents<ControllerName extends string, ControllerState extends StateConstraint> = ControllerStateChangeEvent<ControllerName, ControllerState>;
-/**
- * Controller class that provides state management, subscriptions, and state metadata
- */
-export declare class BaseController<ControllerName extends string, ControllerState extends StateConstraint, ControllerMessenger extends Messenger<ControllerName, ActionConstraint, EventConstraint, any>> {
-    #private;
-    /**
-     * The controller messenger. This is used to interact with other parts of the application.
-     */
-    protected messenger: ControllerMessenger;
-    /**
-     * The name of the controller.
-     *
-     * This is used by the ComposableController to construct a composed application state.
-     */
-    readonly name: ControllerName;
-    readonly metadata: StateMetadata<ControllerState>;
-    /**
-     * Creates a BaseController instance.
-     *
-     * @param options - Controller options.
-     * @param options.messenger - The controller messenger.
-     * @param options.metadata - ControllerState metadata, describing how to "anonymize" the state, and which
-     * parts should be persisted.
-     * @param options.name - The name of the controller, used as a namespace for events and actions.
-     * @param options.state - Initial controller state.
-     */
-    constructor({ messenger, metadata, name, state, }: {
-        messenger: ControllerActions<ControllerName, ControllerState>['type'] extends MessengerActions<ControllerMessenger>['type'] ? ControllerEvents<ControllerName, ControllerState>['type'] extends MessengerEvents<ControllerMessenger>['type'] ? ControllerMessenger : never : never;
-        metadata: StateMetadata<ControllerState>;
-        name: ControllerName;
-        state: ControllerState;
-    });
-    /**
-     * Retrieves current controller state.
-     *
-     * @returns The current state.
-     */
-    get state(): ControllerState;
-    set state(_: ControllerState);
-    /**
-     * Updates controller state. Accepts a callback that is passed a draft copy
-     * of the controller state. If a value is returned, it is set as the new
-     * state. Otherwise, any changes made within that callback to the draft are
-     * applied to the controller state.
-     *
-     * @param callback - Callback for updating state, passed a draft state
-     * object. Return a new state object or mutate the draft to update state.
-     * @returns An object that has the next state, patches applied in the update and inverse patches to
-     * rollback the update.
-     */
-    protected update(callback: (state: Draft<ControllerState>) => void | ControllerState): {
-        nextState: ControllerState;
-        patches: Patch[];
-        inversePatches: Patch[];
-    };
-    /**
-     * Applies immer patches to the current state. The patches come from the
-     * update function itself and can either be normal or inverse patches.
-     *
-     * @param patches - An array of immer patches that are to be applied to make
-     * or undo changes.
-     */
-    protected applyPatches(patches: Patch[]): void;
-    /**
-     * Prepares the controller for garbage collection. This should be extended
-     * by any subclasses to clean up any additional connections or events.
-     *
-     * The only cleanup performed here is to remove listeners. While technically
-     * this is not required to ensure this instance is garbage collected, it at
-     * least ensures this instance won't be responsible for preventing the
-     * listeners from being garbage collected.
-     */
-    protected destroy(): void;
-}
-/**
- * Use the metadata to derive state according to the given metadata property.
- *
- * @param state - The full controller state.
- * @param metadata - The controller metadata.
- * @param metadataProperty - The metadata property to use to derive state.
- * @param captureException - Reports an error to an error monitoring service.
- * @returns The metadata-derived controller state.
- */
-export declare function deriveStateFromMetadata<ControllerState extends StateConstraint>(state: ControllerState, metadata: StateMetadata<ControllerState>, metadataProperty: keyof StatePropertyMetadata<Json>, captureException?: (error: Error) => void): Record<keyof ControllerState, Json>;
-//# sourceMappingURL=BaseController.d.cts.map

package/dist/next/BaseController.d.cts.map

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