@dxos/plugin-space 0.7.5-main.9d26e3a → 0.7.5-main.b19bfc8

package/src/capabilities/app-graph-builder.ts

@@ -0,0 +1,319 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, createIntent, type PluginsContext } from '@dxos/app-framework';
+import {
+  Expando,
+  Filter,
+  FQ_ID_LENGTH,
+  getSpace,
+  isEchoObject,
+  isSpace,
+  OBJECT_ID_LENGTH,
+  type ReactiveEchoObject,
+  SPACE_ID_LENGTH,
+  SpaceState,
+  type Space,
+} from '@dxos/client/echo';
+import { isDeleted } from '@dxos/live-object';
+import { log } from '@dxos/log';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { createExtension, toSignal, type Node, type InvokeParams } from '@dxos/plugin-graph';
+import { isNonNullable } from '@dxos/util';
+
+import { SpaceCapabilities } from './capabilities';
+import { SPACE_PLUGIN } from '../meta';
+import { CollectionType, SpaceAction, type SpaceSettingsProps } from '../types';
+import {
+  constructObjectActions,
+  constructSpaceActions,
+  constructSpaceNode,
+  createObjectNode,
+  memoizeQuery,
+  SHARED,
+  SPACES,
+} from '../util';
+
+export default (context: PluginsContext) => {
+  const resolve = (typename: string) =>
+    context.requestCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+
+  const spacesNode = {
+    id: SPACES,
+    type: SPACES,
+    cacheable: ['label', 'role'],
+    properties: {
+      label: ['spaces label', { ns: SPACE_PLUGIN }],
+      icon: 'ph--planet--regular',
+      testId: 'spacePlugin.spaces',
+      role: 'branch',
+      disposition: 'collection',
+      disabled: true,
+      childrenPersistenceClass: 'echo',
+      onRearrangeChildren: async (nextOrder: Space[]) => {
+        const { graph } = context.requestCapability(Capabilities.AppGraph);
+        const client = context.requestCapability(ClientCapabilities.Client);
+
+        // NOTE: This is needed to ensure order is updated by next animation frame.
+        // TODO(wittjosiah): Is there a better way to do this?
+        //   If not, graph should be passed as an argument to the extension.
+        graph._sortEdges(
+          SPACES,
+          'outbound',
+          nextOrder.map(({ id }) => id),
+        );
+
+        const {
+          objects: [spacesOrder],
+        } = await client.spaces.default.db.query(Filter.schema(Expando, { key: SHARED })).run();
+        if (spacesOrder) {
+          spacesOrder.order = nextOrder.map(({ id }) => id);
+        } else {
+          log.warn('spaces order object not found');
+        }
+      },
+    },
+  };
+
+  return contributes(Capabilities.AppGraphBuilder, [
+    // Primary actions.
+    createExtension({
+      id: `${SPACE_PLUGIN}/primary-actions`,
+      position: 'hoist',
+      filter: (node): node is Node<null> => node.id === 'root',
+      actions: () => [
+        {
+          id: SpaceAction.AddSpace._tag,
+          data: async (params: InvokeParams) => {
+            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+            await dispatch(createIntent(SpaceAction.AddSpace));
+          },
+          properties: {
+            label: ['add space label', { ns: SPACE_PLUGIN }],
+            icon: 'ph--plus--regular',
+            testId: 'spacePlugin.addSpace',
+            disposition: 'item',
+            position: 'fallback',
+          },
+        },
+      ],
+    }),
+
+    // Create spaces group node.
+    createExtension({
+      id: `${SPACE_PLUGIN}/root`,
+      position: 'hoist',
+      filter: (node): node is Node<null> => node.id === 'root',
+      connector: () => [spacesNode],
+      resolver: ({ id }) => (id === SPACES ? spacesNode : undefined),
+    }),
+
+    // Create space nodes.
+    createExtension({
+      id: SPACES,
+      filter: (node): node is Node<null> => node.id === SPACES,
+      connector: () => {
+        const client = context.requestCapability(ClientCapabilities.Client);
+        const spaces = toSignal(
+          (onChange) => client.spaces.subscribe(() => onChange()).unsubscribe,
+          () => client.spaces.get(),
+        );
+
+        const isReady = toSignal(
+          (onChange) => client.spaces.isReady.subscribe(() => onChange()).unsubscribe,
+          () => client.spaces.isReady.get(),
+        );
+
+        if (!spaces || !isReady) {
+          return;
+        }
+
+        const state = context.requestCapability(SpaceCapabilities.State);
+        const settings = context
+          .requestCapabilities(Capabilities.SettingsStore)[0]
+          ?.getStore<SpaceSettingsProps>(SPACE_PLUGIN)?.value;
+
+        // TODO(wittjosiah): During client reset, accessing default space throws.
+        try {
+          const [spacesOrder] = memoizeQuery(client.spaces.default, Filter.schema(Expando, { key: SHARED }));
+          const order: string[] = spacesOrder?.order ?? [];
+          const orderMap = new Map(order.map((id, index) => [id, index]));
+          return [
+            ...spaces
+              .filter((space) => orderMap.has(space.id))
+              .sort((a, b) => orderMap.get(a.id)! - orderMap.get(b.id)!),
+            ...spaces.filter((space) => !orderMap.has(space.id)),
+          ]
+            .filter((space) => (settings?.showHidden ? true : space.state.get() !== SpaceState.SPACE_INACTIVE))
+            .map((space) =>
+              constructSpaceNode({
+                space,
+                navigable: state.navigableCollections,
+                personal: space === client.spaces.default,
+                namesCache: state.spaceNames,
+                resolve,
+              }),
+            );
+        } catch {}
+      },
+      resolver: ({ id }) => {
+        if (id.length !== SPACE_ID_LENGTH) {
+          return;
+        }
+
+        const client = context.requestCapability(ClientCapabilities.Client);
+        const spaces = toSignal(
+          (onChange) => client.spaces.subscribe(() => onChange()).unsubscribe,
+          () => client.spaces.get(),
+        );
+
+        const isReady = toSignal(
+          (onChange) => client.spaces.isReady.subscribe(() => onChange()).unsubscribe,
+          () => client.spaces.isReady.get(),
+        );
+
+        if (!spaces || !isReady) {
+          return;
+        }
+
+        const space = spaces.find((space) => space.id === id);
+        if (!space) {
+          return;
+        }
+
+        if (space.state.get() === SpaceState.SPACE_INACTIVE) {
+          return false;
+        } else if (space.state.get() !== SpaceState.SPACE_READY) {
+          return undefined;
+        } else {
+          const state = context.requestCapability(SpaceCapabilities.State);
+          return constructSpaceNode({
+            space,
+            navigable: state.navigableCollections,
+            personal: space === client.spaces.default,
+            namesCache: state.spaceNames,
+            resolve,
+          });
+        }
+      },
+    }),
+
+    // Create space actions.
+    createExtension({
+      id: `${SPACE_PLUGIN}/actions`,
+      filter: (node): node is Node<Space> => isSpace(node.data),
+      actions: ({ node }) => {
+        const space = node.data;
+        const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+        const client = context.requestCapability(ClientCapabilities.Client);
+        const state = context.requestCapability(SpaceCapabilities.State);
+        return constructSpaceActions({
+          space,
+          dispatch,
+          personal: space === client.spaces.default,
+          migrating: state.sdkMigrationRunning[space.id],
+        });
+      },
+    }),
+
+    // Create nodes for objects in the root collection of a space.
+    createExtension({
+      id: `${SPACE_PLUGIN}/root-collection`,
+      filter: (node): node is Node<Space> => isSpace(node.data),
+      connector: ({ node }) => {
+        const space = node.data;
+        const spaceState = toSignal(
+          (onChange) => space.state.subscribe(() => onChange()).unsubscribe,
+          () => space.state.get(),
+          space.id,
+        );
+        if (spaceState !== SpaceState.SPACE_READY) {
+          return;
+        }
+
+        const collection = space.properties[CollectionType.typename]?.target as CollectionType | undefined;
+        if (!collection) {
+          return;
+        }
+
+        const state = context.requestCapability(SpaceCapabilities.State);
+
+        return collection.objects
+          .map((object) => object.target)
+          .filter(isNonNullable)
+          .map((object) => createObjectNode({ object, space, resolve, navigable: state.navigableCollections }))
+          .filter(isNonNullable);
+      },
+    }),
+
+    // Create nodes for objects in a collection or by its fully qualified id.
+    createExtension({
+      id: `${SPACE_PLUGIN}/objects`,
+      filter: (node): node is Node<CollectionType> => node.data instanceof CollectionType,
+      connector: ({ node }) => {
+        const collection = node.data;
+        const space = getSpace(collection);
+        if (!space) {
+          return;
+        }
+
+        const state = context.requestCapability(SpaceCapabilities.State);
+
+        return collection.objects
+          .map((object) => object.target)
+          .filter(isNonNullable)
+          .map((object) => createObjectNode({ object, space, resolve, navigable: state.navigableCollections }))
+          .filter(isNonNullable);
+      },
+      resolver: ({ id }) => {
+        if (id.length !== FQ_ID_LENGTH) {
+          return;
+        }
+
+        const [spaceId, objectId] = id.split(':');
+        if (spaceId.length !== SPACE_ID_LENGTH && objectId.length !== OBJECT_ID_LENGTH) {
+          return;
+        }
+
+        const client = context.requestCapability(ClientCapabilities.Client);
+        const space = client.spaces.get().find((space) => space.id === spaceId);
+        if (!space) {
+          return;
+        }
+
+        const spaceState = toSignal(
+          (onChange) => space.state.subscribe(() => onChange()).unsubscribe,
+          () => space.state.get(),
+          space.id,
+        );
+        if (spaceState !== SpaceState.SPACE_READY) {
+          return;
+        }
+
+        const [object] = memoizeQuery(space, { id: objectId });
+        if (!object) {
+          return;
+        }
+
+        if (isDeleted(object)) {
+          return false;
+        } else {
+          const state = context.requestCapability(SpaceCapabilities.State);
+          return createObjectNode({ object, space, resolve, navigable: state.navigableCollections });
+        }
+      },
+    }),
+
+    // Create collection actions and action groups.
+    createExtension({
+      id: `${SPACE_PLUGIN}/object-actions`,
+      filter: (node): node is Node<ReactiveEchoObject<any>> => isEchoObject(node.data),
+      actions: ({ node }) => {
+        const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+        const state = context.requestCapability(SpaceCapabilities.State);
+        return constructObjectActions({ node, dispatch, navigable: state.navigableCollections });
+      },
+    }),
+  ]);
+};

