@dxos/app-framework 0.7.5-main.9d2a38b → 0.7.5-main.b19bfc8

package/src/common/layout.ts

@@ -2,83 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
+import { Schema as S } from '@effect/schema';
 
 import { Label } from '../plugin-intent';
 
-//
-// Provides
-//
-
-export const Toast = S.Struct({
-  id: S.String,
-  title: S.optional(Label),
-  description: S.optional(Label),
-  icon: S.optional(S.String),
-  duration: S.optional(S.Number),
-  closeLabel: S.optional(Label),
-  actionLabel: S.optional(Label),
-  actionAlt: S.optional(Label),
-  // TODO(wittjosiah): Make class with customizable method?
-  onAction: S.optional(S.Any),
-});
-
-export type Toast = S.Schema.Type<typeof Toast>;
-
-/**
- * Basic state provided by a layout plugin.
- *
- * Layout provides the state of global UI landmarks, such as the sidebar, dialog, and popover.
- * Generally only one dialog or popover should be open at a time, a layout plugin should manage this.
- * For other landmarks, such as toasts, rendering them in the layout prevents them from unmounting when navigating.
- */
-
-const LayoutMode = S.Union(S.Literal('deck'), S.Literal('solo'), S.Literal('fullscreen'));
-export const isLayoutMode = (value: any): value is LayoutMode => S.is(LayoutMode)(value);
-export type LayoutMode = S.Schema.Type<typeof LayoutMode>;
-
-export const Layout = S.mutable(
-  S.Struct({
-    layoutMode: LayoutMode,
-
-    sidebarOpen: S.Boolean,
-    complementarySidebarOpen: S.Boolean,
-    /**
-     * @deprecated Data to be passed to the complementary sidebar Surface.
-     */
-    complementarySidebarContent: S.optional(S.Any),
-
-    dialogOpen: S.Boolean,
-    /**
-     * Data to be passed to the dialog Surface.
-     */
-    dialogContent: S.optional(S.Any),
-    // TODO(wittjosiah): Custom properties?
-    dialogBlockAlign: S.optional(S.Literal('start', 'center')),
-    dialogType: S.optional(S.Literal('default', 'alert')),
-
-    popoverOpen: S.Boolean,
-    /**
-     * Data to be passed to the popover Surface.
-     */
-    popoverContent: S.optional(S.Any),
-    popoverAnchorId: S.optional(S.String),
-
-    toasts: S.mutable(S.Array(Toast)),
-
-    /**
-     * The identifier of a component to scroll into view when it is mounted.
-     */
-    scrollIntoView: S.optional(S.String),
-  }),
-);
-
-export type Layout = S.Schema.Type<typeof Layout>;
-
-//
-// Intents
-//
-
 export const LAYOUT_PLUGIN = 'dxos.org/plugin/layout';
 export const LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
 
