@dxos/app-graph 0.10.0 → 0.11.1

package/src/graph.ts

@@ -2,11 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Atom, Registry } from '@effect-atom/atom-react';
+import { Atom, Registry } from '@effect-atom/atom';
 import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
 import * as Pipeable from 'effect/Pipeable';
-import * as Record from 'effect/Record';
 
 import { Event, Trigger } from '@dxos/async';
 import { todo } from '@dxos/debug';
@@ -144,11 +143,11 @@ class GraphImpl implements WritableGraph {
   readonly _onRemoveNode?: GraphProps['onRemoveNode'];
 
   readonly _registry: Registry.Registry;
-  readonly _expanded = Record.empty<string, boolean>();
+  readonly _expanded = new Set<string>();
   readonly _pendingExpands = new Set<string>();
-  readonly _initialized = Record.empty<string, boolean>();
-  readonly _initialEdges = Record.empty<string, Edges>();
-  readonly _initialNodes = Record.fromEntries([
+  readonly _initialized = new Set<string>();
+  readonly _initialEdges = new Map<string, Edges>();
+  readonly _initialNodes = new Map<string, Option.Option<Node.Node>>([
     [
       Node.RootId,
       this._constructNode({
@@ -162,7 +161,7 @@ class GraphImpl implements WritableGraph {
 
   /** @internal */
   readonly _node = Atom.family<string, Atom.Writable<Option.Option<Node.Node>>>((id) => {
-    const initial = Option.flatten(Record.get(this._initialNodes, id));
+    const initial = this._initialNodes.get(id) ?? Option.none();
     return Atom.make<Option.Option<Node.Node>>(initial).pipe(Atom.keepAlive, Atom.withLabel(`graph:node:${id}`));
   });
 
@@ -175,7 +174,7 @@ class GraphImpl implements WritableGraph {
   });
 
   readonly _edges = Atom.family<string, Atom.Writable<Edges>>((id) => {
-    const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({}) as Edges));
+    const initial = this._initialEdges.get(id) ?? ({} as Edges);
     return Atom.make<Edges>(initial).pipe(Atom.keepAlive, Atom.withLabel(`graph:edges:${id}`));
   });
 
@@ -243,13 +242,13 @@ class GraphImpl implements WritableGraph {
 
     if (nodes) {
       nodes.forEach((node) => {
-        Record.set(this._initialNodes, node.id, this._constructNode(node));
+        this._initialNodes.set(node.id, this._constructNode(node));
       });
     }
 
     if (edges) {
       Object.entries(edges).forEach(([source, edges]) => {
-        Record.set(this._initialEdges, source, edges);
+        this._initialEdges.set(source, edges);
       });
     }
   }
@@ -667,10 +666,10 @@ export function waitForPath(
  */
 const initializeImpl = async <T extends ExpandableGraph | WritableGraph>(graph: T, id: string): Promise<T> => {
   const internal = getInternal(graph);
-  const initialized = Record.get(internal._initialized, id).pipe(Option.getOrElse(() => false));
+  const initialized = internal._initialized.has(id);
   log('initialize', { id, initialized });
   if (!initialized) {
-    Record.set(internal._initialized, id, true);
+    internal._initialized.add(id);
     await internal._onInitialize?.(id);
   }
   return graph;
@@ -680,6 +679,9 @@ const initializeImpl = async <T extends ExpandableGraph | WritableGraph>(graph:
  * Initialize a node in the graph.
  *
  * Fires the `onInitialize` callback to provide initial data for a node.
+ *
+ * TODO(wittjosiah): Remove? No graph-builder extension declares a `resolver`, so `onInitialize` has
+ * nothing to run; callers expand the nodes they need explicitly.
  */
 export function initialize<T extends ExpandableGraph | WritableGraph>(graph: T, id: string): Promise<T>;
 export function initialize(id: string): <T extends ExpandableGraph | WritableGraph>(graph: T) => Promise<T>;
@@ -718,10 +720,10 @@ const expandImpl = <T extends ExpandableGraph | WritableGraph>(
     return graph;
   }
 
-  const expanded = Record.get(internal._expanded, key).pipe(Option.getOrElse(() => false));
+  const expanded = internal._expanded.has(key);
   log('expand', { key, expanded });
   if (!expanded) {
-    Record.set(internal._expanded, key, true);
+    internal._expanded.add(key);
     internal._onExpand?.(id, normalizedRelation);
   }
   return graph;
@@ -878,13 +880,17 @@ const addNodeImpl = <T extends WritableGraph>(graph: T, nodeArg: Node.NodeArg<an
       const typeChanged = existing.type !== type;
       const dataChanged = !shallowEqual(existing.data, data);
       const propertiesChanged = Object.keys(properties).some((key) => existing.properties[key] !== properties[key]);
+      // `changed` is on the visit log because counting `existing node` lines alone measures how often a
+      // node was re-offered, not how often it actually changed — two very different costs.
+      const changed = typeChanged || dataChanged || propertiesChanged;
       log('existing node', {
         id,
+        changed,
         typeChanged,
         dataChanged,
         propertiesChanged,
       });
-      if (typeChanged || dataChanged || propertiesChanged) {
+      if (changed) {
         log('updating node', { id, type, data, properties });
         const newNode = Option.some({
           ...existing,
@@ -908,7 +914,7 @@ const addNodeImpl = <T extends WritableGraph>(graph: T, nodeArg: Node.NodeArg<an
       for (const pendingKey of toApply) {
         internal._pendingExpands.delete(pendingKey);
         const relation = relationFromKey(primaryParts(pendingKey)[1]);
-        Record.set(internal._expanded, pendingKey, true);
+        internal._expanded.add(pendingKey);
         internal._onExpand?.(id, relation);
       }
     },

package/src/index.ts

@@ -8,6 +8,7 @@ export * as Graph from './graph';
 export * as GraphBuilder from './graph-builder';
 export * as Node from './node';
 export * as NodeMatcher from './node-matcher';
+export * as PathResolution from './path-resolution';
 export { getParentId, getSegmentId, qualifyId } from './util';
 
 // TODO(wittjosiah): Direct re-export needed for portable type references.

package/src/node-matcher.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom, Registry } from '@effect-atom/atom-react';
+import { Atom, Registry } from '@effect-atom/atom';
 import * as Option from 'effect/Option';
 import { describe, expect, test } from 'vitest';
 

package/src/node-matcher.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom-react';
+import { Atom } from '@effect-atom/atom';
 import * as Option from 'effect/Option';
 
 import { Entity, Obj, type Type } from '@dxos/echo';

package/src/node.ts

@@ -95,8 +95,9 @@ export type NodeArg<TData, TProperties extends Record<string, any> = Record<stri
   /** Will automatically add nodes with an edge from this node to each. */
   nodes?: NodeArg<unknown>[];
 
-  /** Will automatically add actions with an edge from this node to each. */
-  actions?: NodeArg<ActionData<any>>[];
+  /** Will automatically add actions with an edge from this node to each. An action child may itself
+   * be an action group (e.g. a toolbar dropdown group), so groups are accepted alongside actions. */
+  actions?: NodeArg<ActionData<any> | typeof actionGroupSymbol>[];
 
   /** Will automatically add specified edges. */
   edges?: [string, RelationInput][];
@@ -114,6 +115,9 @@ export type InvokeProps = {
   path?: string[];
 
   caller?: string;
+
+  /** Input modifiers held during the gesture that triggered the action (e.g. shift-clicking a menu item). */
+  modifiers?: { shift?: boolean };
 };
 
 /**
@@ -154,6 +158,19 @@ export type ActionLike = Action | ActionGroup;
 
 export const isActionLike = (data: unknown): data is Action | ActionGroup => isAction(data) || isActionGroup(data);
 
+/**
+ * Tests whether a node's `disposition` property (a single string or an array, letting one node opt
+ * into multiple surfaces at once) includes any of `key`. Every surface that routes nodes/actions by
+ * disposition (toolbar, nav-tree list-item, sigil menu, …) should filter through this rather than
+ * comparing `properties.disposition` directly, so a node can multi-target surfaces.
+ */
+export const hasDisposition = (node: Pick<Node, 'properties'>, key: string | string[]): boolean => {
+  const disposition = node.properties.disposition;
+  const dispositions = Array.isArray(disposition) ? disposition : disposition !== undefined ? [disposition] : [];
+  const keys = Array.isArray(key) ? key : [key];
+  return dispositions.some((candidate) => keys.includes(candidate));
+};
+
 //
 // Node Factories
 //