@dxos/app-framework 0.8.4-main.c1de068 → 0.8.4-main.c85a9c8dae

package/src/playground/generator/generator.ts

@@ -1,48 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Capabilities, Events } from '../../common';
-import { contributes, defineEvent, defineCapability, defineModule, definePlugin } from '../../core';
-import { createResolver, type IntentSchema } from '../../plugin-intent';
-
-export const Number = defineCapability<number>('dxos.org/test/generator/number');
-
-export const CountEvent = defineEvent('dxos.org/test/generator/count');
-
-export const createPluginId = (id: string) => `dxos.org/test/generator/${id}`;
-
-export const createGeneratorIntent = (id: string) => {
-  class Alert extends Schema.TaggedClass<Alert>()(`${createPluginId(id)}/action/alert`, {
-    input: Schema.Void,
-    output: Schema.Void,
-  }) {}
-
-  return Alert as unknown as IntentSchema<any, any>;
-};
-
-export const createNumberPlugin = (id: string) => {
-  const number = Math.floor(Math.random() * 100);
-
-  return definePlugin({ id, name: `Plugin ${id}` }, [
-    defineModule({
-      id: `${id}/main`,
-      activatesOn: CountEvent,
-      activate: () => contributes(Number, number),
-    }),
-    defineModule({
-      id: `${id}/intent-resolver`,
-      activatesOn: Events.SetupIntentResolver,
-      activate: () =>
-        contributes(
-          Capabilities.IntentResolver,
-          createResolver({
-            intent: createGeneratorIntent(id),
-            resolve: () => window.alert(JSON.stringify({ number })),
-          }),
-        ),
-    }),
-  ]);
-};

package/src/playground/generator/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './plugin';
-export * from './generator';

package/src/playground/generator/plugin.ts

@@ -1,23 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Events } from '../../common';
-import { defineModule, definePlugin, lazy } from '../../core';
-
-const Main = lazy(() => import('./Main'));
-const Toolbar = lazy(() => import('./Toolbar'));
-
-export const GeneratorPlugin = () =>
-  definePlugin({ id: 'dxos.org/test/generator', name: 'Generator' }, [
-    defineModule({
-      id: 'dxos.org/test/generator/main',
-      activatesOn: Events.Startup,
-      activate: Main,
-    }),
-    defineModule({
-      id: 'dxos.org/test/generator/toolbar',
-      activatesOn: Events.Startup,
-      activate: Toolbar,
-    }),
-  ]);

package/src/playground/layout/Layout.tsx

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities } from '../../common';
-import { contributes } from '../../core';
-import { Surface } from '../../react';
-
-export const Layout = () => {
-  return (
-    <div className='flex flex-col gap-2'>
-      <div className='flex gap-2'>
-        <Surface role='toolbar' />
-      </div>
-      <div className='flex gap-2'>
-        <div className='flex-1'>
-          <Surface role='primary' limit={1} />
-        </div>
-        <div className='flex-1'>
-          <Surface role='secondary' limit={1} />
-        </div>
-      </div>
-    </div>
-  );
-};
-
-export default () =>
-  contributes(Capabilities.ReactRoot, {
-    id: 'dxos.org/test/layout/root',
-    root: Layout,
-  });

package/src/playground/layout/plugin.ts

@@ -1,17 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Events } from '../../common';
-import { definePlugin, lazy, defineModule } from '../../core';
-
-const Layout = lazy(() => import('./Layout'));
-
-export const LayoutPlugin = () =>
-  definePlugin({ id: 'dxos.org/test/layout', name: 'Layout' }, [
-    defineModule({
-      id: 'dxos.org/test/layout/root',
-      activatesOn: Events.Startup,
-      activate: Layout,
-    }),
-  ]);

package/src/playground/logger/Toolbar.tsx