@@ -86,71 +13,225 @@ export const LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
  * Expected payload for layout actions.
  */
 export namespace LayoutAction {
-  export class SetLayout extends S.TaggedClass<SetLayout>()(`${LAYOUT_ACTION}/set-layout`, {
+  export const UPDATE_LAYOUT = `${LAYOUT_ACTION}/update-layout`;
+
+  /**
+   * Generic layout action.
+   */
+  export class UpdateLayout extends S.TaggedClass<UpdateLayout>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.String.annotations({ description: 'The part of the layout to mutate.' }),
+      subject: S.optional(S.Any.annotations({ description: 'The subject of the layout update.' })),
+      options: S.optional(
+        S.Record({ key: S.String, value: S.Any }).annotations({
+          description: 'Additional options for the layout action.',
+        }),
+      ),
+    }),
+    output: S.Void,
+  }) {}
+
+  //
+  // Common layout actions.
+  //
+
+  // NOTE: These are layout actions which are currently in common use.
+  //  They constrain the generic layout action types to provide additional type safety.
+  //  However, they all follow the same generic structure and intent id.
+  //  This allows for plugins to update the layout without depending on a specific layout plugin.
+  //  The expectation is that other norms other than these will emerge over time.
+
+  export class SetLayoutMode extends S.TaggedClass<SetLayoutMode>()(UPDATE_LAYOUT, {
     input: S.Struct({
-      /**
-       * Element to set the state of.
-       */
-      element: S.Literal('fullscreen', 'sidebar', 'complementary', 'dialog', 'popover', 'toast'),
-
-      /**
-       * Whether the element is on or off.
-       *
-       * If omitted, the element's state will be toggled or set based on other provided data.
-       * For example, if `component` is provided, the state will be set to `true`.
-       */
-      state: S.optional(S.Boolean),
-
-      /**
-       * Component to render in the dialog or popover.
-       */
-      component: S.optional(S.String),
-
-      /**
-       * Data to be passed to the dialog or popover Surface.
-       */
-      subject: S.optional(S.Any),
-
-      /**
-       * Anchor ID for the popover.
-       */
-      anchorId: S.optional(S.String),
-
-      // TODO(wittjosiah): Custom properties?
-
-      /**
-       * Block alignment for the dialog.
-       */
-      dialogBlockAlign: S.optional(S.Literal('start', 'center')),
-
-      /**
-       * Type of dialog.
-       */
-      dialogType: S.optional(S.Literal('default', 'alert')),
+      part: S.Literal('mode').annotations({ description: 'Setting the layout mode.' }),
+      subject: S.optional(S.String.annotations({ description: 'Item which is the subject of the new layout mode.' })),
+      options: S.Union(
+        S.Struct({ mode: S.String.annotations({ description: 'The new layout mode.' }) }),
+        S.Struct({ revert: S.Boolean.annotations({ description: 'Revert to the previous layout mode.' }) }),
+      ),
     }),
     output: S.Void,
   }) {}
 
-  // TODO(wittjosiah): Do all these need to be separate actions?
+  export class UpdateSidebar extends S.TaggedClass<UpdateSidebar>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('sidebar').annotations({ description: 'Updating the sidebar.' }),
+      subject: S.optional(S.String.annotations({ description: 'URI of the component to display in the sidebar.' })),
+      options: S.optional(
+        S.Struct({
+          state: S.Literal('closed', 'collapsed', 'expanded').annotations({
+            description: 'Whether the sidebar is closed, collapsed, or expanded.',
+          }),
+        }),
+      ),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class UpdateComplementary extends S.TaggedClass<UpdateComplementary>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('complementary').annotations({ description: 'Updating the complementary sidebar.' }),
+      subject: S.optional(
+        S.String.annotations({ description: 'URI of the component to display in the complementary area.' }),
+      ),
+      options: S.optional(
+        S.Struct({
+          state: S.Literal('closed', 'collapsed', 'expanded').annotations({
+            description: 'Whether the complementary sidebar is closed, collapsed, or expanded.',
+          }),
+        }),
+      ),
+    }),
+    output: S.Void,
+  }) {}
 
