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

package/src/plugin-intent/actions.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { S } from '@dxos/echo-schema';
+
+import { Label } from './intent';
+
+export const INTENT_PLUGIN = 'dxos.org/plugin/intent';
+export const INTENT_ACTION = `${INTENT_PLUGIN}/action`;
+
+export namespace IntentAction {
+  /**
+   * Fired after an intent is dispatched if the intent is undoable.
+   */
+  export class ShowUndo extends S.TaggedClass<ShowUndo>()(`${INTENT_ACTION}/show-undo`, {
+    input: S.Struct({
+      message: Label,
+    }),
+    output: S.Void,
+  }) {}
+}

package/src/plugin-intent/errors.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// TODO(wittjosiah): Reconcile with @dxos/protocols. Factor out errors.
+
+/**
+ * NOTE: Messages should be sentences (Start with a capital letter and end with a period).
+ * Errors can optionally include a JSON context object.
+ */
+export class BaseError extends Error {
+  constructor(
+    readonly code: string,
+    message?: string,
+    readonly context?: Record<string, any>,
+  ) {
+    // TODO(dmaretskyi): Error.cause.
+    super(message ?? code);
+    this.name = code;
+    // NOTE: Restores prototype chain (https://stackoverflow.com/a/48342359).
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class NoResolversError extends BaseError {
+  constructor(action: string) {
+    super('NO_RESOLVERS', 'No resolvers were found for the action', { action });
+  }
+}
+
+export class CycleDetectedError extends BaseError {
+  constructor(context?: Record<string, any>) {
+    super(
+      'CYCLE_DETECTED',
+      'Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.',
+      context,
+    );
+  }
+}

package/src/{plugins/plugin-intent → plugin-intent}/index.ts

@@ -2,12 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-import { IntentPlugin } from './IntentPlugin';
-
+export * from './actions';
 export * from './intent';
 export * from './intent-dispatcher';
-export * from './provides';
-
 export * from './IntentContext';
-
-export default IntentPlugin;
+export * from './IntentPlugin';

package/src/{plugins/plugin-intent → plugin-intent}/intent-dispatcher.test.ts

@@ -8,11 +8,11 @@ import { describe, expect, test } from 'vitest';
 import { S } from '@dxos/echo-schema';
 
 import { chain, createIntent } from './intent';
-import { createDispatcher, createResolver } from './intent-dispatcher';
+import { type AnyIntentResolver, createDispatcher, createResolver } from './intent-dispatcher';
 
 describe('Intent dispatcher', () => {
   test('throws error if no resolver found', async () => {
-    const { dispatchPromise } = createDispatcher({});
+    const { dispatchPromise } = createDispatcher(() => []);
     const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(data).toBe(undefined);
@@ -20,7 +20,7 @@ describe('Intent dispatcher', () => {
   });
 
   test('matches intent to resolver and executes', async () => {
-    const { dispatchPromise } = createDispatcher({ test: [toStringResolver] });
+    const { dispatchPromise } = createDispatcher(() => [toStringResolver]);
     const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(error).toBe(undefined);
@@ -28,18 +28,19 @@ describe('Intent dispatcher', () => {
   });
 
   test('update resolvers', async () => {
-    const { dispatchPromise, registerResolver } = createDispatcher({ test: [] });
+    const resolvers: AnyIntentResolver[] = [];
+    const { dispatchPromise } = createDispatcher(() => resolvers);
     const { error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(error).toBeInstanceOf(Error);
 
-    const removeResolver = registerResolver('test', toStringResolver);
+    resolvers.push(toStringResolver);
 
     const { data } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(data?.string).toBe('1');
 
-    removeResolver();
+    resolvers.splice(resolvers.indexOf(toStringResolver), 1);
 
     {
       const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
@@ -50,34 +51,34 @@ describe('Intent dispatcher', () => {
   });
 
   test('compose intent effects', async () => {
-    const { dispatch } = createDispatcher({ test: [computeResolver] });
+    const { dispatch } = createDispatcher(() => [computeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
       const b = yield* dispatch(createIntent(Compute, { value: 2 }));
-      return b.data!.value - a.data!.value;
+      return b.value - a.value;
     });
 
     expect(await Effect.runPromise(program)).toBe(2);
   });
 
   test('concurrent intent effects', async () => {
-    const { dispatch } = createDispatcher({ test: [computeResolver] });
+    const { dispatch } = createDispatcher(() => [computeResolver]);
     const program = Effect.gen(function* () {
       const fiberA = yield* Effect.fork(dispatch(createIntent(Compute, { value: 5 })));
       const fiberB = yield* Effect.fork(dispatch(createIntent(Compute, { value: 2 })));
       const [a, b] = yield* Fiber.join(Fiber.zip(fiberA, fiberB));
-      return b.data!.value - a.data!.value;
+      return b.value - a.value;
     });
 
     expect(await Effect.runPromise(program)).toBe(-6);
   });
 
   test('mix & match intent effects with promises', async () => {
-    const { dispatch, dispatchPromise } = createDispatcher({ test: [toStringResolver, computeResolver] });
+    const { dispatch, dispatchPromise } = createDispatcher(() => [toStringResolver, computeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 2 }));
-      const b = yield* dispatch(createIntent(ToString, { value: a.data!.value }));
-      return b.data?.string;
+      const b = yield* dispatch(createIntent(ToString, { value: a.value }));
+      return b.string;
     });
 
     expect(await Effect.runPromise(program)).toBe('4');
@@ -89,22 +90,22 @@ describe('Intent dispatcher', () => {
   });
 
   test('undo intent', async () => {
-    const { dispatch, undo } = createDispatcher({ test: [computeResolver] });
+    const { dispatch, undo } = createDispatcher(() => [computeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 2 }));
 
-      expect(a.data?.value).toBe(4);
+      expect(a.value).toBe(4);
 
       const b = yield* undo();
 
-      expect(b?.data?.value).toBe(2);
+      expect(b.value).toBe(2);
     });
 
     await Effect.runPromise(program);
   });
 
   test('chain intents', async () => {
-    const { dispatch } = createDispatcher({ test: [computeResolver, toStringResolver, concatResolver] });
+    const { dispatch } = createDispatcher(() => [computeResolver, toStringResolver, concatResolver]);
     const intent = pipe(createIntent(Compute, { value: 1 }), chain(ToString, {}), chain(Concat, { plus: '!' }));
 
     expect(intent.first.action).toBe(Compute._tag);
@@ -112,24 +113,24 @@ describe('Intent dispatcher', () => {
     expect(intent.all.length).toBe(3);
 
     const program = Effect.gen(function* () {
-      const { data } = yield* dispatch(intent);
-      return data?.string;
+      const data = yield* dispatch(intent);
+      return data.string;
     });
 
     expect(await Effect.runPromise(program)).toBe('2!');
   });
 
   test('undo chained intent', async () => {
-    const { dispatch, undo } = createDispatcher({ test: [computeResolver, toStringResolver, concatResolver] });
+    const { dispatch, undo } = createDispatcher(() => [computeResolver, toStringResolver, concatResolver]);
     const intent = pipe(createIntent(Compute, { value: 1 }), chain(Compute, {}), chain(Compute, {}));
     const program = Effect.gen(function* () {
       const a = yield* dispatch(intent);
 
-      expect(a.data?.value).toBe(8);
+      expect(a.value).toBe(8);
 
       const b = yield* undo();
 
-      expect(b?.data?.value).toBe(1);
+      expect(b.value).toBe(1);
     });
 
     await Effect.runPromise(program);
@@ -137,15 +138,15 @@ describe('Intent dispatcher', () => {
 
   test('filter resolvers by plugin', async () => {
     const otherComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }));
-    const { dispatch } = createDispatcher({ test: [computeResolver], other: [otherComputeResolver] });
+    const { dispatch } = createDispatcher((module) => (module === 'test' ? [computeResolver] : [otherComputeResolver]));
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
-      expect(a.data?.value).toBe(2);
+      expect(a.value).toBe(3);
 
-      const b = yield* dispatch(createIntent(Compute, { value: 1 }, { plugin: 'other' }));
+      const b = yield* dispatch(createIntent(Compute, { value: 1 }, { module: 'test' }));
 
-      expect(b.data?.value).toBe(3);
+      expect(b.value).toBe(2);
     });
 
     await Effect.runPromise(program);
@@ -155,15 +156,15 @@ describe('Intent dispatcher', () => {
     const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
       filter: (data): data is { value: number } => data?.value > 1,
     });
-    const { dispatch } = createDispatcher({ test: [conditionalComputeResolver, computeResolver] });
+    const { dispatch } = createDispatcher(() => [conditionalComputeResolver, computeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
-      expect(a.data?.value).toBe(2);
+      expect(a.value).toBe(2);
 
       const b = yield* dispatch(createIntent(Compute, { value: 2 }));
 
-      expect(b.data?.value).toBe(6);
+      expect(b.value).toBe(6);
     });
 
     await Effect.runPromise(program);
@@ -173,7 +174,7 @@ describe('Intent dispatcher', () => {
     const hoistedComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
       disposition: 'hoist',
     });
-    const { dispatchPromise } = createDispatcher({ test: [computeResolver, hoistedComputeResolver] });
+    const { dispatchPromise } = createDispatcher(() => [computeResolver, hoistedComputeResolver]);
     const { data } = await dispatchPromise(createIntent(Compute, { value: 1 }));
     expect(data?.value).toBe(3);
   });
@@ -185,28 +186,28 @@ describe('Intent dispatcher', () => {
     const fallbackComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
       disposition: 'fallback',
     });
-    const { dispatch } = createDispatcher({ test: [fallbackComputeResolver, conditionalComputeResolver] });
+    const { dispatch } = createDispatcher(() => [fallbackComputeResolver, conditionalComputeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
-      expect(a.data?.value).toBe(2);
+      expect(a.value).toBe(2);
 
       const b = yield* dispatch(createIntent(Compute, { value: 2 }));
 
-      expect(b.data?.value).toBe(6);
+      expect(b.value).toBe(6);
     });
 
     await Effect.runPromise(program);
   });
 
   test('non-struct inputs & outputs', async () => {
-    const { dispatchPromise } = createDispatcher({ test: [addResolver] });
+    const { dispatchPromise } = createDispatcher(() => [addResolver]);
     const { data } = await dispatchPromise(createIntent(Add, [1, 1]));
     expect(data).toBe(2);
   });
 
   test('empty inputs & outputs', async () => {
-    const { dispatchPromise } = createDispatcher({ test: [sideEffectResolver] });
+    const { dispatchPromise } = createDispatcher(() => [sideEffectResolver]);
     const { data } = await dispatchPromise(createIntent(SideEffect));
     expect(data).toBe(undefined);
   });

package/src/{plugins/plugin-intent → plugin-intent}/intent-dispatcher.ts

@@ -2,13 +2,15 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Effect, Ref } from 'effect';
+import { Effect, Option, pipe, Ref } from 'effect';
+import { type Simplify } from 'effect/Types';
 
-import { type MaybePromise, pick } from '@dxos/util';
+import { type MaybePromise, byDisposition, type Disposition } from '@dxos/util';
 
+import { IntentAction } from './actions';
+import { CycleDetectedError, NoResolversError } from './errors';
 import {
   createIntent,
-  IntentAction,
   type AnyIntent,
   type AnyIntentChain,
   type Intent,
@@ -53,6 +55,8 @@ export type IntentEffectResult<Fields extends IntentParams> = {
    * An error that occurred while performing the action.
    *
    * If the intent is apart of a chain of intents and an error occurs, the chain will be aborted.
+   *
+   * Return caught error instead of throwing to trigger other intent to be triggered prior to returning the error.
    */
   error?: Error;
 
@@ -69,15 +73,6 @@ export type AnyIntentEffectResult = IntentEffectResult<any>;
  */
 export type IntentDispatcherResult<Fields extends IntentParams> = Pick<IntentEffectResult<Fields>, 'data' | 'error'>;
 
-/**
- * Determines the priority of the effect when multiple intent resolvers are matched.
- *
- * - `static` - The effect is selected in the order it was resolved.
- * - `hoist` - The effect is selected before `static` effects.
- * - `fallback` - The effect is selected after `static` effects.
- */
-export type IntentDisposition = 'static' | 'hoist' | 'fallback';
-
 /**
  * The implementation of an intent effect.
  */
@@ -89,13 +84,13 @@ export type IntentEffectDefinition<Fields extends IntentParams> = (
 /**
  * Intent resolver to match intents to their effects.
  */
-export type IntentResolver<Tag extends string, Fields extends IntentParams> = {
+export type IntentResolver<Tag extends string, Fields extends IntentParams> = Readonly<{
   action: Tag;
-  disposition?: IntentDisposition;
+  disposition?: Disposition;
   // TODO(wittjosiah): Would be nice to make this a guard for intents with optional data.
   filter?: (data: IntentData<Fields>) => boolean;
   effect: IntentEffectDefinition<Fields>;
-};
+}>;
 
 export type AnyIntentResolver = IntentResolver<any, any>;
 
@@ -121,7 +116,7 @@ export const createResolver = <Tag extends string, Fields extends IntentParams>(
  */
 export type PromiseIntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
-) => Promise<IntentDispatcherResult<Fields>>;
+) => Promise<Simplify<IntentDispatcherResult<Fields>>>;
 
 /**
  * Creates an effect for intents.
@@ -129,23 +124,23 @@ export type PromiseIntentDispatcher = <Fields extends IntentParams>(
 export type IntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
   depth?: number,
-) => Effect.Effect<IntentDispatcherResult<Fields>, Error>;
+) => Effect.Effect<Simplify<Required<IntentDispatcherResult<Fields>>['data']>, Error>;
 
 type IntentResult<Tag extends string, Fields extends IntentParams> = IntentEffectResult<Fields> & {
   _intent: Intent<Tag, Fields>;
 };
 
-type AnyIntentResult = IntentResult<any, any>;
+export type AnyIntentResult = IntentResult<any, any>;
 
 /**
  * Invokes the most recent undoable intent with undo flags.
  */
-export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any> | undefined>;
+export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any>>;
 
 /**
  * Creates an effect which undoes the last intent.
  */
-export type IntentUndo = () => Effect.Effect<IntentDispatcherResult<any> | undefined, Error>;
+export type IntentUndo = () => Effect.Effect<any, Error>;
 
 /**
  * Check if a chain of results is undoable.
@@ -158,7 +153,6 @@ export type IntentContext = {
   dispatchPromise: PromiseIntentDispatcher;
   undo: IntentUndo;
   undoPromise: PromiseIntentUndo;
-  registerResolver: (id: string, resolver: AnyIntentResolver) => () => void;
 };
 
 /**
@@ -169,40 +163,34 @@ export type IntentContext = {
  * @param params.executionLimit The maximum recursion depth of intent chains.
  */
 export const createDispatcher = (
-  resolvers: Record<string, AnyIntentResolver[]>,
+  getResolvers: (module?: string) => AnyIntentResolver[],
   { executionLimit = EXECUTION_LIMIT, historyLimit = HISTORY_LIMIT } = {},
 ): IntentContext => {
   const historyRef = Effect.runSync(Ref.make<AnyIntentResult[][]>([]));
 
   const handleIntent = (intent: AnyIntent) => {
     return Effect.gen(function* () {
-      const candidates = Object.entries(resolvers)
-        .filter(([id, _]) => (intent.plugin ? id === intent.plugin : true))
-        .flatMap(([_, resolvers]) => resolvers)
+      const candidates = getResolvers(intent.module)
         .filter((r) => r.action === intent.action)
         .filter((r) => !r.filter || r.filter(intent.data))
-        .toSorted(({ disposition: a = 'static' }, { disposition: b = 'static' }) => {
-          return a === b ? 0 : a === 'hoist' || b === 'fallback' ? -1 : b === 'hoist' || a === 'fallback' ? 1 : 0;
-        });
+        .toSorted(byDisposition);
       if (candidates.length === 0) {
         return {
           _intent: intent,
-          error: new Error(`No resolver found for action: ${intent.action}`),
-        } satisfies AnyIntentResult;
+          error: new NoResolversError(intent.action),
+        } as AnyIntentResult;
       }
 
       const effect = candidates[0].effect(intent.data, intent.undo ?? false);
       const result = Effect.isEffect(effect) ? yield* effect : yield* Effect.promise(async () => effect);
-      return { _intent: intent, ...result } satisfies AnyIntentResult;
+      return { _intent: intent, ...result } as AnyIntentResult;
     });
   };
 
   const dispatch: IntentDispatcher = (intentChain, depth = 0) => {
     return Effect.gen(function* () {
       if (depth > executionLimit) {
-        yield* Effect.fail(
-          new Error('Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.'),
-        );
+        yield* Effect.fail(new CycleDetectedError());
       }
 
       const resultsRef = yield* Ref.make<AnyIntentResult[]>([]);
@@ -210,9 +198,6 @@ export const createDispatcher = (
         const { data: prev } = (yield* resultsRef.get)[0] ?? {};
         const result = yield* handleIntent({ ...intent, data: { ...intent.data, ...prev } });
         yield* Ref.update(resultsRef, (results) => [result, ...results]);
-        if (result.error) {
-          break;
-        }
         if (result.intents) {
           for (const intent of result.intents) {
             // Returned intents are dispatched but not yielded into results,
@@ -221,34 +206,39 @@ export const createDispatcher = (
             yield* dispatch(intent, depth + 1);
           }
         }
+        if (result.error) {
+          yield* Effect.fail(result.error);
+        }
       }
 
       const results = yield* resultsRef.get;
       const result = results[0];
-      if (result) {
-        yield* Ref.update(historyRef, (history) => {
-          const next = [...history, results];
-          if (next.length > historyLimit) {
-            next.splice(0, next.length - historyLimit);
-          }
-          return next;
-        });
-
-        if (result.undoable && isUndoable(results)) {
-          // TODO(wittjosiah): Is there a better way to handle showing undo for chains?
-          yield* dispatch(createIntent(IntentAction.ShowUndo, { message: result.undoable.message }));
+      yield* Ref.update(historyRef, (history) => {
+        const next = [...history, results];
+        if (next.length > historyLimit) {
+          next.splice(0, next.length - historyLimit);
         }
-
-        return pick(result, ['data', 'error']);
-      } else {
-        return { data: {}, error: new Error('No results') };
+        return next;
+      });
+
+      if (result.undoable && isUndoable(results)) {
+        // TODO(wittjosiah): Is there a better way to handle showing undo for chains?
+        yield* pipe(
+          dispatch(createIntent(IntentAction.ShowUndo, { message: result.undoable.message })),
+          Effect.catchSome((err) =>
+            err instanceof NoResolversError ? Option.some(Effect.succeed(undefined)) : Option.none(),
+          ),
+        );
       }
+
+      return result.data;
     });
   };
 
   const dispatchPromise: PromiseIntentDispatcher = (intentChain) => {
-    const program = dispatch(intentChain);
-    return Effect.runPromise(program);
+    return Effect.runPromise(dispatch(intentChain))
+      .then((data) => ({ data }))
+      .catch((error) => ({ error }));
   };
 
   const undo: IntentUndo = () => {
@@ -270,16 +260,10 @@ export const createDispatcher = (
   };
 
   const undoPromise: PromiseIntentUndo = () => {
-    const program = undo();
-    return Effect.runPromise(program);
-  };
-
-  const registerResolver = (id: string, resolver: AnyIntentResolver) => {
-    resolvers[id] = [...(resolvers[id] ?? []), resolver];
-    return () => {
-      resolvers[id] = resolvers[id].filter((r) => r !== resolver);
-    };
+    return Effect.runPromise(undo())
+      .then((data) => ({ data }))
+      .catch((error) => ({ error }));
   };
 
-  return { dispatch, dispatchPromise, undo, undoPromise, registerResolver };
+  return { dispatch, dispatchPromise, undo, undoPromise };
 };

package/src/{plugins/plugin-intent → plugin-intent}/intent.ts

@@ -4,8 +4,6 @@
 
 import { S } from '@dxos/echo-schema';
 
-import { INTENT_PLUGIN } from './meta';
-
 export type IntentParams = {
   readonly input: S.Schema.All;
   readonly output: S.Schema.All;
@@ -37,11 +35,11 @@ export type Intent<Tag extends string, Fields extends IntentParams> = {
   data: IntentData<Fields>;
 
   /**
-   * Plugin ID.
-   * If specified, the intent will be sent explicitly to the plugin.
+   * Module ID.
+   * If specified, the intent will be sent explicitly to the plugin module.
    * Otherwise, the intent will be sent to all plugins, in order and the first to resolve a non-null value will be used.
    */
-  plugin?: string;
+  module?: string;
 
   /**
    * Whether or not the intent is being undone.
@@ -78,7 +76,7 @@ export type AnyIntentChain = IntentChain<any, any, any, any>;
 export const createIntent = <Tag extends string, Fields extends IntentParams>(
   schema: IntentSchema<Tag, Fields>,
   data: IntentData<Fields> = {},
-  params: Pick<AnyIntent, 'plugin' | 'undo'> = {},
+  params: Pick<AnyIntent, 'module' | 'undo'> = {},
 ): IntentChain<Tag, Tag, Fields, Fields> => {
   // The output of validateSync breaks proxy objects so this is just used for validation.
   // TODO(wittjosiah): Is there a better way to make theses types align?
@@ -114,7 +112,7 @@ export const chain =
   >(
     schema: IntentSchema<NextTag, NextFields>,
     data: Omit<IntentData<NextFields>, keyof IntentResultData<LastFields>> = {},
-    params: Pick<AnyIntent, 'plugin' | 'undo'> = {},
+    params: Pick<AnyIntent, 'module' | 'undo'> = {},
   ) =>
   (
     intent: IntentChain<FirstTag, any, FirstFields, LastFields>,
@@ -146,17 +144,3 @@ export const Label = S.Union(
   S.mutable(S.Tuple(S.String, S.mutable(S.Struct({ ns: S.String, count: S.optional(S.Number) })))),
 );
 export type Label = S.Schema.Type<typeof Label>;
-
-export const INTENT_ACTION = `${INTENT_PLUGIN}/action`;
-
-export namespace IntentAction {
-  /**
-   * Fired after an intent is dispatched if the intent is undoable.
-   */
-  export class ShowUndo extends S.TaggedClass<ShowUndo>()(`${INTENT_ACTION}/show-undo`, {
-    input: S.Struct({
-      message: Label,
-    }),
-    output: S.Void,
-  }) {}
-}

package/src/plugin-settings/SettingsPlugin.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { RootSettingsStore } from '@dxos/local-storage';
+
+import { SETTINGS_PLUGIN } from './actions';
+import { Capabilities, Events } from '../common';
+import { contributes, defineModule, definePlugin } from '../core';
+
+export const SettingsPlugin = () =>
+  definePlugin({ id: SETTINGS_PLUGIN }, [
+    defineModule({
+      id: `${SETTINGS_PLUGIN}/module/store`,
+      activatesOn: Events.Startup,
+      activatesBefore: [Events.SetupSettings],
+      activatesAfter: [Events.SettingsReady],
+      activate: (context) => {
+        const allSettings = context.requestCapabilities(Capabilities.Settings);
+        const settingsStore = new RootSettingsStore();
+
+        allSettings.forEach((setting) => {
+          settingsStore.createStore(setting as any);
+        });
+
+        return contributes(Capabilities.SettingsStore, settingsStore);
+      },
+    }),
+  ]);

package/src/plugin-settings/actions.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { S } from '@dxos/echo-schema';
+
+export const SETTINGS_PLUGIN = 'dxos.org/plugin/settings';
+export const SETTINGS_ACTION = `${SETTINGS_PLUGIN}/action`;
+
+export namespace SettingsAction {
+  export class Open extends S.TaggedClass<Open>()(`${SETTINGS_ACTION}/open`, {
+    input: S.Struct({
+      plugin: S.optional(S.String),
+    }),
+    output: S.Void,
+  }) {}
+}

package/src/plugin-settings/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './actions';
+export * from './SettingsPlugin';