@dxos/plugin-space 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/src/hooks/useInputSurfaceLookup.tsx

@@ -2,34 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import type * as Schema from 'effect/Schema';
 import React, { useCallback } from 'react';
 
 import { Surface, isSurfaceAvailable, usePluginManager } from '@dxos/app-framework/react';
-import { type InputProps } from '@dxos/react-ui-form';
+import { type FormFieldProvider } from '@dxos/react-ui-form';
 
-// TODO(ZaymonFC): Move this if you find yourself needing it elsewhere.
 /**
  * Creates a surface input component based on plugin context.
  * @param baseData Additional data that will be merged with form data and passed to the surface.
  * This allows providing more context to the surface than what's available from the form itself.
  */
-export const useInputSurfaceLookup = (baseData?: Record<string, any>) => {
+// TODO(burdon): Factor out?
+export const useInputSurfaceLookup = (baseData?: Record<string, any>): FormFieldProvider => {
   const pluginManager = usePluginManager();
-
-  return useCallback(
-    ({ prop, schema, inputProps }: { prop: string; schema: Schema.Schema<any>; inputProps: InputProps }) => {
-      const composedData = { prop, schema, ...baseData };
-      if (
-        !isSurfaceAvailable(pluginManager.context, {
-          role: 'form-input',
-          data: composedData,
-        })
-      ) {
-        return undefined;
+  return useCallback<FormFieldProvider>(
+    ({ schema, prop, fieldProps }) => {
+      const data = { prop, schema, ...baseData };
+      if (isSurfaceAvailable(pluginManager.capabilities, { role: 'form-input', data })) {
+        return <Surface role='form-input' data={data} {...fieldProps} />;
       }
-
-      return <Surface role='form-input' data={composedData} {...inputProps} />;
     },
     [pluginManager, baseData],
   );

package/src/hooks/usePath.ts

@@ -5,7 +5,7 @@
 import * as Option from 'effect/Option';
 import { useEffect, useState } from 'react';
 
-import { type ReadableGraph } from '@dxos/plugin-graph';
+import { Graph } from '@dxos/plugin-graph';
 
 /**
  * React hook to get a path from the graph.
@@ -16,9 +16,9 @@ import { type ReadableGraph } from '@dxos/plugin-graph';
  * @returns Path if found, undefined otherwise.
  */
 // TODO(wittjosiah): Factor out.
-export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {
+export const usePath = (graph: Graph.ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {
   const [pathState, setPathState] = useState<Option.Option<string[]>>(
-    id ? graph.getPath({ target: id }) : Option.none(),
+    id ? Graph.getPath(graph, { target: id }) : Option.none(),
   );
 
   useEffect(() => {
@@ -33,7 +33,7 @@ export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Op
     // Set timeout did not seem to effectively not block the UI thread.
     const frame = requestAnimationFrame(async () => {
       try {
-        const path = await graph.waitForPath({ target: id }, { timeout });
+        const path = await Graph.waitForPath(graph, { target: id }, { timeout });
         if (path) {
           setPathState(Option.some(path));
         }

package/src/hooks/useTypeOptions.ts

@@ -4,7 +4,6 @@
 
 import { useMemo } from 'react';
 
-import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 import { useTranslation } from '@dxos/react-ui';
 
@@ -12,8 +11,7 @@ import { type TypeInputOptions, getTypenames } from '../types';
 
 export const useTypeOptions = ({ space, annotation }: { space?: Space; annotation: TypeInputOptions }) => {
   const { t } = useTranslation();
-  const client = useClient();
-  const typenames = getTypenames({ annotation, space, client });
+  const typenames = getTypenames({ annotation, space });
   return useMemo(
     () =>
       typenames

package/src/index.ts

@@ -2,8 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export { SpaceCapabilities } from './capabilities';
-export { SpaceEvents } from './events';
+export { SpaceCapabilities, SpaceEvents } from './types';
 
 export * from './components';
 export * from './helpers';

package/src/meta.ts

@@ -2,10 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
-export const meta: PluginMeta = {
+export const meta: Plugin.Meta = {
   id: 'dxos.org/plugin/space',
   name: 'Spaces',
   description: trim`

package/src/translations.ts

@@ -238,6 +238,8 @@ export const translations = [
         'sync latency label': 'Latency',
         'sync upload label': 'Upload',
         'sync download label': 'Download',
+
+        'search placeholder': 'Search…',
       },
     },
   },

package/src/types/capabilities.ts

@@ -0,0 +1,73 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Atom } from '@effect-atom/atom-react';
+import type * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { type Space } from '@dxos/client/echo';
+import { type Database } from '@dxos/echo';
+import { type PublicKey } from '@dxos/keys';
+import { type Operation } from '@dxos/operation';
+import { type Collection } from '@dxos/schema';
+import { type Label } from '@dxos/ui-types';
+import { type ComplexMap, type Position } from '@dxos/util';
+
+import { meta } from '../meta';
+
+import { type ObjectViewerProps, type SpaceSettingsProps } from './types';
+
+export namespace SpaceCapabilities {
+  export const Settings = Capability.make<Atom.Writable<SpaceSettingsProps>>(`${meta.id}/capability/settings`);
+
+  /** Schema for persisted space plugin state. */
+  export const StateSchema = Schema.mutable(
+    Schema.Struct({
+      spaceNames: Schema.Record({ key: Schema.String, value: Schema.String }),
+      enabledEdgeReplication: Schema.Boolean,
+    }),
+  );
+
+  export type SpaceState = Schema.Schema.Type<typeof StateSchema>;
+
+  /** Persisted state (stored in KVS/localStorage). */
+  export const State = Capability.make<Atom.Writable<SpaceState>>(`${meta.id}/capability/state`);
+
+  /** Ephemeral space plugin state (not persisted). */
+  export type SpaceEphemeralState = {
+    awaiting: string | undefined;
+    sdkMigrationRunning: Record<string, boolean>;
+    navigableCollections: boolean;
+    viewersByObject: Record<string, ComplexMap<PublicKey, ObjectViewerProps>>;
+    viewersByIdentity: ComplexMap<PublicKey, Set<string>>;
+  };
+
+  /** Transient/ephemeral state (not persisted). */
+  export const EphemeralState = Capability.make<Atom.Writable<SpaceEphemeralState>>(
+    `${meta.id}/capability/ephemeral-state`,
+  );
+
+  export type SettingsSection = { id: string; label: Label; position?: Position };
+  export const SettingsSection = Capability.make<SettingsSection>(`${meta.id}/capability/settings-section`);
+
+  export type OnCreateSpace = (params: {
+    space: Space;
+    isDefault: boolean;
+    rootCollection: Collection.Collection;
+  }) => Effect.Effect<void, Error, Operation.Service>;
+  export const OnCreateSpace = Capability.make<OnCreateSpace>(`${meta.id}/capability/on-space-created`);
+
+  export type OnSchemaAdded = (params: {
+    db: Database.Database;
+    schema: Schema.Schema.AnyNoContext;
+    // TODO(wittjosiah): This is leaky.
+    show?: boolean;
+  }) => Effect.Effect<void, Error, Operation.Service>;
+  export const OnSchemaAdded = Capability.make<OnSchemaAdded>(`${meta.id}/capability/on-schema-added`);
+
+  // TODO(wittjosiah): Replace with migrations, this is not a sustainable solution.
+  export type HandleRepair = (params: { space: Space; isDefault: boolean }) => Promise<void>;
+  export const Repair = Capability.make<HandleRepair>(`${meta.id}/capability/repair`);
+}

package/src/types/events.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ActivationEvent, Common } from '@dxos/app-framework';
+
+import { meta } from '../meta';
+
+export namespace SpaceEvents {
+  export const StateReady = Common.ActivationEvent.createStateEvent(`${meta.id}/event/state-ready`);
+  export const SetupSettingsPanel = ActivationEvent.make(`${meta.id}/event/setup-settings-panel`);
+  export const DefaultSpaceReady = ActivationEvent.make(`${meta.id}/event/default-space-ready`);
+  export const SpaceCreated = ActivationEvent.make(`${meta.id}/event/space-created`);
+  export const SchemaAdded = ActivationEvent.make(`${meta.id}/event/schema-added`);
+}

package/src/types/form.ts

@@ -5,7 +5,6 @@
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 
-import { type Client } from '@dxos/client';
 import { type Space } from '@dxos/client/echo';
 import { Type } from '@dxos/echo';
 import { EntityKind, SystemTypeAnnotation, createAnnotationHelper, getTypeAnnotation } from '@dxos/echo/internal';
@@ -24,16 +23,8 @@ export type TypeInputOptions = Schema.Schema.Type<typeof TypeInputOptions>;
 export const TypeInputOptionsAnnotationId = Symbol.for('@dxos/schema/annotation/TypeInputOptions');
 export const TypeInputOptionsAnnotation = createAnnotationHelper<TypeInputOptions>(TypeInputOptionsAnnotationId);
 
-// TODO(wittjosiah): This is way to complicated and needs to be simplified.
-export const getTypenames = ({
-  annotation,
-  space,
-  client,
-}: {
-  annotation: TypeInputOptions;
-  space?: Space;
-  client: Client;
-}) => {
+// TODO(wittjosiah): This is too complicated and needs to be simplified.
+export const getTypenames = ({ annotation, space }: { annotation: TypeInputOptions; space?: Space }) => {
   const includeRuntime = annotation.location.includes('runtime');
   const includeDatabase = annotation.location.includes('database');
   const includeSystemType = annotation.kind.includes('system');
@@ -41,34 +32,37 @@ export const getTypenames = ({
   const includeRegistered = annotation.registered.includes('registered');
   const includeUnregistered = annotation.registered.includes('unregistered');
 
-  const runtimeTypenames = includeRuntime
-    ? client.graph.schemaRegistry.schemas
-        .filter((schema) => {
-          const relation = getTypeAnnotation(schema)?.kind === EntityKind.Relation;
-          if (relation) {
-            return includeSystemType;
-          }
+  const runtimeTypenames =
+    includeRuntime && space
+      ? space.db.schemaRegistry
+          .query({ location: ['runtime'] })
+          .runSync()
+          .filter((schema) => {
+            const relation = getTypeAnnotation(schema)?.kind === EntityKind.Relation;
+            if (relation) {
+              return includeSystemType;
+            }
 
-          const system = SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false));
-          if (system) {
-            return includeSystemType;
-          }
+            const system = SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false));
+            if (system) {
+              return includeSystemType;
+            }
 
-          return includeUserType;
-        })
-        .filter((schema) => {
-          const registered = space?.properties.staticRecords?.includes(Type.getTypename(schema));
-          return registered ? includeRegistered : includeUnregistered;
-        })
-        .map((schema) => Type.getTypename(schema))
-    : [];
+            return includeUserType;
+          })
+          .filter((schema) => {
+            const registered = space?.properties.staticRecords?.includes(Type.getTypename(schema));
+            return registered ? includeRegistered : includeUnregistered;
+          })
+          .map((schema) => Type.getTypename(schema))
+      : [];
 
   const databaseTypenames =
     includeDatabase && includeRegistered && space
       ? space.db.schemaRegistry
-          .query()
+          .query({ location: ['database'] })
           .runSync()
-          .map((schema) => schema.typename)
+          .map((schema) => Type.getTypename(schema))
       : [];
 
   return Array.from(new Set<string>([...runtimeTypenames, ...databaseTypenames])).sort();

package/src/types/index.ts

@@ -2,5 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './capabilities';
+export * from './events';
 export * from './form';
 export * from './types';