@dxos/app-framework 0.7.5-labs.e27f9b9 → 0.7.5-main.2567c87

package/src/plugin-intent/intent-dispatcher.test.ts

@@ -2,10 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from '@effect/schema';
 import { Effect, Fiber, pipe } from 'effect';
 import { describe, expect, test } from 'vitest';
 
+import { S } from '@dxos/echo-schema';
+
 import { chain, createIntent } from './intent';
 import { type AnyIntentResolver, createDispatcher, createResolver } from './intent-dispatcher';
 
@@ -107,8 +108,8 @@ describe('Intent dispatcher', () => {
     const { dispatch } = createDispatcher(() => [computeResolver, toStringResolver, concatResolver]);
     const intent = pipe(createIntent(Compute, { value: 1 }), chain(ToString, {}), chain(Concat, { plus: '!' }));
 
-    expect(intent.first.id).toBe(Compute._tag);
-    expect(intent.last.id).toBe(Concat._tag);
+    expect(intent.first.action).toBe(Compute._tag);
+    expect(intent.last.action).toBe(Concat._tag);
     expect(intent.all.length).toBe(3);
 
     const program = Effect.gen(function* () {
@@ -136,10 +137,7 @@ describe('Intent dispatcher', () => {
   });
 
   test('filter resolvers by plugin', async () => {
-    const otherComputeResolver = createResolver({
-      intent: Compute,
-      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
-    });
+    const otherComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }));
     const { dispatch } = createDispatcher((module) => (module === 'test' ? [computeResolver] : [otherComputeResolver]));
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
@@ -155,10 +153,8 @@ describe('Intent dispatcher', () => {
   });
 
   test('filter resolvers by predicate', async () => {
-    const conditionalComputeResolver = createResolver({
-      intent: Compute,
+    const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
       filter: (data): data is { value: number } => data?.value > 1,
-      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
     });
     const { dispatch } = createDispatcher(() => [conditionalComputeResolver, computeResolver]);
     const program = Effect.gen(function* () {
@@ -175,10 +171,8 @@ describe('Intent dispatcher', () => {
   });
 
   test('hoist resolvers', async () => {
-    const hoistedComputeResolver = createResolver({
-      intent: Compute,
-      position: 'hoist',
-      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
+    const hoistedComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
+      disposition: 'hoist',
     });
     const { dispatchPromise } = createDispatcher(() => [computeResolver, hoistedComputeResolver]);
     const { data } = await dispatchPromise(createIntent(Compute, { value: 1 }));
@@ -186,17 +180,13 @@ describe('Intent dispatcher', () => {
   });
 
   test('fallback resolvers', async () => {
-    const conditionalComputeResolver = createResolver({
-      intent: Compute,
+    const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 2 } }), {
       filter: (data): data is { value: number } => data?.value === 1,
-      resolve: async (data) => ({ data: { value: data?.value * 2 } }),
     });
-    const fallbackComputeResolver = createResolver({
-      intent: Compute,
-      position: 'fallback',
-      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
+    const fallbackComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
+      disposition: 'fallback',
     });
-    const { dispatch } = createDispatcher(() => [conditionalComputeResolver, fallbackComputeResolver]);
+    const { dispatch } = createDispatcher(() => [fallbackComputeResolver, conditionalComputeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
@@ -234,9 +224,8 @@ class ToString extends S.TaggedClass<ToString>()('ToString', {
   }),
 }) {}
 
-const toStringResolver = createResolver({
-  intent: ToString,
-  resolve: async (data) => ({ data: { string: data.value.toString() } }),
+const toStringResolver = createResolver(ToString, async (data) => {
+  return { data: { string: data.value.toString() } };
 });
 
 class Compute extends S.TaggedClass<Compute>()('Compute', {
@@ -248,19 +237,16 @@ class Compute extends S.TaggedClass<Compute>()('Compute', {
   }),
 }) {}
 
-const computeResolver = createResolver({
-  intent: Compute,
-  resolve: (data, undo) => {
-    return Effect.gen(function* () {
-      if (undo) {
-        return { data: { value: data.value / 2 } };
-      }
-
-      yield* Effect.sleep(data.value * 10);
-      const value = data.value * 2;
-      return { data: { value }, undoable: { message: 'test', data: { value } } };
-    });
-  },
+const computeResolver = createResolver(Compute, (data, undo) => {
+  return Effect.gen(function* () {
+    if (undo) {
+      return { data: { value: data.value / 2 } };
+    }
+
+    yield* Effect.sleep(data.value * 10);
+    const value = data.value * 2;
+    return { data: { value }, undoable: { message: 'test', data: { value } } };
+  });
 });
 
 class Concat extends S.TaggedClass<Concat>()('Concat', {
@@ -273,9 +259,8 @@ class Concat extends S.TaggedClass<Concat>()('Concat', {
   }),
 }) {}
 
-const concatResolver = createResolver({
-  intent: Concat,
-  resolve: async (data) => ({ data: { string: data.string + data.plus } }),
+const concatResolver = createResolver(Concat, async (data) => {
+  return { data: { string: data.string + data.plus } };
 });
 
 class Add extends S.TaggedClass<Add>()('Add', {
@@ -283,9 +268,8 @@ class Add extends S.TaggedClass<Add>()('Add', {
   output: S.Number,
 }) {}
 
-const addResolver = createResolver({
-  intent: Add,
-  resolve: async (data) => ({ data: data[0] + data[1] }),
+const addResolver = createResolver(Add, async (data) => {
+  return { data: data[0] + data[1] };
 });
 
 class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
@@ -293,7 +277,4 @@ class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
   output: S.Void,
 }) {}
 
-const sideEffectResolver = createResolver({
-  intent: SideEffect,
-  resolve: async () => {},
-});
+const sideEffectResolver = createResolver(SideEffect, async () => {});

package/src/plugin-intent/intent-dispatcher.ts

@@ -5,8 +5,7 @@
 import { Effect, Option, pipe, Ref } from 'effect';
 import { type Simplify } from 'effect/Types';
 
-import { create } from '@dxos/live-object';
-import { byPosition, type MaybePromise, type Position, type GuardedType } from '@dxos/util';
+import { type MaybePromise, byDisposition, type Disposition } from '@dxos/util';
 
 import { IntentAction } from './actions';
 import { CycleDetectedError, NoResolversError } from './errors';
@@ -22,8 +21,6 @@ import {
   type IntentSchema,
   type Label,
 } from './intent';
-import { Events, Capabilities } from '../common';
-import { contributes, type PluginsContext } from '../core';
 
 const EXECUTION_LIMIT = 100;
 const HISTORY_LIMIT = 100;
@@ -31,13 +28,13 @@ const HISTORY_LIMIT = 100;
 /**
  * The return value of an intent effect.
  */
-export type IntentEffectResult<Input, Output> = {
+export type IntentEffectResult<Fields extends IntentParams> = {
   /**
    * The output of the action that was performed.
    *
    * If the intent is apart of a chain of intents, the data will be passed to the next intent.
    */
-  data?: Output;
+  data?: IntentResultData<Fields>;
 
   /**
    * If provided, the action will be undoable.
@@ -51,7 +48,7 @@ export type IntentEffectResult<Input, Output> = {
     /**
      * Will be merged with the original intent data when firing the undo intent.
      */
-    data?: Partial<Input>;
+    data?: Partial<IntentData<Fields>>;
   };
 
   /**
@@ -69,32 +66,33 @@ export type IntentEffectResult<Input, Output> = {
   intents?: AnyIntentChain[];
 };
 
-export type AnyIntentEffectResult = IntentEffectResult<any, any>;
+export type AnyIntentEffectResult = IntentEffectResult<any>;
 
 /**
  * The result of an intent dispatcher.
  */
-export type IntentDispatcherResult<Input, Output> = Pick<IntentEffectResult<Input, Output>, 'data' | 'error'>;
+export type IntentDispatcherResult<Fields extends IntentParams> = Pick<IntentEffectResult<Fields>, 'data' | 'error'>;
 
 /**
  * The implementation of an intent effect.
  */
-export type IntentEffectDefinition<Input, Output> = (
-  data: Input,
+export type IntentEffectDefinition<Fields extends IntentParams> = (
+  data: IntentData<Fields>,
   undo: boolean,
-) => MaybePromise<IntentEffectResult<Input, Output> | void> | Effect.Effect<IntentEffectResult<Input, Output> | void>;
+) => MaybePromise<IntentEffectResult<Fields> | void> | Effect.Effect<IntentEffectResult<Fields> | void>;
 
 /**
  * Intent resolver to match intents to their effects.
  */
-export type IntentResolver<Tag extends string, Fields extends IntentParams, Data = IntentData<Fields>> = Readonly<{
-  intent: IntentSchema<Tag, Fields>;
-  position?: Position;
-  filter?: (data: IntentData<Fields>) => data is Data;
-  resolve: IntentEffectDefinition<GuardedType<IntentResolver<Tag, Fields, Data>['filter']>, IntentResultData<Fields>>;
+export type IntentResolver<Tag extends string, Fields extends IntentParams> = Readonly<{
+  action: Tag;
+  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, any>;
+export type AnyIntentResolver = IntentResolver<any, any>;
 
 /**
  * Creates an intent resolver to match intents to their effects.
@@ -103,16 +101,22 @@ export type AnyIntentResolver = IntentResolver<any, any, any>;
  * @param params.disposition Determines the priority of the resolver when multiple are resolved.
  * @param params.filter Optional filter to determine if the resolver should be used.
  */
-export const createResolver = <Tag extends string, Fields extends IntentParams, Data = IntentData<Fields>>(
-  resolver: IntentResolver<Tag, Fields, Data>,
-) => resolver;
+export const createResolver = <Tag extends string, Fields extends IntentParams>(
+  schema: IntentSchema<Tag, Fields>,
+  effect: IntentEffectDefinition<Fields>,
+  params: Pick<IntentResolver<Tag, Fields>, 'disposition' | 'filter'> = {},
+): IntentResolver<Tag, Fields> => ({
+  action: schema._tag,
+  effect,
+  ...params,
+});
 
 /**
  * Invokes intents and returns the result.
  */
 export type PromiseIntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
-) => Promise<Simplify<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>>;
+) => Promise<Simplify<IntentDispatcherResult<Fields>>>;
 
 /**
  * Creates an effect for intents.
@@ -120,15 +124,9 @@ export type PromiseIntentDispatcher = <Fields extends IntentParams>(
 export type IntentDispatcher = <Fields extends IntentParams>(
   intent: IntentChain<any, any, any, Fields>,
   depth?: number,
-) => Effect.Effect<
-  Simplify<Required<IntentDispatcherResult<IntentData<Fields>, IntentResultData<Fields>>>['data']>,
-  Error
->;
-
-type IntentResult<Tag extends string, Fields extends IntentParams> = IntentEffectResult<
-  IntentData<Fields>,
-  IntentResultData<Fields>
-> & {
+) => Effect.Effect<Simplify<Required<IntentDispatcherResult<Fields>>['data']>, Error>;
+
+type IntentResult<Tag extends string, Fields extends IntentParams> = IntentEffectResult<Fields> & {
   _intent: Intent<Tag, Fields>;
 };
 
@@ -137,7 +135,7 @@ export type AnyIntentResult = IntentResult<any, any>;
 /**
  * Invokes the most recent undoable intent with undo flags.
  */
-export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any, any>>;
+export type PromiseIntentUndo = () => Promise<IntentDispatcherResult<any>>;
 
 /**
  * Creates an effect which undoes the last intent.
@@ -160,7 +158,7 @@ export type IntentContext = {
 /**
  * Sets of an intent dispatcher.
  *
- * @param getResolvers A function that returns an array of available intent resolvers.
+ * @param resolvers An array of available intent resolvers.
  * @param params.historyLimit The maximum number of intent results to keep in history.
  * @param params.executionLimit The maximum recursion depth of intent chains.
  */
@@ -170,20 +168,24 @@ export const createDispatcher = (
 ): IntentContext => {
   const historyRef = Effect.runSync(Ref.make<AnyIntentResult[][]>([]));
 
-  const handleIntent = (intent: AnyIntent) =>
-    Effect.gen(function* () {
+  const handleIntent = (intent: AnyIntent) => {
+    return Effect.gen(function* () {
       const candidates = getResolvers(intent.module)
-        .filter((r) => r.intent._tag === intent.id)
+        .filter((r) => r.action === intent.action)
         .filter((r) => !r.filter || r.filter(intent.data))
-        .toSorted(byPosition);
+        .toSorted(byDisposition);
       if (candidates.length === 0) {
-        yield* Effect.fail(new NoResolversError(intent.id));
+        return {
+          _intent: intent,
+          error: new NoResolversError(intent.action),
+        } as AnyIntentResult;
       }
 
-      const effect = candidates[0].resolve(intent.data, intent.undo ?? false);
+      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 } as AnyIntentResult;
     });
+  };
 
   const dispatch: IntentDispatcher = (intentChain, depth = 0) => {
     return Effect.gen(function* () {
@@ -265,40 +267,3 @@ export const createDispatcher = (
 
   return { dispatch, dispatchPromise, undo, undoPromise };
 };
-
-const defaultEffect = () => Effect.fail(new Error('Intent runtime not ready'));
-const defaultPromise = () => Effect.runPromise(defaultEffect());
-
-export default (context: PluginsContext) => {
-  const state = create<IntentContext>({
-    dispatch: defaultEffect,
-    dispatchPromise: defaultPromise,
-    undo: defaultEffect,
-    undoPromise: defaultPromise,
-  });
-
-  // TODO(wittjosiah): Make getResolver callback async and allow resolvers to be requested on demand.
-  const { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher((module) =>
-    context
-      .requestCapabilities(Capabilities.IntentResolver, (c, moduleId): c is AnyIntentResolver => {
-        return module ? moduleId === module : true;
-      })
-      .flat(),
-  );
-
-  const manager = context.requestCapability(Capabilities.PluginManager);
-  state.dispatch = (intentChain, depth) => {
-    return Effect.gen(function* () {
-      yield* manager._activate(Events.SetupIntents);
-      return yield* dispatch(intentChain, depth);
-    });
-  };
-  state.dispatchPromise = async (intentChain) => {
-    await manager.activate(Events.SetupIntents);
-    return await dispatchPromise(intentChain);
-  };
-  state.undo = undo;
-  state.undoPromise = undoPromise;
-
-  return contributes(Capabilities.IntentDispatcher, state);
-};

package/src/plugin-intent/intent.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema as S } from '@effect/schema';
+import { S } from '@dxos/echo-schema';
 
 export type IntentParams = {
   readonly input: S.Schema.All;
@@ -25,9 +25,9 @@ export type Intent<Tag extends string, Fields extends IntentParams> = {
   _schema: IntentSchema<Tag, Fields>;
 
   /**
-   * The id of the intent.
+   * The action to perform.
    */
-  id: Tag;
+  action: Tag;
 
   /**
    * Any data needed to perform the desired action.
@@ -84,7 +84,7 @@ export const createIntent = <Tag extends string, Fields extends IntentParams>(
   const intent = {
     ...params,
     _schema: schema,
-    id: schema._tag,
+    action: schema._tag,
     data,
   } satisfies Intent<Tag, Fields>;
 
@@ -122,7 +122,7 @@ export const chain =
     const last = {
       ...params,
       _schema: schema,
-      id: schema._tag,
+      action: schema._tag,
       data,
     } satisfies Intent<NextTag, NextFields>;
 

package/src/plugin-settings/SettingsPlugin.ts

@@ -2,12 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
+import { RootSettingsStore } from '@dxos/local-storage';
+
 import { SETTINGS_PLUGIN } from './actions';
-import translations from './translations';
 import { Capabilities, Events } from '../common';
-import { contributes, defineModule, definePlugin, lazy } from '../core';
+import { contributes, defineModule, definePlugin } from '../core';
 
-// TODO(wittjosiah): Add options to exclude some modules.
 export const SettingsPlugin = () =>
   definePlugin({ id: SETTINGS_PLUGIN }, [
     defineModule({
@@ -15,21 +15,15 @@ export const SettingsPlugin = () =>
       activatesOn: Events.Startup,
       activatesBefore: [Events.SetupSettings],
       activatesAfter: [Events.SettingsReady],
-      activate: lazy(() => import('./store')),
-    }),
-    defineModule({
-      id: `${SETTINGS_PLUGIN}/module/translations`,
-      activatesOn: Events.SetupTranslations,
-      activate: () => contributes(Capabilities.Translations, translations),
-    }),
-    defineModule({
-      id: `${SETTINGS_PLUGIN}/module/intent-resolver`,
-      activatesOn: Events.SetupIntents,
-      activate: lazy(() => import('./intent-resolver')),
-    }),
-    defineModule({
-      id: `${SETTINGS_PLUGIN}/module/app-graph-builder`,
-      activatesOn: Events.SetupAppGraph,
-      activate: lazy(() => import('./app-graph-builder')),
+      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

@@ -2,12 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema as S } from '@effect/schema';
+import { S } from '@dxos/echo-schema';
 
 export const SETTINGS_PLUGIN = 'dxos.org/plugin/settings';
 export const SETTINGS_ACTION = `${SETTINGS_PLUGIN}/action`;
-export const SETTINGS_ID = 'dxos:settings';
-export const SETTINGS_KEY = 'settings';
 
 export namespace SettingsAction {
   export class Open extends S.TaggedClass<Open>()(`${SETTINGS_ACTION}/open`, {
@@ -16,12 +14,4 @@ export namespace SettingsAction {
     }),
     output: S.Void,
   }) {}
-
-  export class OpenPluginRegistry extends S.TaggedClass<OpenPluginRegistry>()(
-    `${SETTINGS_ACTION}/open-plugin-registry`,
-    {
-      input: S.Void,
-      output: S.Void,
-    },
-  ) {}
 }

package/src/react/Surface.tsx

@@ -5,17 +5,14 @@
 import React, { memo, forwardRef, Suspense, useMemo } from 'react';
 
 import { useDefaultValue } from '@dxos/react-hooks';
-import { byPosition } from '@dxos/util';
+import { byDisposition } from '@dxos/util';
 
 import { ErrorBoundary } from './ErrorBoundary';
 import { useCapabilities } from './useCapabilities';
 import { Capabilities, type SurfaceDefinition, type SurfaceProps } from '../common';
 import { type PluginsContext } from '../core';
 
-/**
- * @internal
- */
-export const useSurfaces = () => {
+const useSurfaces = () => {
   const surfaces = useCapabilities(Capabilities.ReactSurface);
   return useMemo(() => surfaces.flat(), [surfaces]);
 };
@@ -26,7 +23,7 @@ const findCandidates = (surfaces: SurfaceDefinition[], { role, data }: Pick<Surf
       Array.isArray(definition.role) ? definition.role.includes(role) : definition.role === role,
     )
     .filter(({ filter }) => (filter ? filter(data ?? {}) : true))
-    .toSorted(byPosition);
+    .toSorted(byDisposition);
 };
 
 /**
@@ -52,9 +49,11 @@ export const Surface = memo(
       const surfaces = useSurfaces();
       const data = useDefaultValue(_data, () => ({}));
 
-      // NOTE: Memoizing the candidates makes the surface not re-render based on reactivity within data.
-      const definitions = findCandidates(surfaces, { role, data });
-      const candidates = limit ? definitions.slice(0, limit) : definitions;
+      const candidates = useMemo(() => {
+        const definitions = findCandidates(surfaces, { role, data });
+        return limit ? definitions.slice(0, limit) : definitions;
+      }, [surfaces, role, data, limit]);
+
       const nodes = candidates.map(({ component: Component, id }) => (
         <Component ref={forwardedRef} key={id} id={id} role={role} data={data} limit={limit} {...rest} />
       ));
@@ -71,5 +70,3 @@ export const Surface = memo(
     },
   ),
 );
-
-Surface.displayName = 'Surface';

package/src/react/index.ts

@@ -2,9 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './common';
 export * from './ErrorBoundary';
 export * from './PluginManagerProvider';
 export * from './Surface';
 export * from './useCapabilities';
-export * from './useIntentResolver';

package/src/react/useCapabilities.ts

@@ -21,7 +21,6 @@ export const useCapabilities = <T, U extends T = T>(
     () => computed(() => manager.context.requestCapabilities(interfaceDef, filter)),
     [interfaceDef],
   );
-
   return signal.value;
 };
 

package/src/testing/withPluginManager.tsx

@@ -12,14 +12,14 @@ import { Capabilities, Events } from '../common';
 import { type AnyCapability, contributes, defineModule, definePlugin, PluginManager } from '../core';
 
 /**
- * @internal
+ * Wraps a story with a plugin manager.
  */
-export const setupPluginManager = ({
+export const withPluginManager = ({
   capabilities,
   plugins = [],
   core = plugins.map(({ meta }) => meta.id),
   ...options
-}: CreateAppOptions & { capabilities?: AnyCapability[] } = {}) => {
+}: CreateAppOptions & { capabilities?: AnyCapability[] } = {}): Decorator => {
   const pluginManager = new PluginManager({
     pluginLoader: () => raise(new Error('Not implemented')),
     plugins: [StoryPlugin(), ...plugins],
@@ -37,14 +37,6 @@ export const setupPluginManager = ({
     });
   }
 
-  return pluginManager;
-};
-
-/**
- * Wraps a story with a plugin manager.
- */
-export const withPluginManager = (options: CreateAppOptions & { capabilities?: AnyCapability[] } = {}): Decorator => {
-  const pluginManager = setupPluginManager(options);
   const App = createApp({ pluginManager });
 
   return (Story, context) => {

package/tsconfig.json

@@ -20,6 +20,9 @@
     {
       "path": "../../common/async"
     },
+    {
+      "path": "../../common/context"
+    },
     {
       "path": "../../common/debug"
     },
@@ -32,9 +35,6 @@
     {
       "path": "../../common/log"
     },
-    {
-      "path": "../../common/random"
-    },
     {
       "path": "../../common/storybook-utils"
     },
@@ -50,9 +50,6 @@
     {
       "path": "../../core/echo/live-object"
     },
-    {
-      "path": "../../experimental/artifact"
-    },
     {
       "path": "../../ui/primitives/react-hooks"
     },