@dxos/app-graph 0.8.4-main.69d29f4 → 0.8.4-main.6fa680abb7

package/src/stories/EchoGraph.stories.tsx

@@ -17,9 +17,9 @@ import { type Client, useClient } from '@dxos/react-client';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { Icon, IconButton, Input, Select } from '@dxos/react-ui';
 import { withTheme } from '@dxos/react-ui/testing';
-import { Path, Tree } from '@dxos/react-ui-list';
+import { Path, Tree, type TreeModel } from '@dxos/react-ui-list';
 import { getSize, mx } from '@dxos/ui-theme';
-import { byPosition, isNonNullable, safeParseInt } from '@dxos/util';
+import { safeParseInt } from '@dxos/util';
 
 import * as CreateAtom from '../atoms';
 import * as Graph from '../graph';
@@ -64,7 +64,7 @@ const createGraph = (client: Client, registry: Registry.Registry): Graph.Expanda
                 const propertiesSnapshot = get(AtomObj.make(space.properties));
                 return {
                   id: space.id,
-                  type: 'dxos.org/type/Space',
+                  type: 'org.dxos.type.space',
                   properties: {
                     label: propertiesSnapshot.name,
                   },
@@ -88,7 +88,7 @@ const createGraph = (client: Client, registry: Registry.Registry): Graph.Expanda
             const objects = get(AtomQuery.make(space.db, Query.type(TestSchema.Expando, { type: 'test' })));
             return objects.map((object) => ({
               id: object.id,
-              type: 'dxos.org/type/test',
+              type: 'org.dxos.type.test',
               properties: { label: object.name },
               data: object,
             }));
@@ -104,9 +104,9 @@ const createGraph = (client: Client, registry: Registry.Registry): Graph.Expanda
   GraphBuilder.addExtension(builder, objectBuilderExtension);
   const graph = builder.graph;
   graph.onNodeChanged.on(({ id }) => {
-    Graph.expand(graph, id);
+    Graph.expand(graph, id, 'child');
   });
-  Graph.expand(graph, Node.RootId);
+  Graph.expand(graph, Node.RootId, 'child');
   (window as any).graph = graph;
   return graph;
 };