-  export class SetLayoutMode extends S.TaggedClass<SetLayoutMode>()(`${LAYOUT_ACTION}/set-layout-mode`, {
-    input: S.Union(
-      S.Struct({
-        layoutMode: LayoutMode,
+  export class UpdateDialog extends S.TaggedClass<UpdateDialog>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('dialog').annotations({ description: 'Updating the dialog.' }),
+      subject: S.optional(S.String.annotations({ description: 'URI of the component to display in the dialog.' })),
+      options: S.Struct({
+        state: S.optional(S.Boolean.annotations({ description: 'Whether the dialog is open or closed.' })),
+        blockAlign: S.optional(
+          S.Literal('start', 'center', 'end').annotations({ description: 'The alignment of the dialog.' }),
+        ),
+        type: S.optional(S.Literal('default', 'alert').annotations({ description: 'The type of dialog.' })),
+        props: S.optional(
+          S.Record({ key: S.String, value: S.Any }).annotations({
+            description: 'Additional props for the dialog.',
+          }),
+        ),
       }),
-      S.Struct({
-        revert: S.Literal(true),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class UpdatePopover extends S.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('popover').annotations({ description: 'Updating the popover.' }),
+      subject: S.optional(S.String.annotations({ description: 'URI of the component to display in the popover.' })),
+      options: S.Struct({
+        anchorId: S.String.annotations({ description: 'The id of the element to anchor the popover to.' }),
+        side: S.optional(
+          S.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }),
+        ),
+        state: S.optional(S.Boolean.annotations({ description: 'Whether the popover is open or closed.' })),
+        props: S.optional(
+          S.Record({ key: S.String, value: S.Any }).annotations({
+            description: 'Additional props for the popover.',
+          }),
+        ),
       }),
+    }),
+    output: S.Void,
+  }) {}
+
+  export const Toast = S.Struct({
+    id: S.String.annotations({ description: 'The id of the toast.' }),
+    title: S.optional(Label.annotations({ description: 'The title of the toast.' })),
+    description: S.optional(Label.annotations({ description: 'The description of the toast.' })),
+    icon: S.optional(S.String.annotations({ description: 'The icon of the toast.' })),
+    duration: S.optional(S.Number.annotations({ description: 'The duration of the toast.' })),
+    closeLabel: S.optional(Label.annotations({ description: 'The label of the close button.' })),
+    actionLabel: S.optional(Label.annotations({ description: 'The label of the action button.' })),
+    actionAlt: S.optional(Label.annotations({ description: 'The alt text of the action button.' })),
+    onAction: S.optional(
+      S.Any.annotations({ description: 'The action to perform when the action button is clicked.' }),
     ),
+  });
+
+  export interface Toast extends Omit<S.Schema.Type<typeof Toast>, 'onAction'> {
+    onAction?: () => void;
+  }
+
+  export class AddToast extends S.TaggedClass<AddToast>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('toast').annotations({ description: 'Adding a toast.' }),
+      subject: Toast.annotations({ description: 'The toast to add.' }),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class SwitchWorkspace extends S.TaggedClass<SwitchWorkspace>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('workspace').annotations({ description: 'Switching the workspace.' }),
+      subject: S.String.annotations({ description: 'The id of the workspace to switch to.' }),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class RevertWorkspace extends S.TaggedClass<RevertWorkspace>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('workspace').annotations({ description: 'Switching the workspace.' }),
+      options: S.Struct({
+        revert: S.Literal(true).annotations({ description: 'Revert to the previous workspace.' }),
+      }),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class Open extends S.TaggedClass<Open>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('main').annotations({ description: 'Opening an item in the main content area.' }),
+      subject: S.Array(S.String.annotations({ description: 'Ids of the items to open.' })),
+      options: S.optional(
+        S.Struct({
+          state: S.optional(S.Literal(true).annotations({ description: 'The items are being added.' })),
+          key: S.optional(
+            S.String.annotations({ description: 'If provided, will replace item with a matching key (id prefix).' }),
+          ),
+          scrollIntoView: S.optional(S.Boolean.annotations({ description: 'Scroll the items into view.' })),
+          pivotId: S.optional(S.String.annotations({ description: 'The id of the item to place new items next to.' })),
+          positioning: S.optional(
+            S.Union(
+              S.Literal('start').annotations({ description: 'The items are being added before the pivot item.' }),
+              S.Literal('end').annotations({ description: 'The items are being added after the pivot item.' }),
+            ),
+          ),
+        }),
+      ),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class Set extends S.TaggedClass<Set>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('main').annotations({ description: 'Setting items in the main content area.' }),
+      subject: S.Array(S.String.annotations({ description: 'Ids of the items to set.' })),
+      options: S.Struct({
+        override: S.Literal(true).annotations({ description: 'Override the current items in the main content area.' }),
+      }),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class Close extends S.TaggedClass<Close>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('main').annotations({ description: 'Closing items in the main content area.' }),
+      subject: S.Array(S.String.annotations({ description: 'Ids of the items to close.' })),
+      options: S.Struct({
+        state: S.Literal(false).annotations({ description: 'The items are being removed.' }),
+      }),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class ScrollIntoView extends S.TaggedClass<ScrollIntoView>()(UPDATE_LAYOUT, {
+    input: S.Struct({
+      part: S.Literal('current').annotations({ description: 'Setting the current item' }),
+      subject: S.optional(S.String.annotations({ description: 'The id of the item to set as current.' })),
+      options: S.optional(
+        S.Record({ key: S.String, value: S.Any }).annotations({
+          description: 'Additional options for the scroll into view.',
+        }),
+      ),
+    }),
     output: S.Void,
   }) {}
 
-  export class ScrollIntoView extends S.TaggedClass<ScrollIntoView>()(`${LAYOUT_ACTION}/scroll-into-view`, {
+  export class Expose extends S.TaggedClass<Expose>()(UPDATE_LAYOUT, {
     input: S.Struct({
-      id: S.optional(S.String),
-      // TODO(wittjosiah): Factor out to thread scroll into view action?
-      cursor: S.optional(S.String),
-      ref: S.optional(S.String),
+      part: S.Literal('navigation').annotations({ description: 'Exposing an item in the navigation area.' }),
+      subject: S.String.annotations({ description: 'The id of the item to expose.' }),
     }),
     output: S.Void,
   }) {}

package/src/common/surface.ts

@@ -4,7 +4,7 @@
 
 import { type JSX, type ForwardedRef, type PropsWithChildren, type ReactNode } from 'react';
 
-import { type GuardedType, type MakeOptional, type Disposition } from '@dxos/util';
+import { type GuardedType, type MakeOptional, type Position } from '@dxos/util';
 
 import { type ErrorBoundary } from '../react';
 
@@ -73,7 +73,7 @@ export type SurfaceComponent<T extends Record<string, any> = Record<string, unkn
 export type SurfaceDefinition<T extends Record<string, any> = any> = Readonly<{
   id: string;
   role: string | string[];
-  disposition?: Disposition;
+  position?: Position;
   filter?: (data: Record<string, unknown>) => data is T;
   component: SurfaceComponent<GuardedType<SurfaceDefinition<T>['filter']>>;
 }>;

package/src/common/translations.ts

@@ -2,17 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { z } from 'zod';
+import { Schema as S } from '@effect/schema';
 
-// TODO(burdon): Replace zod with effect.
-export const ResourceKey = z.union([z.string(), z.record(z.any())]);
-export type ResourceKey = z.infer<typeof ResourceKey>;
+export const ResourceKey = S.Union(S.String, S.Record({ key: S.String, value: S.Any }));
+export type ResourceKey = S.Schema.Type<typeof ResourceKey>;
 
-export const ResourceLanguage = z.record(ResourceKey);
-export type ResourceLanguage = z.infer<typeof ResourceLanguage>;
+export const ResourceLanguage = S.Record({ key: S.String, value: ResourceKey });
+export type ResourceLanguage = S.Schema.Type<typeof ResourceLanguage>;
 
 /**
  * A resource is a collection of translations for a language.
  */
-export const Resource = z.record(ResourceLanguage);
-export type Resource = z.infer<typeof Resource>;
+export const Resource = S.Record({ key: S.String, value: ResourceLanguage });
+export type Resource = S.Schema.Type<typeof Resource>;

package/src/core/capabilities.ts

@@ -79,17 +79,20 @@ export const contributes = <T>(
   return { interface: interfaceDef, implementation, deactivate } satisfies Capability<T>;
 };
 
-type LazyCapability<T, U> = () => Promise<{ default: (props: T) => MaybePromise<Capability<U>> }>;
+type LoadCapability<T, U> = () => Promise<{ default: (props: T) => MaybePromise<Capability<U>> }>;
+type LoadCapabilities<T> = () => Promise<{ default: (props: T) => MaybePromise<AnyCapability[]> }>;
+// TODO(wittjosiah): Not having the array be `any` causes type errors when using the lazy capability.
+type LazyCapability<T, U> = (props?: T) => Promise<() => Promise<Capability<U> | AnyCapability[]>>;
 
 /**
  * Helper to define a lazily loaded implementation of a capability.
  */
 export const lazy =
-  <T, U>(c: LazyCapability<T, U>) =>
-  (props?: T): Promise<Capability<U>> =>
-    c().then(({ default: getCapability }) => {
-      return getCapability(props as T);
-    });
+  <T, U>(c: LoadCapability<T, U> | LoadCapabilities<T>): LazyCapability<T, U> =>
+  async (props?: T) => {
+    const { default: getCapability } = await c();
+    return async () => getCapability(props as T);
+  };
 
 /**
  * Context which is passed to plugins, allowing them to interact with each other.
@@ -136,7 +139,11 @@ export class PluginsContext {
     }
 
     current.push(new CapabilityImpl(moduleId, implementation));
-    log('capability contributed', { id: interfaceDef.identifier, count: untracked(() => current.length) });
+    log('capability contributed', {
+      id: interfaceDef.identifier,
+      moduleId,
+      count: untracked(() => current.length),
+    });
   }
 
   /**
@@ -152,6 +159,8 @@ export class PluginsContext {
     if (index !== -1) {
       current.splice(index, 1);
       log('capability removed', { id: interfaceDef.identifier, count: untracked(() => current.length) });
+    } else {
+      log.warn('capability not removed', { id: interfaceDef.identifier });
     }
   }
 

package/src/core/manager.test.ts

@@ -62,10 +62,10 @@ describe('PluginManager', () => {
     const Test = definePlugin(testMeta, [Hello]);
 
     const manager = new PluginManager({ plugins: [Test], core: [], pluginLoader });
-    manager.enable(testMeta.id);
+    await manager.enable(testMeta.id);
     expect(manager.enabled).toEqual([Test.meta.id]);
     expect(manager.modules).toEqual([Hello]);
-    manager.disable(testMeta.id);
+    await manager.disable(testMeta.id);
     expect(manager.enabled).toEqual([]);
     expect(manager.modules).toEqual([]);
   });
@@ -111,7 +111,8 @@ describe('PluginManager', () => {
     const Fail = defineModule({
       id: 'dxos.org/test/fail',
       activatesOn: FailEvent,
-      activate: async () => raise(new Error('test')),
+      // TODO(wittjosiah): Test and catch more failure modes.
+      activate: async () => async () => raise(new Error('test')),
     });
     plugins = [definePlugin(testMeta, [Hello, Fail])];
 
@@ -287,7 +288,7 @@ describe('PluginManager', () => {
         id: 'dxos.org/test/count',
         activatesOn: Events.Startup,
         activatesBefore: [CountEvent],
-        activate: (context) => {
+        activate: async (context) => async () => {
           computeTotal(context);
           return contributes(Total, state);
         },
@@ -328,57 +329,18 @@ describe('PluginManager', () => {
 
     {
       await manager.disable(Test.meta.id);
-      expect(manager.active).toEqual([...Test.modules.map((m) => m.id), Count.meta.id]);
-      expect(manager.pendingReset).toEqual([CountEvent.id, Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(6);
-    }
-
-    {
-      await manager.reset(CountEvent);
-      expect(manager.active).toEqual([Count.meta.id]);
-      expect(manager.pendingReset).toEqual([Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(6);
-    }
-
-    {
-      await manager.reset(Events.Startup);
       expect(manager.active).toEqual([Count.meta.id]);
       expect(manager.pendingReset).toEqual([]);
 
       const totals = manager.context.requestCapabilities(Total);
       expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(0);
+      // Total doesn't change because it is not reactive.
+      expect(totals[0].total).toEqual(6);
     }
 
     {
       await manager.enable(Test.meta.id);
-      expect(manager.active).toEqual([Count.meta.id]);
-      expect(manager.pendingReset).toEqual([CountEvent.id, Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(0);
-    }
-
-    {
-      await manager.reset(CountEvent);
       expect(manager.active).toEqual([Count.meta.id, ...Test.modules.map((m) => m.id)]);
-      expect(manager.pendingReset).toEqual([Events.Startup.id]);
-
-      const totals = manager.context.requestCapabilities(Total);
-      expect(totals).toHaveLength(1);
-      expect(totals[0].total).toEqual(0);
-    }
-
-    {
-      await manager.reset(Events.Startup);
-      expect(manager.active).toEqual([...Test.modules.map((m) => m.id), Count.meta.id]);
       expect(manager.pendingReset).toEqual([]);
 
       const totals = manager.context.requestCapabilities(Total);
@@ -464,9 +426,6 @@ describe('PluginManager', () => {
     using activeUpdates = updateCounter(() => {
       const _ = manager.active.length;
     });
-    using pendingRemovalUpdates = updateCounter(() => {
-      const _ = manager.pendingRemoval.length;
-    });
     using eventsFiredUpdates = updateCounter(() => {
       const _ = manager.eventsFired.length;
     });
@@ -477,7 +436,6 @@ describe('PluginManager', () => {
     expect(enabledUpdates.count).toEqual(0);
     expect(modulesUpdates.count).toEqual(0);
     expect(activeUpdates.count).toEqual(0);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(0);
     expect(pendingResetUpdates.count).toEqual(0);
 
@@ -486,7 +444,6 @@ describe('PluginManager', () => {
     expect(enabledUpdates.count).toEqual(1);
     expect(modulesUpdates.count).toEqual(1);
     expect(activeUpdates.count).toEqual(0);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(0);
     expect(pendingResetUpdates.count).toEqual(0);
 
@@ -495,7 +452,6 @@ describe('PluginManager', () => {
     expect(enabledUpdates.count).toEqual(1);
     expect(modulesUpdates.count).toEqual(1);
     expect(activeUpdates.count).toEqual(1);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(1);
     expect(pendingResetUpdates.count).toEqual(0);
 
@@ -503,17 +459,15 @@ describe('PluginManager', () => {
     expect(pluginUpdates.count).toEqual(2);
     expect(enabledUpdates.count).toEqual(2);
     expect(modulesUpdates.count).toEqual(2);
-    expect(activeUpdates.count).toEqual(1);
-    expect(pendingRemovalUpdates.count).toEqual(0);
+    expect(activeUpdates.count).toEqual(2);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(1);
+    expect(pendingResetUpdates.count).toEqual(2);
 
     await manager.activate(CountEvent);
     expect(pluginUpdates.count).toEqual(2);
     expect(enabledUpdates.count).toEqual(2);
     expect(modulesUpdates.count).toEqual(2);
     expect(activeUpdates.count).toEqual(2);
-    expect(pendingRemovalUpdates.count).toEqual(0);
     expect(eventsFiredUpdates.count).toEqual(1);
     expect(pendingResetUpdates.count).toEqual(2);
 
@@ -521,47 +475,42 @@ describe('PluginManager', () => {
     expect(pluginUpdates.count).toEqual(3);
     expect(enabledUpdates.count).toEqual(3);
     expect(modulesUpdates.count).toEqual(3);
-    expect(activeUpdates.count).toEqual(2);
-    expect(pendingRemovalUpdates.count).toEqual(0);
+    expect(activeUpdates.count).toEqual(3);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(3);
+    expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.reset(CountEvent);
     expect(pluginUpdates.count).toEqual(3);
     expect(enabledUpdates.count).toEqual(3);
     expect(modulesUpdates.count).toEqual(3);
-    // Starts at 2, plus deactivates 2, plus activates 3.
-    expect(activeUpdates.count).toEqual(7);
-    expect(pendingRemovalUpdates.count).toEqual(0);
+    // Starts at 3, plus deactivates 3, plus activates 3.
+    expect(activeUpdates.count).toEqual(9);
     expect(eventsFiredUpdates.count).toEqual(1);
     expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.disable(One.meta.id);
     expect(pluginUpdates.count).toEqual(3);
     expect(enabledUpdates.count).toEqual(4);
-    expect(modulesUpdates.count).toEqual(3);
-    expect(activeUpdates.count).toEqual(7);
-    expect(pendingRemovalUpdates.count).toEqual(1);
+    expect(modulesUpdates.count).toEqual(4);
+    expect(activeUpdates.count).toEqual(10);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(5);
+    expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.remove(One.meta.id);
     expect(pluginUpdates.count).toEqual(4);
     expect(enabledUpdates.count).toEqual(4);
-    expect(modulesUpdates.count).toEqual(3);
-    expect(activeUpdates.count).toEqual(7);
-    expect(pendingRemovalUpdates.count).toEqual(1);
+    expect(modulesUpdates.count).toEqual(4);
+    expect(activeUpdates.count).toEqual(10);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(5);
+    expect(pendingResetUpdates.count).toEqual(4);
 
     await manager.reset(CountEvent);
     expect(pluginUpdates.count).toEqual(4);
     expect(enabledUpdates.count).toEqual(4);
     expect(modulesUpdates.count).toEqual(4);
-    // Starts at 7, plus deactivates 3, plus activates 2.
-    expect(activeUpdates.count).toEqual(12);
-    expect(pendingRemovalUpdates.count).toEqual(2);
+    // Starts at 10, plus deactivates 2, plus activates 2.
+    expect(activeUpdates.count).toEqual(14);
     expect(eventsFiredUpdates.count).toEqual(1);
-    expect(pendingResetUpdates.count).toEqual(6);
+    expect(pendingResetUpdates.count).toEqual(4);
   });
 });