@dxos/plugin-explorer 0.8.4-main.406dc2a → 0.8.4-main.4668b7de9b

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

@@ -0,0 +1,97 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Type, View } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { useSpaces } from '@dxos/react-client/echo';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { ViewModel } from '@dxos/schema';
+import { type ValueGenerator, createObjectFactory, createRelationFactory } from '@dxos/schema/testing';
+import { HasRelationship, Organization, Person, Pipeline } from '@dxos/types';
+
+import { useGraphModel } from '#hooks';
+import { Graph } from '#types';
+
+import { CanvasForceGraph } from './CanvasForceGraph';
+
+const generator = random as any as ValueGenerator;
+
+random.seed(1);
+
+const DefaultStory = () => {
+  const [space] = useSpaces();
+  const model = useGraphModel(space?.db);
+  if (!space || !model) {
+    return <Loading data={{ space: !!space, model: !!model }} />;
+  }
+
+  return <CanvasForceGraph model={model} />;
+};
+
+const meta = {
+  title: 'plugins/plugin-explorer/components/CanvasForceGraph',
+  component: CanvasForceGraph,
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'fullscreen' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [
+            Graph.Graph,
+            View.View,
+            HasRelationship.HasRelationship,
+            Organization.Organization,
+            Pipeline.Pipeline,
+            Person.Person,
+          ],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+              yield* Effect.promise(() =>
+                createObjectFactory(
+                  personalSpace.db,
+                  generator,
+                )([
+                  { type: Organization.Organization, count: 20 },
+                  { type: Person.Person, count: 30 },
+                  { type: Pipeline.Pipeline, count: 10 },
+                ]),
+              );
+              yield* Effect.promise(() =>
+                createRelationFactory(
+                  personalSpace.db,
+                  generator,
+                )([{ type: HasRelationship.HasRelationship, count: 20, data: { kind: 'friend' } }]),
+              );
+              const { view } = yield* Effect.promise(() =>
+                ViewModel.makeFromDatabase({ db: personalSpace.db, typename: Type.getTypename(Graph.Graph) }),
+              );
+              personalSpace.db.add(Graph.make({ name: 'Test', view }));
+              yield* Effect.promise(() => personalSpace.db.flush({ indexes: true }));
+            }),
+        }),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof CanvasForceGraph>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/Graph/CanvasForceGraph.tsx

@@ -0,0 +1,124 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { forceLink, forceManyBody } from 'd3';
+import NativeForceGraph from 'force-graph';
+import React, {
+  type ComponentPropsWithoutRef,
+  type Ref,
+  RefObject,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+} from 'react';
+import { useResizeDetector } from 'react-resize-detector';
+
+import { composable, composableProps } from '@dxos/react-ui';
+import { type SpaceGraphModel } from '@dxos/schema';
+
+import { GraphAdapter } from './graph-adapter';
+
+export type CanvasForceGraphProps = {
+  model?: SpaceGraphModel;
+  match?: RegExp;
+};
+
+/**
+ * More performance optimized version of the ForceGraph.
+ */
+export const CanvasForceGraph = composable<HTMLDivElement, CanvasForceGraphProps>(
+  ({ model, match, onClick, ...props }, forwardedRef) => {
+    const { ref: resizeRef, width, height } = useResizeDetector({ refreshRate: 200 });
+    const setRef = useCallback(
+      (node: HTMLDivElement | null) => {
+        resizeRef(node);
+        assignRef(forwardedRef, node);
+      },
+      [resizeRef, forwardedRef],
+    );
+
+    const rootRef = useRef<HTMLDivElement>(null);
+    const forceGraph = useRef<NativeForceGraph>(null);
+
+    const [data, setData] = useState<GraphAdapter>();
+    useEffect(() => {
+      return model?.subscribe((model) => setData(new GraphAdapter(model.graph)));
+    }, [model]);
+
+    useEffect(() => {
+      if (rootRef.current) {
+        // https://github.com/vasturiano/force-graph
+        // https://github.com/vasturiano/3d-force-graph
+        forceGraph.current = new NativeForceGraph(rootRef.current)
+          // https://github.com/vasturiano/force-graph?tab=readme-ov-file#node-styling
+          .nodeRelSize(6)
+          .nodeLabel((node: any) => (node.type === 'schema' ? node.data.typename : (node.data.label ?? node.id)))
+          .nodeAutoColorBy((node: any) => (node.type === 'schema' ? 'schema' : node.data.typename))
+
+          // https://github.com/vasturiano/force-graph?tab=readme-ov-file#link-styling
+          .linkAutoColorBy((link: any) => link.type);
+      }
+
+      return () => {
+        forceGraph.current?.pauseAnimation().graphData({ nodes: [], links: [] });
+        forceGraph.current = null;
+      };
+    }, []);
+
+    useEffect(() => {
+      if (!data || !width || !height || !forceGraph.current) {
+        return;
+      }
+
+      // https://github.com/vasturiano/force-graph?tab=readme-ov-file#container-layout
+      forceGraph.current
+        .pauseAnimation()
+        .width(width)
+        .height(height)
+        .onEngineStop(() => handleZoomToFit())
+        .onNodeClick((node: any) => {
+          forceGraph.current?.emitParticle(node);
+        })
+
+        // https://github.com/vasturiano/force-graph?tab=readme-ov-file#force-engine-d3-force-configuration
+        // .d3Force('center', forceCenter().strength(0.9))
+        .d3Force('link', forceLink().distance(160).strength(0.5))
+        .d3Force('charge', forceManyBody().strength(-30))
+
+        .graphData(data)
+        .warmupTicks(100)
+        .cooldownTime(1_000)
+        .resumeAnimation();
+    }, [data, width, height]);
+
+    const handleZoomToFit = () => {
+      forceGraph.current?.zoomToFit(400, 40);
+    };
+
+    const handleClick = useCallback<NonNullable<ComponentPropsWithoutRef<'div'>['onClick']>>(
+      (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) {
+          handleZoomToFit();
+        }
+      },
+      [onClick],
+    );
+
+    return (
+      <div {...composableProps(props, { classNames: 'relative grow' })} onClick={handleClick} ref={setRef}>
+        <div ref={rootRef} className='absolute inset-0' />
+      </div>
+    );
+  },
+);
+
+const assignRef = <T,>(ref: Ref<T> | undefined, value: T | null): void => {
+  if (typeof ref === 'function') {
+    ref(value);
+  } else if (ref) {
+    (ref as RefObject<T | null>).current = value;
+  }
+};

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