@@ -1,29 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React, { useCallback } from 'react';
-
-import { Button } from '@dxos/react-ui';
-
-import { Log } from './schema';
-import { Capabilities, createSurface } from '../../common';
-import { contributes } from '../../core';
-import { createIntent } from '../../plugin-intent';
-import { useIntentDispatcher } from '../../react';
-
-export const Logger = () => {
-  const { dispatchPromise } = useIntentDispatcher();
-  const handleClick = useCallback(() => dispatchPromise(createIntent(Log, { message: 'Hello, world!' })), []);
-  return <Button onClick={handleClick}>Log</Button>;
-};
-
-export default () =>
-  contributes(
-    Capabilities.ReactSurface,
-    createSurface({
-      id: 'dxos.org/test/logger/action',
-      role: 'toolbar',
-      component: Logger,
-    }),
-  );

package/src/playground/logger/plugin.ts

@@ -1,36 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { log } from '@dxos/log';
-
-import { Log } from './schema';
-import { Capabilities, Events } from '../../common';
-import { contributes, defineModule, lazy, definePlugin } from '../../core';
-import { createResolver } from '../../plugin-intent';
-
-const Toolbar = lazy(() => import('./Toolbar'));
-
-export const LoggerPlugin = () =>
-  definePlugin({ id: 'dxos.org/test/logger', name: 'Logger' }, [
-    defineModule({
-      id: 'dxos.org/test/logger/intents',
-      activatesOn: Events.SetupIntentResolver,
-      activate: () => [
-        contributes(
-          Capabilities.IntentResolver,
-          createResolver({
-            intent: Log,
-            resolve: ({ message }) => {
-              log.info(message);
-            },
-          }),
-        ),
-      ],
-    }),
-    defineModule({
-      id: 'dxos.org/test/logger/surfaces',
-      activatesOn: Events.Startup,
-      activate: Toolbar,
-    }),
-  ]);

package/src/playground/logger/schema.ts

@@ -1,12 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-export class Log extends Schema.TaggedClass<Log>()('dxos.org/test/logger/log', {
-  input: Schema.Struct({
-    message: Schema.String,
-  }),
-  output: Schema.Void,
-}) {}

package/src/playground/playground.stories.tsx

@@ -1,42 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import '@dxos-theme';
-
-import React from 'react';
-
-import { withLayout, withTheme } from '@dxos/storybook-utils';
-
-import { DebugPlugin } from './debug';
-import { createNumberPlugin, GeneratorPlugin } from './generator';
-import { LayoutPlugin } from './layout';
-import { LoggerPlugin } from './logger';
-import { useApp } from '../App';
-import { IntentPlugin } from '../plugin-intent';
-
-const plugins = [IntentPlugin(), LayoutPlugin(), DebugPlugin(), LoggerPlugin(), GeneratorPlugin()];
-
-const Placeholder = () => {
-  return <div>Loading...</div>;
-};
-
-const Story = () => {
-  const App = useApp({
-    pluginLoader: (id) => createNumberPlugin(id),
-    plugins,
-    core: plugins.map((plugin) => plugin.meta.id),
-    // Having a non-empty placeholder makes it clear if it's taking a while to load.
-    placeholder: Placeholder,
-  });
-
-  return <App />;
-};
-
-export const Playground = {};
-
-export default {
-  title: 'sdk/app-framework/playground',
-  render: Story,
-  decorators: [withTheme, withLayout()],
-};

package/src/plugin-intent/IntentPlugin.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { INTENT_PLUGIN } from './actions';
-import { Events } from '../common';
-import { defineModule, definePlugin, lazy } from '../core';
-
-export const IntentPlugin = () =>
-  definePlugin({ id: INTENT_PLUGIN, name: 'Intent' }, [
-    defineModule({
-      id: `${INTENT_PLUGIN}/module/dispatcher`,
-      // TODO(wittjosiah): This will mean that startup needs to be reset when intents are added or removed.
-      //   This is fine for now because it's how it worked prior to capabilities api anyways.
-      //   In the future, the intent dispatcher should be able to be reset without resetting the entire app.
-      activatesOn: Events.Startup,
-      activatesAfter: [Events.DispatcherReady],
-      activate: lazy(() => import('./intent-dispatcher')),
-    }),
-  ]);

