@metamask-previews/composable-controller - npm Package Compare versions

Comparing version 5.0.1-preview.d392f46 to 5.0.1-preview.d78968a2

CHANGELOG.md

@@ -10,2 +10,17 @@ # Changelog
 
+### Added
+
+- Add and export functions `isBaseControllerV1` and `isBaseController`, which are type guards for validating controller instances ([#3904](https://github.com/MetaMask/core/pull/3904))
+- Add and export types `BaseControllerV1Instance`, `BaseControllerV2Instance`, `ControllerInstance` which are the narrowest supertypes for all controllers extending from, respectively, `BaseControllerV1`, `BaseController`, and both ([#3904](https://github.com/MetaMask/core/pull/3904))
+
+### Changed
+
+- **BREAKING:** Passing a non-controller into `controllers` constructor option now throws an error ([#3904](https://github.com/MetaMask/core/pull/3904))
+- **BREAKING:** The `AllowedActions` parameter of the `ComposableControllerMessenger` type is narrowed from `string` to `never`, as `ComposableController` does not use any external controller actions. ([#3904](https://github.com/MetaMask/core/pull/3904))
+- Add `@metamask/utils` ^8.3.0 as a dependency. ([#3904](https://github.com/MetaMask/core/pull/3904))
+
+### Removed
+
+- **BREAKING:** Remove `ControllerList` as an exported type. ([#3904](https://github.com/MetaMask/core/pull/3904))
+
 ## [5.0.1]
@@ -12,0 +27,0 @@

dist/ComposableController.d.ts

 import { BaseController, BaseControllerV1 } from '@metamask/base-controller';
-import type { ControllerStateChangeEvent, RestrictedControllerMessenger } from '@metamask/base-controller';
+import type { RestrictedControllerMessenger, BaseState, BaseConfig, StateConstraint } from '@metamask/base-controller';
+import type { Patch } from 'immer';
 export declare const controllerName = "ComposableController";
-declare type ControllerInstance = BaseControllerV1<any, any> | {
+/**
+ * A type encompassing all controller instances that extend from `BaseControllerV1`.
+ */
+export declare type BaseControllerV1Instance = BaseControllerV1<any, any>;
+/**
+ * A type encompassing all controller instances that extend from `BaseController` (formerly `BaseControllerV2`).
+ *
+ * The `BaseController` class itself can't be used directly as a type representing all of its subclasses,
+ * because the generic parameters it expects require knowing the exact shape of the controller's state and messenger.
+ *
+ * Instead, we look for an object with the `BaseController` properties that we use in the ComposableController (name and state).
+ */
+export declare type BaseControllerV2Instance = {
     name: string;
-    state: Record<string, unknown>;
+    state: StateConstraint;
 };
 /**
- * List of child controller instances
+ * A type encompassing all controller instances that extend from `BaseControllerV1` or `BaseController`.
  */
-export declare type ControllerList = ControllerInstance[];
+export declare type ControllerInstance = BaseControllerV1Instance | BaseControllerV2Instance;
+/**
+ * Determines if the given controller is an instance of BaseControllerV1
+ * @param controller - Controller instance to check
+ * @returns True if the controller is an instance of BaseControllerV1
+ * TODO: Deprecate once `BaseControllerV2` migrations are completed for all controllers.
+ */
+export declare function isBaseControllerV1(controller: ControllerInstance): controller is BaseControllerV1<BaseConfig & Record<string, unknown>, BaseState & Record<string, unknown>>;
+/**
+ * Determines if the given controller is an instance of BaseController
+ * @param controller - Controller instance to check
+ * @returns True if the controller is an instance of BaseController
+ */
+export declare function isBaseController(controller: ControllerInstance): controller is BaseController<never, never, never>;
 export declare type ComposableControllerState = {
-    [name: string]: ControllerInstance['state'];
+    [name: string]: Record<string, any>;
 };
-export declare type ComposableControllerStateChangeEvent = ControllerStateChangeEvent<typeof controllerName, ComposableControllerState>;
+export declare type ComposableControllerStateChangeEvent = {
+    type: `${typeof controllerName}:stateChange`;
+    payload: [ComposableControllerState, Patch[]];
+};
 export declare type ComposableControllerEvents = ComposableControllerStateChangeEvent;
-export declare type ComposableControllerMessenger = RestrictedControllerMessenger<typeof controllerName, never, ControllerStateChangeEvent<string, Record<string, unknown>>, string, string>;
+declare type AnyControllerStateChangeEvent = {
+    type: `${string}:stateChange`;
+    payload: [ControllerInstance['state'], Patch[]];
+};
+declare type AllowedEvents = AnyControllerStateChangeEvent;
+export declare type ComposableControllerMessenger = RestrictedControllerMessenger<typeof controllerName, never, ComposableControllerEvents | AllowedEvents, never, AllowedEvents['type']>;
 /**
@@ -31,15 +65,7 @@ * Controller that can be used to compose multiple controllers together.
     constructor({ controllers, messenger, }: {
-        controllers: ControllerList;
+        controllers: ControllerInstance[];
         messenger: ComposableControllerMessenger;
     });
-    /**
-     * Flat state representation, one that isn't keyed
-     * of controller name. Instead, all child controller state is merged
-     * together into a single, flat object.
-     *
-     * @returns Merged state representation of all child controllers.
-     */
-    get flatState(): {};
 }
 export default ComposableController;
 //# sourceMappingURL=ComposableController.d.ts.map

dist/ComposableController.js

 "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) {
@@ -13,6 +7,7 @@ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
 };
-var _ComposableController_instances, _ComposableController_controllers, _ComposableController_updateChildController;
+var _ComposableController_instances, _ComposableController_updateChildController;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComposableController = exports.controllerName = void 0;
+exports.ComposableController = exports.isBaseController = exports.isBaseControllerV1 = exports.controllerName = void 0;
 const base_controller_1 = require("@metamask/base-controller");
+const utils_1 = require("@metamask/utils");
 exports.controllerName = 'ComposableController';
@@ -23,7 +18,30 @@ /**
  * @returns True if the controller is an instance of BaseControllerV1
+ * TODO: Deprecate once `BaseControllerV2` migrations are completed for all controllers.
  */
 function isBaseControllerV1(controller) {
-    return controller instanceof base_controller_1.BaseControllerV1;
+    return ('name' in controller &&
+        typeof controller.name === 'string' &&
+        'defaultConfig' in controller &&
+        typeof controller.defaultConfig === 'object' &&
+        'defaultState' in controller &&
+        typeof controller.defaultState === 'object' &&
+        'disabled' in controller &&
+        typeof controller.disabled === 'boolean' &&
+        controller instanceof base_controller_1.BaseControllerV1);
 }
+exports.isBaseControllerV1 = isBaseControllerV1;
 /**
+ * Determines if the given controller is an instance of BaseController
+ * @param controller - Controller instance to check
+ * @returns True if the controller is an instance of BaseController
+ */
+function isBaseController(controller) {
+    return ('name' in controller &&
+        typeof controller.name === 'string' &&
+        'state' in controller &&
+        typeof controller.state === 'object' &&
+        controller instanceof base_controller_1.BaseController);
+}
+exports.isBaseController = isBaseController;
+/**
  * Controller that can be used to compose multiple controllers together.
@@ -45,3 +63,5 @@ */
             name: exports.controllerName,
-            metadata: {},
+            metadata: controllers.reduce((metadata, controller) => (Object.assign(Object.assign({}, metadata), { [controller.name]: isBaseController(controller)
+                    ? controller.metadata
+                    : { persist: true, anonymous: true } })), {}),
             state: controllers.reduce((state, controller) => {
@@ -53,23 +73,7 @@ return Object.assign(Object.assign({}, state), { [controller.name]: controller.state });
         _ComposableController_instances.add(this);
-        _ComposableController_controllers.set(this, []);
-        __classPrivateFieldSet(this, _ComposableController_controllers, controllers, "f");
-        __classPrivateFieldGet(this, _ComposableController_controllers, "f").forEach((controller) => __classPrivateFieldGet(this, _ComposableController_instances, "m", _ComposableController_updateChildController).call(this, controller));
+        controllers.forEach((controller) => __classPrivateFieldGet(this, _ComposableController_instances, "m", _ComposableController_updateChildController).call(this, controller));
     }
-    /**
-     * Flat state representation, one that isn't keyed
-     * of controller name. Instead, all child controller state is merged
-     * together into a single, flat object.
-     *
-     * @returns Merged state representation of all child controllers.
-     */
-    get flatState() {
-        let flatState = {};
-        for (const controller of __classPrivateFieldGet(this, _ComposableController_controllers, "f")) {
-            flatState = Object.assign(Object.assign({}, flatState), controller.state);
-        }
-        return flatState;
-    }
 }
 exports.ComposableController = ComposableController;
-_ComposableController_controllers = new WeakMap(), _ComposableController_instances = new WeakSet(), _ComposableController_updateChildController = function _ComposableController_updateChildController(controller) {
+_ComposableController_instances = new WeakSet(), _ComposableController_updateChildController = function _ComposableController_updateChildController(controller) {
     const { name } = controller;
@@ -81,9 +85,14 @@ if (isBaseControllerV1(controller)) {
     }
-    else {
-        this.messagingSystem.subscribe(`${String(name)}:stateChange`, (childState) => {
-            this.update((state) => (Object.assign(Object.assign({}, state), { [name]: childState })));
+    else if (isBaseController(controller)) {
+        this.messagingSystem.subscribe(`${name}:stateChange`, (childState) => {
+            if ((0, utils_1.isValidJson)(childState)) {
+                this.update((state) => (Object.assign(Object.assign({}, state), { [name]: childState })));
+            }
         });
     }
+    else {
+        throw new Error('Invalid controller: controller must extend from BaseController or BaseControllerV1');
+    }
 };
 exports.default = ComposableController;
 //# sourceMappingURL=ComposableController.js.map

dist/index.d.ts

@@ -1,3 +0,3 @@
-export type { ControllerList, ComposableControllerState, ComposableControllerStateChangeEvent, ComposableControllerEvents, ComposableControllerMessenger, } from './ComposableController';
-export { ComposableController } from './ComposableController';
+export type { BaseControllerV1Instance, BaseControllerV2Instance, ControllerInstance, ComposableControllerState, ComposableControllerStateChangeEvent, ComposableControllerEvents, ComposableControllerMessenger, } from './ComposableController';
+export { ComposableController, isBaseController, isBaseControllerV1, } from './ComposableController';
 //# sourceMappingURL=index.d.ts.map

dist/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComposableController = void 0;
+exports.isBaseControllerV1 = exports.isBaseController = exports.ComposableController = void 0;
 var ComposableController_1 = require("./ComposableController");
 Object.defineProperty(exports, "ComposableController", { enumerable: true, get: function () { return ComposableController_1.ComposableController; } });
+Object.defineProperty(exports, "isBaseController", { enumerable: true, get: function () { return ComposableController_1.isBaseController; } });
+Object.defineProperty(exports, "isBaseControllerV1", { enumerable: true, get: function () { return ComposableController_1.isBaseControllerV1; } });
 //# sourceMappingURL=index.js.map

package.json

 {
   "name": "@metamask-previews/composable-controller",
-  "version": "5.0.1-preview.d392f46",
+  "version": "5.0.1-preview.d78968a2",
   "description": "Consolidates the state from multiple controllers into one",
@@ -34,6 +34,8 @@ "keywords": [
   "dependencies": {
-    "@metamask/base-controller": "^4.1.1"
+    "@metamask/base-controller": "^4.1.1",
+    "@metamask/utils": "^8.3.0"
   },
   "devDependencies": {
     "@metamask/auto-changelog": "^3.4.4",
+    "@metamask/json-rpc-engine": "^7.3.3",
     "@types/jest": "^27.4.1",
@@ -40,0 +42,0 @@ "deepmerge": "^4.2.2",

No alert changes

Improved metrics

Total package byte prevSize

30041

increased by31.01%

Lines of code

170

increased by27.82%

Worsened metrics

Dependency count

2

increased by100%

Dev dependency count

11

increased by10%

Dependency changes

• + Added@metamask/utils@^8.3.0