@@ -3,65 +3,121 @@
 //
 
 import { type Meta, type StoryObj } from '@storybook/react-vite';
-import React, { useState } from 'react';
+import * as Effect from 'effect/Effect';
+import React, { useCallback, useMemo } from 'react';
 
-import { faker } 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 { useAsyncEffect } from '@dxos/react-ui';
-import { withTheme } from '@dxos/react-ui/testing';
-import { DataType } from '@dxos/schema';
-import { type ValueGenerator } from '@dxos/schema/testing';
-import { render } from '@dxos/storybook-utils';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Obj, Type, View } from '@dxos/echo';
+import { SelectionModel } from '@dxos/graph';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { useSpaces } from '@dxos/react-client/echo';
+import { DxAnchorActivate } from '@dxos/react-ui';
+import { type GraphProps } from '@dxos/react-ui-graph';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { type SpaceGraphEdge, type SpaceGraphNode, ViewModel } from '@dxos/schema';
+import { type ValueGenerator, createObjectFactory, createRelationFactory } from '@dxos/schema/testing';
+import { HasRelationship, Organization, Person, Pipeline } from '@dxos/types';
 
-import { useGraphModel } from '../../hooks';
-import { Graph } 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<DataType.View>();
+  const [space] = useSpaces();
+  const model = useGraphModel(space?.db);
 
-  useAsyncEffect(async () => {
-    const space = client.spaces.default;
-    void generate(space, generator);
-    const { view } = await Graph.makeView({ client, space, name: 'Test', typename: Graph.Graph.typename });
-    space.db.add(view);
-    setSpace(space);
-    setView(view);
-  }, []);
+  const selection = useMemo(() => new SelectionModel({ mode: 'single' }), []);
 
