@dxos/plugin-explorer 0.8.4-main.f5c0578 → 0.8.4-main.fcc0d83b33

package/src/components/Graph/D3ForceGraph.tsx

@@ -2,11 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import React, { type FC, useCallback, useEffect, useMemo, useRef } from 'react';
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import React, { type ComponentPropsWithoutRef, useCallback, useEffect, useMemo, useRef } from 'react';
 
 import { Obj } from '@dxos/echo';
 import { SelectionModel } from '@dxos/graph';
-import { type ThemedClassName } from '@dxos/react-ui';
 import {
   type GraphController,
   GraphForceProjector,
@@ -15,87 +15,94 @@ import {
   SVG,
   type SVGContext,
 } from '@dxos/react-ui-graph';
-import { getHashColor } from '@dxos/react-ui-theme';
 import { type SpaceGraphEdge, type SpaceGraphModel, type SpaceGraphNode } from '@dxos/schema';
-
+import { composable, composableProps, getHashStyles } from '@dxos/ui-theme';
 import '@dxos/react-ui-graph/styles/graph.css';
 
-export type D3ForceGraphProps = ThemedClassName<
-  {
-    model?: SpaceGraphModel;
-    match?: RegExp;
-    selection?: SelectionModel;
-    grid?: boolean;
-  } & Pick<GraphProps, 'drag'>
->;
+export type D3ForceGraphProps = {
+  model?: SpaceGraphModel;
+  match?: RegExp;
+  selection?: SelectionModel;
+  grid?: boolean;
+} & Pick<GraphProps, 'drag'> &
+  ComponentPropsWithoutRef<'div'>;
+
+const EMPTY_ATOM = Atom.make<{ nodes: SpaceGraphNode[]; edges: SpaceGraphEdge[] }>({ nodes: [], edges: [] });
+
+export const D3ForceGraph = composable<HTMLDivElement, D3ForceGraphProps>(
+  ({ model, selection: _selection, grid, drag, ...props }, forwardedRef) => {
+    // TODO(wittjosiah): This should go into Graph.tsx but for some reason doesn't work.
+    useAtomValue(model?.graphAtom ?? EMPTY_ATOM);
 
-export const D3ForceGraph: FC<D3ForceGraphProps> = ({ classNames, model, selection: _selection, grid, ...props }) => {
-  const context = useRef<SVGContext>(null);
-  const projector = useMemo<GraphForceProjector | undefined>(() => {
-    if (context.current) {
-      return new GraphForceProjector(context.current, {
-        attributes: {
-          linkForce: (edge) => {
-            // TODO(burdon): Check type (currently assumes Employee property).
-            // Edge shouldn't contribute to force if it's not active.
-            return edge.data?.object?.active !== false;
+    const svgRef = useRef<SVGContext>(null);
+    const projector = useMemo<GraphForceProjector | undefined>(() => {
+      if (svgRef.current) {
+        return new GraphForceProjector(svgRef.current, {
+          attributes: {
+            linkForce: (edge) => {
+              // TODO(burdon): Check type (currently assumes Employee property).
+              // Edge shouldn't contribute to force if it's not active.
+              return edge.data?.object?.active !== false;
+            },
           },
-        },
-        forces: {
-          point: {
-            strength: 0.01,
+          forces: {
+            point: {
+              strength: 0.01,
+            },
           },
-        },
-      });
-    }
-  }, [context.current]);
+        });
+      }
+    }, []);
 
-  const graph = useRef<GraphController>(null);
-  const selection = useMemo(() => _selection ?? new SelectionModel(), [_selection]);
-  useEffect(() => graph.current?.repaint(), [selection.selected.value]);
+    const graph = useRef<GraphController>(null);
+    const selection = useMemo(() => _selection ?? new SelectionModel(), [_selection]);
+    useEffect(() => selection.subscribe(() => graph.current?.repaint()), [selection]);
 
-  const handleSelect = useCallback<NonNullable<GraphProps['onSelect']>>(
-    (node) => {
-      if (selection.contains(node.id)) {
-        selection.remove(node.id);
-      } else {
-        selection.add(node.id);
-      }
-    },
-    [selection],
-  );
+    const handleSelect = useCallback<NonNullable<GraphProps['onSelect']>>(
+      (node) => {
+        if (selection.contains(node.id)) {
+          selection.remove(node.id);
+        } else {
+          selection.add(node.id);
+        }
+      },
+      [selection],
+    );
 
-  return (
-    <SVG.Root ref={context} classNames={classNames}>
-      <SVG.Markers />
-      {grid && <SVG.Grid axis />}
-      <SVG.Zoom extent={[1 / 2, 2]}>
-        <SVG.Graph<SpaceGraphNode, SpaceGraphEdge>
-          {...props}
-          ref={graph}
-          model={model}
-          projector={projector}
-          labels={{
-            text: (node) => {
-              return node.data?.data.label ?? node.id;
-            },
-          }}
-          attributes={{
-            node: (node: GraphLayoutNode<SpaceGraphNode>) => {
-              const obj = node.data?.data.object;
-              return {
-                data: {
-                  color: getHashColor(obj && Obj.getTypename(obj))?.color,
+    return (
+      <div {...composableProps(props, { classNames: 'dx-container' })} ref={forwardedRef}>
+        <SVG.Root ref={svgRef}>
+          <SVG.Markers />
+          {grid && <SVG.Grid axis />}
+          <SVG.Zoom extent={[1 / 2, 2]}>
+            <SVG.Graph<SpaceGraphNode, SpaceGraphEdge>
+              drag={drag}
+              ref={graph}
+              model={model}
+              projector={projector}
+              labels={{
+                text: (node) => {
+                  return node.data?.data.label ?? node.id;
                 },
-                classes: {
-                  'dx-selected': selection.contains(node.id),
+              }}
+              attributes={{
+                node: (node: GraphLayoutNode<SpaceGraphNode>) => {
+                  const obj = node.data?.data.object;
+                  return {
+                    data: {
+                      color: getHashStyles(obj && Obj.getTypename(obj))?.hue,
+                    },
+                    classes: {
+                      'dx-selected': selection.contains(node.id),
+                    },
+                  };
                 },
-              };
-            },
-          }}
-          onSelect={handleSelect}
-        />
-      </SVG.Zoom>
-    </SVG.Root>
-  );
-};
+              }}
+              onSelect={handleSelect}
+            />
+          </SVG.Zoom>
+        </SVG.Root>
+      </div>
+    );
+  },
+);

package/src/components/Graph/ForceGraph.stories.tsx

@@ -2,64 +2,82 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useState } from 'react';
 
-import { type Meta } from '@storybook/react-vite';
-import React, { useEffect, useState } from 'react';
-
-import { Obj } from '@dxos/echo';
-import { faker } from '@dxos/random';
+import { Type } from '@dxos/echo';
+import { View } from '@dxos/echo';
+import { random } from '@dxos/random';
 import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
-import { DataType } from '@dxos/schema';
+import { useAsyncEffect } from '@dxos/react-ui';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { ViewModel } from '@dxos/schema';
 import { type ValueGenerator } from '@dxos/schema/testing';
-import { render, withLayout, withTheme } from '@dxos/storybook-utils';
+import { withRegistry } from '@dxos/storybook-utils';
+import { HasRelationship, Organization, Person, Pipeline } from '@dxos/types';
 
-import { useGraphModel } from '../../hooks';
-import { ViewType } from '../../types';
+import { useGraphModel } from '#hooks';
+import { Graph } from '#types';
 
 import { ForceGraph } from './ForceGraph';
 import { generate } from './testing';
 
-const generator = faker as any as ValueGenerator;
+const generator = random as any as ValueGenerator;
 
-faker.seed(1);
+random.seed(1);
 
 const DefaultStory = () => {
   const client = useClient();
   const [space, setSpace] = useState<Space>();
-  const [view, setView] = useState<ViewType>();
-  useEffect(() => {
-    const space = client.spaces.default;
+  const [graph, setGraph] = useState<Graph.Graph>();
+
+  useAsyncEffect(async () => {
+    const space = client.spaces.get()[0];
     void generate(space, generator);
-    const view = space.db.add(Obj.make(ViewType, { name: '', type: '' }));
+    const { view } = await ViewModel.makeFromDatabase({ db: space.db, typename: Type.getTypename(Graph.Graph) });
+    const graph = Graph.make({ name: 'Test', view });
+    space.db.add(graph);
     setSpace(space);
-    setView(view);
-  }, []);
+    setGraph(graph);
+  }, [client]);
 
   const model = useGraphModel(space);
-  if (!model || !space || !view) {
-    return null;
+  if (!model || !space || !graph) {
+    return <Loading data={{ model: !!model, space: !!space, graph: !!graph }} />;
   }
 
   return <ForceGraph model={model} />;
 };
 
-const meta: Meta = {
-  title: 'plugins/plugin-explorer/ForceGraph',
+const meta = {
+  title: 'plugins/plugin-explorer/components/ForceGraph',
   component: ForceGraph,
-  render: render(DefaultStory),
+  render: DefaultStory,
   decorators: [
+    withRegistry,
+    withTheme(),
+    withLayout(),
     withClientProvider({
       createSpace: true,
-      types: [ViewType, DataType.HasRelationship, DataType.Organization, DataType.Project, DataType.Person],
+      types: [
+        Graph.Graph,
+        View.View,
+        HasRelationship.HasRelationship,
+        Organization.Organization,
+        Pipeline.Pipeline,
+        Person.Person,
+      ],
     }),
-    withTheme,
-    withLayout({ fullscreen: true }),
   ],
-};
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof ForceGraph>;
 
 export default meta;
 
-export const Default = {};
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/Graph/ForceGraph.tsx

@@ -20,9 +20,9 @@ export type ForceGraphProps = {
 export const ForceGraph: FC<ForceGraphProps> = ({ model, match }) => {
   const { ref, width, height } = useResizeDetector({ refreshRate: 200 });
   const rootRef = useRef<HTMLDivElement>(null);
-  const forceGraph = useRef<NativeForceGraph>();
+  const forceGraph = useRef<NativeForceGraph>(null);
 
-  const filteredRef = useRef<SearchResult[]>();
+  const filteredRef = useRef<SearchResult[]>([]);
   filteredRef.current = filterObjectsSync(model?.objects ?? [], match);
 
   const [data, setData] = useState<GraphAdapter>();
@@ -48,7 +48,7 @@ export const ForceGraph: FC<ForceGraphProps> = ({ model, match }) => {
 
     return () => {
       forceGraph.current?.pauseAnimation().graphData({ nodes: [], links: [] });
-      forceGraph.current = undefined;
+      forceGraph.current = null;
     };
   }, []);
 

package/src/components/Graph/adapter.ts

@@ -25,19 +25,25 @@ export class GraphAdapter implements GraphData {
   private readonly _nodes: GraphNode[] = [];
   private readonly _links: GraphLink[] = [];
 
-  constructor(private readonly graph: Graph) {
-    this._nodes = graph.nodes.map((node) => ({
+  constructor(private readonly graph: Graph.Any) {
+    this._nodes = graph.nodes.map((node: Graph.Node.Any) => ({
       id: node.id,
       type: node.type,
       data: node.data,
     }));
 
-    this._links = graph.edges.map((edge) => ({
-      type: edge.type,
-      source: edge.source,
-      target: edge.target,
-      data: edge.data,
-    }));
+    // Build a set of node IDs for efficient lookup.
+    const nodeIds = new Set(this._nodes.map((node) => node.id));
+
+    // Filter out edges where source or target node doesn't exist.
+    this._links = graph.edges
+      .filter((edge: Graph.Edge.Any) => nodeIds.has(edge.source) && nodeIds.has(edge.target))
+      .map((edge: Graph.Edge.Any) => ({
+        type: edge.type,
+        source: edge.source,
+        target: edge.target,
+        data: edge.data,
+      }));
   }
 
   get nodes() {

package/src/components/Graph/testing.ts

@@ -4,16 +4,16 @@
 
 import { type Space } from '@dxos/client/echo';
 import { type Obj, Query, Relation } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
 import { type TypeSpec, type ValueGenerator, createObjectFactory } from '@dxos/schema/testing';
+import { HasRelationship, Organization, Person, Pipeline } from '@dxos/types';
 import { range } from '@dxos/util';
 
-const getObject = (objects: Obj.Any[]) => objects[Math.floor(Math.random() * objects.length)];
+const getObject = (objects: Obj.Unknown[]) => objects[Math.floor(Math.random() * objects.length)];
 
 const defaultTypes: TypeSpec[] = [
-  { type: DataType.Organization, count: 5 },
-  { type: DataType.Project, count: 5 },
-  { type: DataType.Person, count: 10 },
+  { type: Organization.Organization, count: 5 },
+  { type: Pipeline.Pipeline, count: 5 },
+  { type: Person.Person, count: 10 },
 ];
 
 export type GenerateOptions = {
@@ -24,7 +24,10 @@ export type GenerateOptions = {
   };
 };
 
-const defaultRelations: GenerateOptions['relations'] = { kind: 'friend', count: 10 };
+const defaultRelations: GenerateOptions['relations'] = {
+  kind: 'friend',
+  count: 10,
+};
 
 /**
  * @deprecated Use @dxos/schema.
@@ -38,13 +41,13 @@ export const generate = async (
   await createObjects(spec);
 
   // Add relations between objects.
-  const { objects: contacts } = await space.db.query(Query.type(DataType.Person)).run();
+  const contacts = await space.db.query(Query.type(Person.Person)).run();
   for (const _ of range(relations.count)) {
     const source = getObject(contacts);
     const target = getObject(contacts);
     if (source.id !== target.id) {
       space.db.add(
-        Relation.make(DataType.HasRelationship, {
+        Relation.make(HasRelationship.HasRelationship, {
           [Relation.Source]: source,
           [Relation.Target]: target,
           kind: relations.kind,

package/src/components/Tree/Tree.stories.tsx

@@ -2,15 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useEffect, useState } from 'react';
 
-import { type Meta } from '@storybook/react-vite';
-import React, { type FC, useEffect, useState } from 'react';
-
-import { faker } from '@dxos/random';
+import { invariant } from '@dxos/invariant';
+import { random } from '@dxos/random';
 import { useClient } from '@dxos/react-client';
 import { type ClientRepeatedComponentProps, ClientRepeater } from '@dxos/react-client/testing';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { withRegistry } from '@dxos/storybook-utils';
 
 import { Tree, type TreeComponentProps } from './Tree';
 import { Tree as TreeModel, TreeType } from './types';
@@ -18,11 +18,14 @@ import { Tree as TreeModel, TreeType } from './types';
 // TODO(burdon): Storybook for Graph/Tree/Plot (generics); incl. GraphModel.
 // TODO(burdon): Type for all Explorer components (Space, Object, Query, etc.) incl.
 
-faker.seed(1);
+random.seed(1);
+
+type ComponentProps = ClientRepeatedComponentProps & { type?: TreeComponentProps<any>['variant'] };
 
-const Story: FC<ClientRepeatedComponentProps & { type?: TreeComponentProps<any>['variant'] }> = ({ type }) => {
+const Component = ({ type }: ComponentProps) => {
   const client = useClient();
-  const space = client.spaces.default;
+  const space = client.spaces.get()[0];
+  invariant(space, 'Tree story requires at least one space');
   const [object, setObject] = useState<TreeType>();
   useEffect(() => {
     setTimeout(() => {
@@ -38,32 +41,38 @@ const Story: FC<ClientRepeatedComponentProps & { type?: TreeComponentProps<any>[
   return <Tree space={space} selected={object?.id} variant={type} />;
 };
 
-export const Tidy = {
+const DefaultStory = () => {
+  return <ClientRepeater component={Component} types={[TreeType]} createSpace />;
+};
+
+const meta = {
+  title: 'plugins/plugin-explorer/components/Tree',
+  component: Tree as any,
+  render: DefaultStory,
+  decorators: [withRegistry, withTheme(), withLayout()],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Tidy: Story = {
   args: {
     type: 'tidy',
   },
 };
 
-export const Radial = {
+export const Radial: Story = {
   args: {
     type: 'radial',
   },
 };
 
-export const Edge = {
+export const Edge: Story = {
   args: {
     type: 'edge',
   },
 };
-
-const meta: Meta = {
-  title: 'plugins/plugin-explorer/Tree',
-  component: Tree,
-  render: () => <ClientRepeater component={Story} types={[TreeType]} createSpace />,
-  decorators: [withTheme, withLayout({ fullscreen: true })],
-  parameters: {
-    layout: 'fullscreen',
-  },
-};
-
-export default meta;

package/src/components/Tree/Tree.tsx

@@ -2,7 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-import React, { useEffect, useRef, useState } from 'react';
+import { RegistryContext } from '@effect-atom/atom-react';
+import React, { useContext, useEffect, useRef, useState } from 'react';
 
 import { type Space } from '@dxos/client/echo';
 import { useAsyncState } from '@dxos/react-ui';
@@ -62,7 +63,11 @@ export type TreeComponentProps<N = unknown> = {
 
 // TODO(burdon): Label accessor.
 export const Tree = <N,>({ space, selected, variant = 'tidy', onNodeClick }: TreeComponentProps<N>) => {
-  const [model] = useAsyncState(async () => (space ? new SpaceGraphModel().open(space) : undefined), [space, selected]);
+  const registry = useContext(RegistryContext);
+  const [model] = useAsyncState(
+    async () => (space ? new SpaceGraphModel(registry).open(space.db) : undefined),
+    [space, selected, registry],
+  );
 
   const [tree, setTree] = useState<TreeNode>();
   useEffect(() => {
@@ -75,8 +80,8 @@ export const Tree = <N,>({ space, selected, variant = 'tidy', onNodeClick }: Tre
   const context = useRef<SVGContext>(null);
 
   useEffect(() => {
-    if (context.current) {
-      const { width, height } = context.current.size!;
+    if (context.current?.size) {
+      const { width, height } = context.current.size;
       const size = Math.min(width, height);
       const radius = size * 0.4;
       const options = {
@@ -100,7 +105,7 @@ export const Tree = <N,>({ space, selected, variant = 'tidy', onNodeClick }: Tre
   }, [context.current, tree]);
 
   return (
-    <div onClick={() => onNodeClick?.()}>
+    <div className='grow' onClick={() => onNodeClick?.()}>
       <SVG.Root ref={context} />
     </div>
   );

package/src/components/Tree/testing/generator.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Key } from '@dxos/echo';
+import { Key, Obj } from '@dxos/echo';
 import { range } from '@dxos/util';
 
 import { Tree, type TreeNodeType } from '../types';
@@ -16,7 +16,9 @@ const random = (min: number, max: number) => Math.floor(Math.random() * (max - m
  */
 export const createTree = (spec: NumberOrNumberArray[] = [], createText?: () => string): Tree => {
   const tree = new Tree();
-  tree.root.data = { text: 'root' };
+  Obj.update(tree.tree, () => {
+    tree.root.data = { text: 'root' };
+  });
 
   const createNodes = (parent: TreeNodeType, spec: NumberOrNumberArray = 0): TreeNodeType[] => {
     const count = Array.isArray(spec) ? random(spec[0], spec[1]) : spec;

package/src/components/Tree/types/tree.test.ts

@@ -5,14 +5,13 @@
 import { describe, test } from 'vitest';
 
 import { Obj, Ref } from '@dxos/echo';
-import { faker } from '@dxos/random';
-import { DataType } from '@dxos/schema';
+import { random } from '@dxos/random';
+import { Task } from '@dxos/types';
 
 import { createTree } from '../testing';
-
 import { type Tree } from './tree';
 
-faker.seed(0);
+random.seed(0);
 
 const print = (tree: Tree) => {
   let count = 0;
@@ -124,11 +123,13 @@ describe('tree', () => {
   });
 
   test('task', ({ expect }) => {
-    const task = Obj.make(DataType.Task, { title: 'Test task.' });
+    const task = Obj.make(Task.Task, { title: 'Test task.' });
     expect(task.title).to.eq('Test task.');
 
     const tree = createTree();
     const node = tree.addNode(tree.root);
-    node.ref = Ref.make(task);
+    Obj.update(tree.tree, () => {
+      node.ref = Ref.make(task);
+    });
   });
 });