package/src/capabilities/app-graph-serializer.ts

@@ -0,0 +1,73 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, createIntent, type PluginsContext } from '@dxos/app-framework';
+import { isSpace } from '@dxos/client/echo';
+import { create } from '@dxos/live-object';
+
+import { SPACE_PLUGIN } from '../meta';
+import translations from '../translations';
+import { CollectionType, SpaceAction } from '../types';
+import { SPACES, SPACE_TYPE } from '../util';
+
+// https://stackoverflow.com/a/19016910
+const DIRECTORY_TYPE = 'text/directory';
+
+export default (context: PluginsContext) =>
+  contributes(Capabilities.AppGraphSerializer, [
+    {
+      inputType: SPACES,
+      outputType: DIRECTORY_TYPE,
+      serialize: (node) => ({
+        name: translations[0]['en-US'][SPACE_PLUGIN]['spaces label'],
+        data: translations[0]['en-US'][SPACE_PLUGIN]['spaces label'],
+        type: DIRECTORY_TYPE,
+      }),
+      deserialize: () => {
+        // No-op.
+      },
+    },
+    {
+      inputType: SPACE_TYPE,
+      outputType: DIRECTORY_TYPE,
+      serialize: (node) => ({
+        name: node.data.properties.name ?? translations[0]['en-US'][SPACE_PLUGIN]['unnamed space label'],
+        data: node.data.properties.name ?? translations[0]['en-US'][SPACE_PLUGIN]['unnamed space label'],
+        type: DIRECTORY_TYPE,
+      }),
+      deserialize: async (data) => {
+        const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+        const result = await dispatch(createIntent(SpaceAction.Create, { name: data.name, edgeReplication: true }));
+        return result.data?.space;
+      },
+    },
+    {
+      inputType: CollectionType.typename,
+      outputType: DIRECTORY_TYPE,
+      serialize: (node) => ({
+        name: node.data.name ?? translations[0]['en-US'][SPACE_PLUGIN]['unnamed collection label'],
+        data: node.data.name ?? translations[0]['en-US'][SPACE_PLUGIN]['unnamed collection label'],
+        type: DIRECTORY_TYPE,
+      }),
+      deserialize: async (data, ancestors) => {
+        const space = ancestors.find(isSpace);
+        const collection =
+          ancestors.findLast((ancestor) => ancestor instanceof CollectionType) ??
+          space?.properties[CollectionType.typename]?.target;
+        if (!space || !collection) {
+          return;
+        }
+
+        const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+        const result = await dispatch(
+          createIntent(SpaceAction.AddObject, {
+            target: collection,
+            object: create(CollectionType, { name: data.name, objects: [], views: {} }),
+          }),
+        );
+
+        return result.data?.object;
+      },
+    },
+  ]);

