@dxos/plugin-space 0.8.2-main.f081794 → 0.8.2-main.fbd8ed0

package/src/components/SyncStatus/InlineSyncStatus.tsx

@@ -2,6 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Option } from 'effect';
 import React, { useEffect, useState } from 'react';
 
 import { useAppGraph } from '@dxos/app-framework';
@@ -40,7 +41,7 @@ export const InlineSyncStatus = ({ space, open }: { space: Space; open?: boolean
   const attended = useAttended();
   const startOfAttention = attended.at(-1);
   const path = usePath(graph, startOfAttention);
-  const containsAttended = !open && !isAttended && id && path ? path.includes(id) : false;
+  const containsAttended = !open && !isAttended && id && Option.isSome(path) ? path.value.includes(id) : false;
 
   const connectedToEdge = useEdgeStatus() === EdgeStatus.CONNECTED;
   // TODO(wittjosiah): This is not reactive.
@@ -49,21 +50,13 @@ export const InlineSyncStatus = ({ space, open }: { space: Space; open?: boolean
   const syncing = connectedToEdge && edgeSyncEnabled && syncState && syncState.missingOnLocal > 0;
 
   return (
-    <Tooltip.Root>
-      <Tooltip.Trigger asChild>
-        <AttentionGlyph
-          syncing={syncing}
-          attended={isAttended}
-          containsAttended={containsAttended}
-          classNames='self-center mie-1'
-        />
-      </Tooltip.Trigger>
-      <Tooltip.Portal>
-        <Tooltip.Content side='bottom' classNames='z-[70]'>
-          <span>{t('syncing label')}</span>
-          <Tooltip.Arrow />
-        </Tooltip.Content>
-      </Tooltip.Portal>
-    </Tooltip.Root>
+    <Tooltip.Trigger asChild content={t('syncing label')} side='bottom'>
+      <AttentionGlyph
+        syncing={syncing}
+        attended={isAttended}
+        containsAttended={containsAttended}
+        classNames='self-center mie-1'
+      />
+    </Tooltip.Trigger>
   );
 };

package/src/components/index.ts

@@ -11,11 +11,9 @@ export * from './MembersContainer';
 export * from './MenuFooter';
 export * from './ObjectSettings';
 export * from './PersistenceStatus';
-export * from './PopoverAddSpace';
 export * from './PopoverRenameObject';
 export * from './PopoverRenameSpace';
 export * from './SchemaContainer';
-export * from './ShareSpaceButton';
 export * from './SpacePresence';
 export * from './SpacePluginSettings';
 export * from './SpaceSettings';

package/src/hooks/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './useActiveSpace';
 export * from './useInputSurfaceLookup';
 export * from './usePath';

package/src/hooks/useActiveSpace.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, useLayout, type PluginContext } from '@dxos/app-framework';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { parseId, useSpace } from '@dxos/react-client/echo';
+
+export const getActiveSpace = (context: PluginContext) => {
+  const layout = context.getCapability(Capabilities.Layout);
+  const client = context.getCapability(ClientCapabilities.Client);
+  const { spaceId } = parseId(layout.workspace);
+  return spaceId ? client.spaces.get(spaceId) : undefined;
+};
+
+export const useActiveSpace = () => {
+  const layout = useLayout();
+  const { spaceId } = parseId(layout.workspace);
+  return useSpace(spaceId);
+};

package/src/hooks/useInputSurfaceLookup.tsx

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema as S } from 'effect';
+import { type Schema } from 'effect';
 import React, { useCallback } from 'react';
 
 import { usePluginManager, isSurfaceAvailable, Surface } from '@dxos/app-framework';
@@ -18,7 +18,7 @@ export const useInputSurfaceLookup = (baseData?: Record<string, any>) => {
   const pluginManager = usePluginManager();
 
   return useCallback(
-    ({ prop, schema, inputProps }: { prop: string; schema: S.Schema<any>; inputProps: InputProps }) => {
+    ({ 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;

package/src/hooks/usePath.ts

@@ -2,9 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Option } from 'effect';
 import { useEffect, useState } from 'react';
 
-import { type Graph } from '@dxos/plugin-graph';
+import { type ReadableGraph } from '@dxos/plugin-graph';
 
 /**
  * React hook to get a path from the graph.
@@ -15,15 +16,17 @@ import { type Graph } from '@dxos/plugin-graph';
  * @returns Path if found, undefined otherwise.
  */
 // TODO(wittjosiah): Factor out.
-export const usePath = (graph: Graph, id?: string, timeout?: number): string[] | undefined => {
-  const [pathState, setPathState] = useState<string[] | undefined>(id ? graph.getPath({ target: id }) : undefined);
+export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {
+  const [pathState, setPathState] = useState<Option.Option<string[]>>(
+    id ? graph.getPath({ target: id }) : Option.none(),
+  );
 
   useEffect(() => {
     if (!id && pathState) {
-      setPathState(undefined);
+      setPathState(Option.none());
     }
 
-    if (pathState?.at(-1) === id || !id) {
+    if ((Option.isSome(pathState) && pathState.value.at(-1) === id) || !id) {
       return;
     }
 
@@ -32,7 +35,7 @@ export const usePath = (graph: Graph, id?: string, timeout?: number): string[] |
       try {
         const path = await graph.waitForPath({ target: id }, { timeout });
         if (path) {
-          setPathState(path);
+          setPathState(Option.some(path));
         }
       } catch {}
     });

package/src/index.ts

@@ -6,6 +6,7 @@ export { SpaceCapabilities, ThreadCapabilities } from './capabilities';
 export { SpaceEvents, ThreadEvents } from './events';
 
 export * from './components';
+export * from './hooks';
 export * from './meta';
 export * from './SpacePlugin';
 export * from './util';

package/src/translations.ts

@@ -15,7 +15,6 @@ export default [
       [SPACE_PLUGIN]: {
         'plugin name': 'Spaces',
         'first run message': 'Nothing selected.',
-        'add space label': 'Create or join a space',
         'create space label': 'Create space',
         'join space label': 'Join space',
         'empty space message': 'No documents',
@@ -95,7 +94,7 @@ export default [
         'join success label': 'Successfully joined space',
         'name label': 'Name',
         'name placeholder': 'Name',
-        'object settings label': 'Settings',
+        'object settings label': 'Details',
         'edge replication label': 'Enable EDGE Replication',
         'saving locally label': 'Writing to disk',
         'downloading label': 'Replicating from peers',

package/src/types/collection.ts

@@ -2,15 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Expando, Ref, S, TypedObject } from '@dxos/echo-schema';
+import { Schema } from 'effect';
+
+import { Expando, Ref, TypedObject } from '@dxos/echo-schema';
 
 export class CollectionType extends TypedObject({ typename: 'dxos.org/type/Collection', version: '0.1.0' })({
-  name: S.optional(S.String),
-  objects: S.mutable(S.Array(Ref(Expando))),
+  name: Schema.optional(Schema.String),
+  objects: Schema.mutable(Schema.Array(Ref(Expando))),
   // Key is schema typename and value is reference to a view object of the associated schema.
   // Having collection reference the views rather than vice versa ensures that the state converges to a single view per key (i.e. type).
   // This also leaves open a future where this key could be changed to allow for multiple stack views per section.
   // TODO(wittjosiah): Any way to make this more type safe?
   // TODO(wittjosiah): Should the views be separate objects or just be schemas for view data in this record?
-  views: S.mutable(S.Record({ key: S.String, value: Ref(Expando) })),
+  views: Schema.mutable(Schema.Record({ key: Schema.String, value: Ref(Expando) })),
 }) {}

package/src/types/thread.ts

@@ -2,23 +2,29 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Expando, Ref, S, TypedObject } from '@dxos/echo-schema';
-import { MessageType } from '@dxos/schema';
+import { Schema } from 'effect';
+
+import { Expando, Ref, TypedObject } from '@dxos/echo-schema';
+import { DataType } from '@dxos/schema';
 
 // TODO(wittjosiah): These types were placed here rather than in @dxos/plugin-thread
 //   in order to avoid a circular dependency between threads and other objects that use threads.
 
-export const ThreadStatus = S.Union(S.Literal('staged'), S.Literal('active'), S.Literal('resolved'));
+export const ThreadStatus = Schema.Union(
+  Schema.Literal('staged'),
+  Schema.Literal('active'),
+  Schema.Literal('resolved'),
+);
 
 export class ThreadType extends TypedObject({ typename: 'dxos.org/type/Thread', version: '0.1.0' })({
-  name: S.optional(S.String),
+  name: Schema.optional(Schema.String),
   /** AM cursor-range: 'from:to'. */
-  anchor: S.optional(S.String),
-  status: S.optional(ThreadStatus),
-  messages: S.mutable(S.Array(Ref(MessageType))),
+  anchor: Schema.optional(Schema.String),
+  status: Schema.optional(ThreadStatus),
+  messages: Schema.mutable(Schema.Array(Ref(DataType.Message))),
 }) {}
 
 export class ChannelType extends TypedObject({ typename: 'dxos.org/type/Channel', version: '0.1.0' })({
-  name: S.optional(S.String),
+  name: Schema.optional(Schema.String),
   queue: Ref(Expando),
 }) {}

package/src/types/types.ts

@@ -2,11 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Schema } from 'effect';
+
 import { type AnyIntentChain } from '@dxos/app-framework';
-import { S, type Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
+import { type Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
 import { type PublicKey } from '@dxos/react-client';
 // TODO(wittjosiah): This pulls in full client.
 import { EchoObjectSchema, ReactiveObjectSchema, type Space, SpaceSchema } from '@dxos/react-client/echo';
+import { CancellableInvitationObservable, Invitation } from '@dxos/react-client/invitations';
 import { type ComplexMap } from '@dxos/util';
 
 import { CollectionType } from './collection';
@@ -62,16 +65,16 @@ export type PluginState = {
   enabledEdgeReplication: boolean;
 };
 
-export const SpaceSettingsSchema = S.mutable(
-  S.Struct({
+export const SpaceSettingsSchema = Schema.mutable(
+  Schema.Struct({
     /**
      * Show closed spaces.
      */
-    showHidden: S.Boolean,
+    showHidden: Schema.Boolean,
   }),
 );
 
-export type SpaceSettingsProps = S.Schema.Type<typeof SpaceSettingsSchema>;
+export type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;
 
 // TODO(wittjosiah): Reconcile with graph export serializers.
 
@@ -92,18 +95,18 @@ export interface TypedObjectSerializer<T extends Expando = Expando> {
 export const IconAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Icon');
 export const HueAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Hue');
 
-export const SpaceForm = S.Struct({
-  name: S.optional(S.String.annotations({ title: 'Name' })),
-  icon: S.optional(S.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),
-  hue: S.optional(S.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
+export const SpaceForm = Schema.Struct({
+  name: Schema.optional(Schema.String.annotations({ title: 'Name' })),
+  icon: Schema.optional(Schema.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),
+  hue: Schema.optional(Schema.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
   // TODO(wittjosiah): Make optional with default value.
-  edgeReplication: S.Boolean.annotations({ title: 'Enable EDGE Replication' }),
+  edgeReplication: Schema.Boolean.annotations({ title: 'Enable EDGE Replication' }),
 });
 
 export type ObjectForm<T extends BaseObject = BaseObject> = {
-  // TODO(dmaretskyi): Change to S.Schema.AnyNoContext
+  // TODO(dmaretskyi): Change to Schema.Schema.AnyNoContext
   objectSchema: TypedObject;
-  formSchema?: S.Schema<T, any>;
+  formSchema?: Schema.Schema<T, any>;
   hidden?: boolean;
   getIntent: (props: T, options: { space: Space }) => AnyIntentChain;
 };
@@ -113,166 +116,176 @@ export const defineObjectForm = <T extends BaseObject>(form: ObjectForm<T>) => f
 export const SPACE_ACTION = `${SPACE_PLUGIN}/action`;
 
 export namespace SpaceAction {
-  export class OpenCreateSpace extends S.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
-    input: S.Void,
-    output: S.Void,
+  export class OpenCreateSpace extends Schema.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
+    input: Schema.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Create extends S.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
+  export class Create extends Schema.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
     input: SpaceForm,
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       space: SpaceSchema,
     }),
   }) {}
 
-  export class Join extends S.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
-    input: S.Struct({
-      invitationCode: S.optional(S.String),
-      onDone: S.optional(S.Any),
+  export class Join extends Schema.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
+    input: Schema.Struct({
+      invitationCode: Schema.optional(Schema.String),
+      onDone: Schema.optional(Schema.Any),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Share extends S.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
-    input: S.Struct({
+  export class OpenMembers extends Schema.TaggedClass<OpenMembers>()(`${SPACE_ACTION}/open-members`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Lock extends S.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
-    input: S.Struct({
+  export class Share extends Schema.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
+    input: Schema.Struct({
       space: SpaceSchema,
+      type: Schema.Enums(Invitation.Type),
+      authMethod: Schema.Enums(Invitation.AuthMethod),
+      multiUse: Schema.Boolean,
+      target: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.instanceOf(CancellableInvitationObservable),
   }) {}
 
-  export class Unlock extends S.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
-    input: S.Struct({
+  export class GetShareLink extends Schema.TaggedClass<GetShareLink>()(`${SPACE_ACTION}/get-share-link`, {
+    input: Schema.Struct({
       space: SpaceSchema,
+      target: Schema.optional(Schema.String),
+      copyToClipboard: Schema.optional(Schema.Boolean),
     }),
-    output: S.Void,
+    output: Schema.String,
   }) {}
 
-  export class Rename extends S.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
-    input: S.Struct({
+  export class Lock extends Schema.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      caller: S.optional(S.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class AddSpace extends S.TaggedClass<AddSpace>()(`${SPACE_ACTION}/add-space`, {
-    input: S.Void,
-    output: S.Void,
+  export class Unlock extends Schema.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
+    input: Schema.Struct({
+      space: SpaceSchema,
+    }),
+    output: Schema.Void,
   }) {}
 
-  export class AddSpaceMenuGroup extends S.TaggedClass<AddSpaceMenuGroup>()(`${SPACE_ACTION}/add-space-menu-group`, {
-    input: S.Void,
-    output: S.Void,
+  export class Rename extends Schema.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
+    input: Schema.Struct({
+      space: SpaceSchema,
+      caller: Schema.optional(Schema.String),
+    }),
+    output: Schema.Void,
   }) {}
 
   // TODO(wittjosiah): Handle scrolling to section.
   //   This maybe motivates making the space settings its own deck?
-  export class OpenSettings extends S.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
-    input: S.Struct({ space: SpaceSchema }),
-    output: S.Void,
+  export class OpenSettings extends Schema.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
+    input: Schema.Struct({ space: SpaceSchema }),
+    output: Schema.Void,
   }) {}
 
-  export class Open extends S.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
-    input: S.Struct({
+  export class Open extends Schema.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Close extends S.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
-    input: S.Struct({
+  export class Close extends Schema.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Migrate extends S.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
-    input: S.Struct({
+  export class Migrate extends Schema.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      version: S.optional(S.String),
+      version: Schema.optional(Schema.String),
     }),
-    output: S.Boolean,
+    output: Schema.Boolean,
   }) {}
 
-  export class OpenCreateObject extends S.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
-    input: S.Struct({
-      target: S.Union(SpaceSchema, CollectionType),
-      navigable: S.optional(S.Boolean),
+  export class OpenCreateObject extends Schema.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
+    input: Schema.Struct({
+      target: Schema.Union(SpaceSchema, CollectionType),
+      navigable: Schema.optional(Schema.Boolean),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class AddObject extends S.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
-    input: S.Struct({
+  export class AddObject extends Schema.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
+    input: Schema.Struct({
       object: ReactiveObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
-      hidden: S.optional(S.Boolean),
+      target: Schema.Union(SpaceSchema, CollectionType),
+      hidden: Schema.optional(Schema.Boolean),
     }),
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       object: EchoObjectSchema,
     }),
   }) {}
 
-  export const DeletionData = S.Struct({
-    objects: S.Array(EchoObjectSchema),
+  export const DeletionData = Schema.Struct({
+    objects: Schema.Array(EchoObjectSchema),
     parentCollection: CollectionType,
-    indices: S.Array(S.Number),
-    nestedObjectsList: S.Array(S.Array(EchoObjectSchema)),
-    wasActive: S.Array(S.String),
+    indices: Schema.Array(Schema.Number),
+    nestedObjectsList: Schema.Array(Schema.Array(EchoObjectSchema)),
+    wasActive: Schema.Array(Schema.String),
   });
 
-  export type DeletionData = S.Schema.Type<typeof DeletionData>;
+  export type DeletionData = Schema.Schema.Type<typeof DeletionData>;
 
-  export class RemoveObjects extends S.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
-    input: S.Struct({
-      objects: S.Array(EchoObjectSchema),
-      target: S.optional(CollectionType),
-      deletionData: S.optional(DeletionData),
+  export class RemoveObjects extends Schema.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
+    input: Schema.Struct({
+      objects: Schema.Array(EchoObjectSchema),
+      target: Schema.optional(CollectionType),
+      deletionData: Schema.optional(DeletionData),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class RenameObject extends S.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
-    input: S.Struct({
+  export class RenameObject extends Schema.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      caller: S.optional(S.String),
+      caller: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class DuplicateObject extends S.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
-    input: S.Struct({
+  export class DuplicateObject extends Schema.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
+      target: Schema.Union(SpaceSchema, CollectionType),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class WaitForObject extends S.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
-    input: S.Struct({
-      id: S.optional(S.String),
+  export class WaitForObject extends Schema.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
+    input: Schema.Struct({
+      id: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 }
 
 export namespace CollectionAction {
-  export class Create extends S.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
-    input: S.Struct({
-      name: S.optional(S.String),
+  export class Create extends Schema.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
+    input: Schema.Struct({
+      name: Schema.optional(Schema.String),
     }),
-    output: S.Struct({
+    output: Schema.Struct({
       object: CollectionType,
     }),
   }) {}