-  const model = useGraphModel(space);
-  if (!model || !space || !view) {
-    return null;
+  const handleInspect = useCallback<NonNullable<GraphProps<SpaceGraphNode, SpaceGraphEdge>['onInspect']>>(
+    (node, event) => {
+      // `null` node = pointerleave (no preview to open).
+      if (!node) {
+        return;
+      }
+      const obj = node.data?.data?.object;
+      if (!obj) {
+        return;
+      }
+      const uri = Obj.getURI(obj);
+      if (!uri) {
+        return;
+      }
+      const target = event.target as HTMLElement;
+      target.dispatchEvent(
+        new DxAnchorActivate({
+          dxn: uri,
+          label: Obj.getLabel(obj) ?? uri,
+          trigger: target,
+          kind: 'card',
+        }),
+      );
+    },
+    [],
+  );
+
+  if (!space || !model) {
+    return <Loading data={{ space: !!space, model: !!model }} />;
   }
 
-  return <ForceGraph model={model} />;
+  return <ForceGraph model={model} selection={selection} onInspect={handleInspect} />;
 };
 
 const meta = {
-  title: 'plugins/plugin-explorer/ForceGraph',
+  title: 'plugins/plugin-explorer/components/ForceGraph',
   component: ForceGraph,
-  render: render(DefaultStory),
+  render: DefaultStory,
   decorators: [
-    withTheme,
-    withClientProvider({
-      createSpace: true,
-      types: [
-        Graph.Graph,
-        DataType.View,
-        DataType.HasRelationship,
-        DataType.Organization,
-        DataType.Project,
-        DataType.Person,
+    withTheme(),
+    withLayout({ layout: 'fullscreen' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        ClientPlugin({
+          types: [
+            Graph.Graph,
+            View.View,
+            HasRelationship.HasRelationship,
+            Organization.Organization,
+            Pipeline.Pipeline,
+            Person.Person,
+          ],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+              yield* Effect.promise(() =>
+                createObjectFactory(
+                  personalSpace.db,
+                  generator,
+                )([
+                  { type: Organization.Organization, count: 20 },
+                  { type: Person.Person, count: 30 },
+                  { type: Pipeline.Pipeline, count: 10 },
+                ]),
+              );
+              yield* Effect.promise(() =>
+                createRelationFactory(
+                  personalSpace.db,
+                  generator,
+                )([{ type: HasRelationship.HasRelationship, count: 20, data: { kind: 'friend' } }]),
+              );
+              const { view } = yield* Effect.promise(() =>
+                ViewModel.makeFromDatabase({ db: personalSpace.db, typename: Type.getTypename(Graph.Graph) }),
+              );
+              personalSpace.db.add(Graph.make({ name: 'Test', view }));
+              yield* Effect.promise(() => personalSpace.db.flush({ indexes: true }));
+            }),
+        }),
+        PreviewPlugin(),
       ],
     }),
   ],

package/src/components/Graph/ForceGraph.tsx

@@ -2,91 +2,111 @@
 // Copyright 2023 DXOS.org
 //
 
-import { forceLink, forceManyBody } from 'd3';
-import NativeForceGraph from 'force-graph';
-import React, { type FC, useEffect, useRef, useState } from 'react';
-import { useResizeDetector } from 'react-resize-detector';
-
-import { type SearchResult, filterObjectsSync } from '@dxos/plugin-search';
-import { type SpaceGraphModel } from '@dxos/schema';
-
-import { GraphAdapter } from './adapter';
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { Obj } from '@dxos/echo';
+import { SelectionModel } from '@dxos/graph';
+import { composable, composableProps } from '@dxos/react-ui';
+import {
+  type GraphController,
+  GraphForceProjector,
+  type GraphLayoutNode,
+  type GraphProps,
+  SVG,
+  type SVGContext,
+} from '@dxos/react-ui-graph';
+import { type SpaceGraphEdge, type SpaceGraphModel, type SpaceGraphNode } from '@dxos/schema';
+import { getHashStyles } from '@dxos/ui-theme';
+import '@dxos/react-ui-graph/styles/graph.css';
+
+const EMPTY_ATOM = Atom.make<{ nodes: SpaceGraphNode[]; edges: SpaceGraphEdge[] }>({ nodes: [], edges: [] });
 
 export type ForceGraphProps = {
   model?: SpaceGraphModel;
-  match?: RegExp;
-};
-
-export const ForceGraph: FC<ForceGraphProps> = ({ model, match }) => {
-  const { ref, width, height } = useResizeDetector({ refreshRate: 200 });
-  const rootRef = useRef<HTMLDivElement>(null);
-  const forceGraph = useRef<NativeForceGraph>(null);
-
-  const filteredRef = useRef<SearchResult[]>([]);
-  filteredRef.current = filterObjectsSync(model?.objects ?? [], match);
-
-  const [data, setData] = useState<GraphAdapter>();
-  useEffect(() => {
-    return model?.subscribe((model) => {
-      setData(new GraphAdapter(model.graph));
-    });
-  }, [model]);
-
-  useEffect(() => {
-    if (rootRef.current) {
-      // https://github.com/vasturiano/force-graph
-      // https://github.com/vasturiano/3d-force-graph
-      forceGraph.current = new NativeForceGraph(rootRef.current)
-        // https://github.com/vasturiano/force-graph?tab=readme-ov-file#node-styling
-        .nodeRelSize(6)
-        .nodeLabel((node: any) => (node.type === 'schema' ? node.data.typename : (node.data.label ?? node.id)))
-        .nodeAutoColorBy((node: any) => (node.type === 'schema' ? 'schema' : node.data.typename))
-
-        // https://github.com/vasturiano/force-graph?tab=readme-ov-file#link-styling
-        .linkAutoColorBy((link: any) => link.type);
-    }
-
-    return () => {
-      forceGraph.current?.pauseAnimation().graphData({ nodes: [], links: [] });
-      forceGraph.current = null;
-    };
-  }, []);
-
-  useEffect(() => {
-    if (!data || !width || !height || !forceGraph.current) {
-      return;
-    }
-
-    // https://github.com/vasturiano/force-graph?tab=readme-ov-file#container-layout
-    forceGraph.current
-      .pauseAnimation()
-      .width(width)
-      .height(height)
-      .onEngineStop(() => {
-        handleZoomToFit();
-      })
-      .onNodeClick((node: any) => {
-        forceGraph.current?.emitParticle(node);
-      })
-
-      // https://github.com/vasturiano/force-graph?tab=readme-ov-file#force-engine-d3-force-configuration
-      // .d3Force('center', forceCenter().strength(0.9))
-      .d3Force('link', forceLink().distance(160).strength(0.5))
-      .d3Force('charge', forceManyBody().strength(-30))
-
-      .graphData(data)
-      .warmupTicks(100)
-      .cooldownTime(1_000)
-      .resumeAnimation();
-  }, [data, width, height, forceGraph.current]);
-
-  const handleZoomToFit = () => {
-    forceGraph.current?.zoomToFit(400, 40);
-  };
-
-  return (
-    <div ref={ref} className='relative grow' onClick={handleZoomToFit}>
-      <div ref={rootRef} className='absolute inset-0' />
-    </div>
-  );
-};
+  grid?: boolean;
+  selection?: SelectionModel;
+  onInspect?: GraphProps<SpaceGraphNode, SpaceGraphEdge>['onInspect'];
+} & Pick<GraphProps, 'drag'>;
+
+export const ForceGraph = composable<HTMLDivElement, ForceGraphProps>(
+  ({ model, selection: selectionProp, grid, drag, onInspect, ...props }, forwardedRef) => {
+    // TODO(wittjosiah): This should go into Graph.tsx but for some reason doesn't work.
+    useAtomValue(model?.graphAtom ?? EMPTY_ATOM);
+
+    const graph = useRef<GraphController>(null);
+    const selection = useMemo(() => selectionProp ?? new SelectionModel(), [selectionProp]);
+    useEffect(() => {
+      const unsubscribe = selection.subscribe(() => graph.current?.repaint());
+      return unsubscribe;
+    }, [selection]);
+
+    const svgRef = useRef<SVGContext>(null);
+    const [projector, setProjector] = useState<GraphForceProjector>();
+    useEffect(() => {
+      if (svgRef.current) {
+        setProjector(
+          new GraphForceProjector(svgRef.current, {
+            attributes: {
+              // TODO(burdon): Check type (currently assumes Employee property).
+              // Edge shouldn't contribute to force if it's not active.
+              linkForce: (edge) => edge.data?.object?.active !== false,
+            },
+            forces: {
+              point: {
+                strength: 0.01,
+              },
+            },
+          }),
+        );
+      }
+      // SVG.Graph owns projector start/stop; nothing to clean up here.
+    }, []);
+
+    const handleSelect = useCallback<NonNullable<GraphProps['onSelect']>>(
+      (node) => {
+        if (selection.contains(node.id)) {
+          selection.remove(node.id);
+        } else {
+          selection.add(node.id);
+        }
+      },
+      [selection],
+    );
+
+    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>
+              ref={graph}
+              drag={drag}
+              model={model}
+              projector={projector}
+              labels={{
+                text: (node) => node.data?.data.label ?? 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}
+              onInspect={onInspect}
+            />
+          </SVG.Zoom>
+        </SVG.Root>
+      </div>
+    );
+  },
+);

package/src/components/Graph/{adapter.ts → 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/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './D3ForceGraph';
+export * from './CanvasForceGraph';
 export * from './ForceGraph';