package/src/capabilities/capabilities.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { defineCapability, type Label } from '@dxos/app-framework';
+import { type DeepReadonly } from '@dxos/util';
+
+import { SPACE_PLUGIN } from '../meta';
+import { type ObjectForm, type PluginState } from '../types';
+
+export namespace SpaceCapabilities {
+  export const State = defineCapability<DeepReadonly<PluginState>>(`${SPACE_PLUGIN}/capability/state`);
+  export const MutableState = defineCapability<PluginState>(`${SPACE_PLUGIN}/capability/state`);
+
+  export type SpaceSettingsPanel = { id: string; label: Label };
+  export const SettingsPanel = defineCapability<SpaceSettingsPanel>(`${SPACE_PLUGIN}/capability/settings-panel`);
+
+  export const ObjectForm = defineCapability<ObjectForm<any>>(`${SPACE_PLUGIN}/capability/object-form`);
+}
+
+// TODO(wittjosiah): Factor out.
+export namespace ThreadCapabilities {
+  type ThreadCapability<T = any> = {
+    predicate: (obj: any) => obj is T;
+    createSort: (obj: T) => (anchorA: string | undefined, anchorB: string | undefined) => number;
+  };
+  export const Thread = defineCapability<ThreadCapability>(`${SPACE_PLUGIN}/capability/thread`);
+}