package/src/plugin-intent/actions.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Label } from './intent';
-
-export const INTENT_PLUGIN = 'dxos.org/plugin/intent';
-export const INTENT_ACTION = `${INTENT_PLUGIN}/action`;
-
-export namespace IntentAction {
-  /**
-   * Log an intent.
-   */
-  export class Track extends Schema.TaggedClass<Track>()(`${INTENT_ACTION}/track`, {
-    input: Schema.Struct({
-      intents: Schema.Array(Schema.String),
-      error: Schema.optional(Schema.String),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  /**
-   * Fired after an intent is dispatched if the intent is undoable.
-   */
-  export class ShowUndo extends Schema.TaggedClass<ShowUndo>()(`${INTENT_ACTION}/show-undo`, {
-    input: Schema.Struct({
-      message: Label,
-    }),
-    output: Schema.Void,
-  }) {}
-}

package/src/plugin-intent/errors.ts

@@ -1,39 +0,0 @@
-//
-// 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, { cause: context });
-    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/plugin-intent/index.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export * from './actions';
-export * from './intent';
-export * from './intent-dispatcher';
-export * from './IntentPlugin';

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

@@ -1,279 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema, Effect, Fiber, pipe } from 'effect';
-import { describe, expect, test } from 'vitest';
-
-import { chain, createIntent } from './intent';
-import { type AnyIntentResolver, createDispatcher, createResolver } from './intent-dispatcher';
-
-describe('Intent dispatcher', () => {
-  test('throws error if no resolver found', async () => {
-    const { dispatchPromise } = createDispatcher(() => []);
-    const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
-
-    expect(data).toBe(undefined);
-    expect(error).toBeInstanceOf(Error);
-  });
-
-  test('matches intent to resolver and executes', async () => {
-    const { dispatchPromise } = createDispatcher(() => [toStringResolver]);
-    const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
-
-    expect(error).toBe(undefined);
-    expect(data?.string).toBe('1');
-  });
-
-  test('update resolvers', async () => {
-    const resolvers: AnyIntentResolver[] = [];
-    const { dispatchPromise } = createDispatcher(() => resolvers);
-    const { error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
-
-    expect(error).toBeInstanceOf(Error);
-
-    resolvers.push(toStringResolver);
-
-    const { data } = await dispatchPromise(createIntent(ToString, { value: 1 }));
-
-    expect(data?.string).toBe('1');
-
-    resolvers.splice(resolvers.indexOf(toStringResolver), 1);
-
-    {
-      const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
-
-      expect(data).toBe(undefined);
-      expect(error).toBeInstanceOf(Error);
-    }
-  });
-
-  test('compose intent effects', async () => {
-    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.value - a.value;
-    });
-
-    expect(await Effect.runPromise(program)).toBe(2);
-  });
-
-  test('concurrent intent effects', async () => {
-    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.value - a.value;
-    });
-
-    expect(await Effect.runPromise(program)).toBe(-6);
-  });
-
-  test('mix & match intent effects with promises', async () => {
-    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.value }));
-      return b.string;
-    });
-
-    expect(await Effect.runPromise(program)).toBe('4');
-
-    const a = await dispatchPromise(createIntent(Compute, { value: 2 }));
-    const b = await dispatchPromise(createIntent(ToString, { value: a.data!.value }));
-
-    expect(b.data?.string).toBe('4');
-  });
-
-  test('undo intent', async () => {
-    const { dispatch, undo } = createDispatcher(() => [computeResolver]);
-    const program = Effect.gen(function* () {
-      const a = yield* dispatch(createIntent(Compute, { value: 2 }));
-
-      expect(a.value).toBe(4);
-
-      const b = yield* undo();
-
-      expect(b.value).toBe(2);
-    });
-
-    await Effect.runPromise(program);
-  });
-
-  test('chain intents', async () => {
-    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.all.length).toBe(3);
-
-    const program = Effect.gen(function* () {
-      const data = yield* dispatch(intent);
-      return data.string;
-    });
-
-    expect(await Effect.runPromise(program)).toBe('2!');
-  });
-
-  test('undo chained intent', async () => {
-    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.value).toBe(8);
-
-      const b = yield* undo();
-
-      expect(b.value).toBe(1);
-    });
-
-    await Effect.runPromise(program);
-  });
-
-  test('filter resolvers by predicate', async () => {
-    const conditionalComputeResolver = createResolver({
-      intent: Compute,
-      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* () {
-      const a = yield* dispatch(createIntent(Compute, { value: 1 }));
-
-      expect(a.value).toBe(2);
-
-      const b = yield* dispatch(createIntent(Compute, { value: 2 }));
-
-      expect(b.value).toBe(6);
-    });
-
-    await Effect.runPromise(program);
-  });
-
-  test('hoist resolvers', async () => {
-    const hoistedComputeResolver = createResolver({
-      intent: Compute,
-      position: 'hoist',
-      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
-    });
-    const { dispatchPromise } = createDispatcher(() => [computeResolver, hoistedComputeResolver]);
-    const { data } = await dispatchPromise(createIntent(Compute, { value: 1 }));
-    expect(data?.value).toBe(3);
-  });
-
-  test('fallback resolvers', async () => {
-    const conditionalComputeResolver = createResolver({
-      intent: Compute,
-      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 { dispatch } = createDispatcher(() => [conditionalComputeResolver, fallbackComputeResolver]);
-    const program = Effect.gen(function* () {
-      const a = yield* dispatch(createIntent(Compute, { value: 1 }));
-
-      expect(a.value).toBe(2);
-
-      const b = yield* dispatch(createIntent(Compute, { value: 2 }));
-
-      expect(b.value).toBe(6);
-    });
-
-    await Effect.runPromise(program);
-  });
-
-  test('non-struct inputs & outputs', async () => {
-    const { dispatchPromise } = createDispatcher(() => [addResolver]);
-    const { data } = await dispatchPromise(createIntent(Add, [1, 1]));
-    expect(data).toBe(2);
-  });
-
-  test('empty inputs & outputs', async () => {
-    const { dispatchPromise } = createDispatcher(() => [sideEffectResolver]);
-    const { data } = await dispatchPromise(createIntent(SideEffect));
-    expect(data).toBe(undefined);
-  });
-
-  test.todo('follow up intents');
-});
-
-class ToString extends Schema.TaggedClass<ToString>()('ToString', {
-  input: Schema.Struct({
-    value: Schema.Number,
-  }),
-  output: Schema.Struct({
-    string: Schema.String,
-  }),
-}) {}
-
-const toStringResolver = createResolver({
-  intent: ToString,
-  resolve: async (data) => ({ data: { string: data.value.toString() } }),
-});
-
-class Compute extends Schema.TaggedClass<Compute>()('Compute', {
-  input: Schema.Struct({
-    value: Schema.Number,
-  }),
-  output: Schema.Struct({
-    value: Schema.Number,
-  }),
-}) {}
-
-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 } } };
-    });
-  },
-});
-
-class Concat extends Schema.TaggedClass<Concat>()('Concat', {
-  input: Schema.Struct({
-    string: Schema.String,
-    plus: Schema.String,
-  }),
-  output: Schema.Struct({
-    string: Schema.String,
-  }),
-}) {}
-
-const concatResolver = createResolver({
-  intent: Concat,
-  resolve: async (data) => ({ data: { string: data.string + data.plus } }),
-});
-
-class Add extends Schema.TaggedClass<Add>()('Add', {
-  input: Schema.Tuple(Schema.Number, Schema.Number),
-  output: Schema.Number,
-}) {}
-
-const addResolver = createResolver({
-  intent: Add,
-  resolve: async (data) => ({ data: data[0] + data[1] }),
-});
-
-class SideEffect extends Schema.TaggedClass<SideEffect>()('SideEffect', {
-  input: Schema.Void,
-  output: Schema.Void,
-}) {}
-
-const sideEffectResolver = createResolver({
-  intent: SideEffect,
-  resolve: async () => {},
-});