@@ -217,13 +217,13 @@ const Controls = ({ children }: PropsWithChildren) => {
             <Input.TextInput
               autoComplete='off'
               size={5}
-              classNames='is-[100px] text-right pie-[22px]'
+              classNames='w-[100px] text-right pe-[22px]'
               placeholder='Interval'
               value={actionInterval}
               onChange={({ target: { value } }) => setActionInterval(value)}
             />
           </Input.Root>
-          <Icon icon='ph--timer--regular' classNames={mx('absolute inline-end-1 block-start-1 mt-[6px]', getSize(3))} />
+          <Icon icon='ph--timer--regular' classNames={mx('absolute right-1 top-1 mt-[6px]', getSize(3))} />
         </div>
         <IconButton icon='ph--plus--regular' label='Add' onClick={() => action && runAction(client, action)} />
         <Select.Root value={action?.toString()} onValueChange={(action) => setAction(action as unknown as Action)}>
@@ -252,9 +252,10 @@ const Controls = ({ children }: PropsWithChildren) => {
 const meta = {
   title: 'sdk/app-graph/EchoGraph',
   decorators: [
-    withTheme,
+    withTheme(),
     withClientProvider({
       createIdentity: true,
+      types: [TestSchema.Expando],
       onCreateIdentity: async ({ client }) => {
         await client.spaces.create();
         await client.spaces.create();
@@ -291,60 +292,97 @@ export const TreeView: Story = {
     const stateRef = useRef(new Map<string, Atom.Writable<{ open: boolean; current: boolean }>>());
 
     const getOrCreateState = useMemo(
-      () => (path: string) => {
-        let atom = stateRef.current.get(path);
+      () => (pathKey: string) => {
+        let atom = stateRef.current.get(pathKey);
         if (!atom) {
           atom = Atom.make({ open: true, current: false }).pipe(Atom.keepAlive);
-          stateRef.current.set(path, atom);
+          stateRef.current.set(pathKey, atom);
         }
         return atom;
       },
       [],
     );
 
-    const useItems = useCallback(
-      (node?: Node.Node, options?: { disposition?: string; sort?: boolean }) => {
-        const connections = useAtomValue(graph.connections(node?.id ?? Node.RootId));
-        return options?.sort ? connections.toSorted((a, b) => byPosition(a.properties, b.properties)) : connections;
-      },
+    const childIdsFamily = useMemo(
+      () =>
+        Atom.family((id: string) =>
+          Atom.make((get) => {
+            const connections = get(graph.connections(id, 'child'));
+            return connections.map((connection) => connection.id);
+          }),
+        ),
       [graph],
     );
 
-    const getProps = useCallback(
-      (node: Node.Node, path: string[]) => {
-        const children = Graph.getConnections(graph, node.id, 'outbound')
-          .map((n) => {
-            // Break cycles.
-            const nextPath = [...path, node.id];
-            return nextPath.includes(n.id) ? undefined : (n as Node.Node);
-          })
-          .filter(isNonNullable) as Node.Node[];
-        const parentOf =
-          children.length > 0 ? children.map(({ id }) => id) : node.properties.role === 'branch' ? [] : undefined;
-        return {
-          id: node.id,
-          label: node.id,
-          icon: node.type === 'dxos.org/type/Space' ? 'ph--planet--regular' : 'ph--placeholder--regular',
-          parentOf,
-        };
-      },
+    const itemFamily = useMemo(
+      () =>
+        Atom.family((id: string) =>
+          Atom.make((get) => {
+            const node = get(graph.node(id));
+            return Option.isSome(node) ? node.value : undefined;
+          }),
+        ),
+      [graph],
+    );
+
+    const itemPropsFamily = useMemo(
+      () =>
+        Atom.family((pathKey: string) => {
+          const path = pathKey.split('~');
+          const id = path[path.length - 1];
+          return Atom.make((get) => {
+            const nodeOpt = get(graph.node(id));
+            const node = Option.isSome(nodeOpt) ? nodeOpt.value : undefined;
+            if (!node) {
+              return { id, label: id };
+            }
+            const connections = get(graph.connections(node.id, 'child'));
+            const safeChildren = connections.filter((n) => !path.includes(n.id));
+            const parentOf =
+              safeChildren.length > 0
+                ? safeChildren.map(({ id }) => id)
+                : node.properties.role === 'branch'
+                  ? []
+                  : undefined;
+            return {
+              id: node.id,
+              label: node.id,
+              icon: node.type === 'org.dxos.type.space' ? 'ph--planet--regular' : 'ph--placeholder--regular',
+              parentOf,
+            };
+          });
+        }),
       [graph],
     );
 
-    // Hook that subscribes to item state via Atom.
-    const useItemState = (_path: string[]) => {
-      const path = useMemo(() => Path.create(..._path), [_path.join('~')]);
-      const atom = getOrCreateState(path);
-      return useAtomValue(atom);
-    };
+    const itemOpenFamily = useMemo(
+      () =>
+        Atom.family((pathKey: string) => {
+          const stateAtom = getOrCreateState(pathKey);
+          return Atom.make((get) => get(stateAtom).open);
+        }),
+      [getOrCreateState],
+    );
 
-    const useIsOpen = (_path: string[]) => {
-      return useItemState(_path).open;
-    };
+    const itemCurrentFamily = useMemo(
+      () =>
+        Atom.family((pathKey: string) => {
+          const stateAtom = getOrCreateState(pathKey);
+          return Atom.make((get) => get(stateAtom).current);
+        }),
+      [getOrCreateState],
+    );
 
-    const useIsCurrent = (_path: string[]) => {
-      return useItemState(_path).current;
-    };
+    const model: TreeModel<Node.Node> = useMemo(
+      () => ({
+        childIds: (parentId?: string) => childIdsFamily(parentId ?? Node.RootId),
+        item: (id: string) => itemFamily(id),
+        itemProps: (path: string[]) => itemPropsFamily(path.join('~')),
+        itemOpen: (path: string[]) => itemOpenFamily(Path.create(...path)),
+        itemCurrent: (path: string[]) => itemCurrentFamily(Path.create(...path)),
+      }),
+      [childIdsFamily, itemFamily, itemPropsFamily, itemOpenFamily, itemCurrentFamily],
+    );
 
     const onOpenChange = useCallback(
       ({ path: _path, open }: { path: string[]; open: boolean }) => {
@@ -373,15 +411,7 @@ export const TreeView: Story = {
     return (
       <>
         <Controls />
-        <Tree
-          id={Node.RootId}
-          useItems={useItems}
-          getProps={getProps}
-          useIsOpen={useIsOpen}
-          useIsCurrent={useIsCurrent}
-          onOpenChange={onOpenChange}
-          onSelect={onSelect}
-        />
+        <Tree model={model} id={Node.RootId} onOpenChange={onOpenChange} onSelect={onSelect} />
       </>
     );
   },

package/src/stories/Tree.tsx

@@ -72,7 +72,7 @@ const Scalar: FC<{ value: any }> = ({ value }) => {
 
 const Box: FC<HTMLAttributes<HTMLDivElement>> = ({ children, className, ...props }) => {
   return (
-    <div className={mx('flex pli-2 border border-l-0 font-mono truncate', className)} {...props}>
+    <div className={mx('flex px-2 border border-l-0 font-mono truncate', className)} {...props}>
       {children}
     </div>
   );

package/src/util.ts

@@ -0,0 +1,71 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+
+import * as Node from './node';
+
+/**
+ * Key separators for compound string keys used across the app-graph package.
+ * `primary` separates top-level components (e.g., node ID from relation).
+ * `secondary` separates sub-components within an encoded value (e.g., relation kind from direction).
+ * `path` separates segments in qualified node IDs (e.g., parent path from local segment).
+ * Two distinct characters are needed because secondary separators appear inside primary-separated fields.
+ */
+export const Separators = {
+  primary: '\u0001',
+  secondary: '\u0002',
+  path: '/',
+} as const;
+
+/**
+ * Normalize a relation input to a full Relation object.
+ */
+export const normalizeRelation = (relation?: Node.RelationInput): Node.Relation =>
+  relation == null ? Node.childRelation() : typeof relation === 'string' ? Node.relation(relation) : relation;
+
+/**
+ * Shallow-compare two values: same reference, or same own-keys with === values.
+ */
+export const shallowEqual = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true;
+  if (a == null || b == null || typeof a !== 'object' || typeof b !== 'object') return false;
+  const keysA = Object.keys(a as Record<string, unknown>);
+  const keysB = Object.keys(b as Record<string, unknown>);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  return keysA.every((k) => (a as Record<string, unknown>)[k] === (b as Record<string, unknown>)[k]);
+};
+
+/**
+ * Returns true if two NodeArg arrays are semantically identical (same id, type, data, properties per index).
+ */
+export const nodeArgsUnchanged = (prev: Node.NodeArg<any>[], next: Node.NodeArg<any>[]): boolean => {
+  if (prev.length !== next.length) {
+    return false;
+  }
+
+  return prev.every((prevNode, idx) => {
+    const nextNode = next[idx];
+    return (
+      prevNode.id === nextNode.id &&
+      prevNode.type === nextNode.type &&
+      shallowEqual(prevNode.data, nextNode.data) &&
+      shallowEqual(prevNode.properties, nextNode.properties)
+    );
+  });
+};
+
+/**
+ * Build a qualified node ID by joining a parent path with a local segment.
+ */
+export const qualifyId = (parentId: string, segmentId: string): string => `${parentId}${Separators.path}${segmentId}`;
+
+/**
+ * Validate that a segment ID does not contain the path separator.
+ */
+export const validateSegmentId = (id: string): void => {
+  invariant(!id.includes(Separators.path), `Node segment ID must not contain '${Separators.path}': ${id}`);
+};