package/src/capabilities/identity-created.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes, type PluginsContext, Capabilities } from '@dxos/app-framework';
+import { create, makeRef } from '@dxos/live-object';
+import { Migrations } from '@dxos/migrations';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { CollectionType } from '../types';
+
+export default async (context: PluginsContext) => {
+  const client = context.requestCapability(ClientCapabilities.Client);
+  await client.spaces.waitUntilReady();
+
+  const defaultSpace = client.spaces.default;
+  await defaultSpace.waitUntilReady();
+
+  // Create root collection structure.
+  defaultSpace.properties[CollectionType.typename] = makeRef(create(CollectionType, { objects: [], views: {} }));
+  if (Migrations.versionProperty) {
+    defaultSpace.properties[Migrations.versionProperty] = Migrations.targetVersion;
+  }
+
+  return contributes(Capabilities.Null, null);
+};

package/src/capabilities/index.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { lazy } from '@dxos/app-framework';
+
+export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const AppGraphSerializer = lazy(() => import('./app-graph-serializer'));
+export const IdentityCreated = lazy(() => import('./identity-created'));
+export const IntentResolver = lazy(() => import('./intent-resolver'));
+export const ReactRoot = lazy(() => import('./react-root'));
+export const ReactSurface = lazy(() => import('./react-surface'));
+export const Schema = lazy(() => import('./schema'));
+export const SpaceSettings = lazy(() => import('./settings'));
+export const SpaceState = lazy(() => import('./state'));
+export const SpacesReady = lazy(() => import('./spaces-ready'));
+
+export * from './capabilities';