@dxos/app-graph 0.4.7-main.e015b9e → 0.4.7-main.ea67fec

package/dist/lib/browser/index.mjs

@@ -1,292 +1,352 @@
 // packages/sdk/app-graph/src/graph.ts
+import { untracked } from "@preact/signals-core";
 import { deepSignal } from "deepsignal/react";
-import get from "lodash.get";
 import { invariant } from "@dxos/invariant";
+import { nonNullable } from "@dxos/util";
+
+// packages/sdk/app-graph/src/node.ts
+var isGraphNode = (data) => data && typeof data === "object" && "id" in data && "properties" in data && data.properties ? typeof data.properties === "object" && "data" in data : false;
+var isAction = (data) => isGraphNode(data) ? typeof data.data === "function" : false;
+var actionGroupSymbol = Symbol("ActionGroup");
+var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol : false;
+var isActionLike = (data) => isAction(data) || isActionGroup(data);
+
+// packages/sdk/app-graph/src/graph.ts
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/app-graph/src/graph.ts";
+var ROOT_ID = "root";
 var Graph = class {
-  constructor(_root) {
-    this._root = _root;
-    this._index = deepSignal({});
-  }
-  toJSON() {
-    const toLabel = (label) => Array.isArray(label) ? `${label[1].ns}[${label[0]}]` : label;
-    const toJSON = (node) => {
-      return {
-        id: node.id.slice(0, 16),
-        label: toLabel(node.label),
-        children: node.children.length ? node.children.map((node2) => toJSON(node2)) : void 0,
-        actions: node.actions.length ? node.actions.map(({ id, label }) => ({
-          id,
-          label: toLabel(label)
-        })) : void 0
+  constructor() {
+    /**
+    * @internal
+    */
+    this._nodes = deepSignal({
+      [ROOT_ID]: {
+        id: ROOT_ID,
+        properties: {},
+        data: null
+      }
+    });
+    /**
+    * @internal
+    */
+    // Key is the `${node.id}-${direction}` and value is an ordered list of node ids.
+    // Explicit type required because TS says this is not portable.
+    this._edges = deepSignal({});
+    this._constructNode = (nodeBase) => {
+      const node = {
+        ...nodeBase,
+        edges: ({ direction = "outbound" } = {}) => {
+          return this._edges[this.getEdgeKey(node.id, direction)];
+        },
+        nodes: ({ direction, filter } = {}) => {
+          const nodes = this._getNodes({
+            id: node.id,
+            direction
+          }).filter((n) => !isActionLike(n));
+          return filter ? nodes.filter((n) => filter(n, node)) : nodes;
+        },
+        node: (id) => {
+          return this._getNodes({
+            id
+          }).find((node2) => node2.id === id);
+        },
+        actions: () => {
+          return this._getNodes({
+            id: node.id
+          }).filter(isActionLike);
+        }
       };
+      return node;
     };
-    return toJSON(this._root);
   }
   /**
-  * The root node of the graph which is the entry point for all knowledge.
+  * Alias for `findNode('root')`.
   */
   get root() {
-    return this._root;
+    return this.findNode(ROOT_ID);
   }
   /**
-  * Get the path through the graph from the root to the node with the given id.
+  * Convert the graph to a JSON object.
   */
-  getPath(id) {
-    return this._index[id];
-  }
-  /**
-  * @internal
-  */
-  _setPath(id, path) {
-    invariant(id && path, "Invalid path.", {
+  toJSON({ id = ROOT_ID, maxLength = 32 } = {}) {
+    const toJSON = (node) => {
+      const nodes = node.nodes();
+      const obj = {
+        id: node.id.length > maxLength ? `${node.id.slice(0, maxLength - 3)}...` : node.id
+      };
+      if (node.properties.label) {
+        obj.label = node.properties.label;
+      }
+      if (nodes.length) {
+        obj.nodes = nodes.map((node2) => toJSON(node2));
+      }
+      return obj;
+    };
+    const root = this.findNode(id);
+    invariant(root, `Node not found: ${id}`, {
       F: __dxlog_file,
-      L: 82,
+      L: 85,
       S: this,
       A: [
-        "id && path",
-        "'Invalid path.'"
+        "root",
+        "`Node not found: ${id}`"
       ]
     });
-    this._index[id] = path;
+    return toJSON(root);
   }
   /**
   * Find the node with the given id in the graph.
   */
   findNode(id) {
-    const path = this.getPath(id);
-    if (!path) {
+    const nodeBase = this._nodes[id];
+    if (!nodeBase) {
       return void 0;
     }
-    return path.length > 0 ? get(this._root, path) : this._root;
+    return this._constructNode(nodeBase);
+  }
+  _getNodes({ id, direction = "outbound" }) {
+    const edges = this._edges[this.getEdgeKey(id, direction)];
+    if (!edges) {
+      return [];
+    }
+    return edges.map((id2) => this.findNode(id2)).filter(nonNullable);
+  }
+  getEdgeKey(id, direction) {
+    return `${id}-${direction}`;
+  }
+  /**
+  * Add nodes to the graph.
+  */
+  addNodes(...nodes) {
+    return nodes.map((node) => this._addNode(node));
+  }
+  _addNode({ nodes, edges, ..._node }) {
+    return untracked(() => {
+      const node = {
+        data: null,
+        properties: {},
+        ..._node
+      };
+      this._nodes[node.id] = node;
+      if (nodes) {
+        nodes.forEach((subNode) => {
+          this._addNode(subNode);
+          this.addEdge({
+            source: node.id,
+            target: subNode.id
+          });
+        });
+      }
+      if (edges) {
+        edges.forEach(([id, direction]) => direction === "outbound" ? this.addEdge({
+          source: node.id,
+          target: id
+        }) : this.addEdge({
+          source: id,
+          target: node.id
+        }));
+      }
+      return this._constructNode(node);
+    });
+  }
+  /**
+  * Remove nodes from the graph.
+  *
+  * @param id The id of the node to remove.
+  * @param edges Whether to remove edges connected to the node from the graph as well.
+  */
+  removeNode(id, edges = false) {
+    untracked(() => {
+      const node = this.findNode(id);
+      if (!node) {
+        return;
+      }
+      if (edges) {
+        delete this._edges[this.getEdgeKey(id, "outbound")];
+        delete this._edges[this.getEdgeKey(id, "inbound")];
+        this._getNodes({
+          id
+        }).forEach((node2) => this.removeEdge({
+          source: id,
+          target: node2.id
+        }));
+        this._getNodes({
+          id,
+          direction: "inbound"
+        }).forEach((node2) => this.removeEdge({
+          source: node2.id,
+          target: id
+        }));
+      }
+      delete this._nodes[id];
+    });
+  }
+  /**
+  * Add an edge to the graph.
+  */
+  addEdge({ source, target }) {
+    untracked(() => {
+      const outbound = this._edges[this.getEdgeKey(source, "outbound")];
+      if (!outbound) {
+        this._edges[this.getEdgeKey(source, "outbound")] = [
+          target
+        ];
+      } else if (!outbound.includes(target)) {
+        outbound.push(target);
+      }
+      const inbound = this._edges[this.getEdgeKey(target, "inbound")];
+      if (!inbound) {
+        this._edges[this.getEdgeKey(target, "inbound")] = [
+          source
+        ];
+      } else if (!inbound.includes(source)) {
+        inbound.push(source);
+      }
+    });
   }
   /**
-  * Recursive breadth-first traversal.
+  * Sort edges for a node.
+  *
+  * Edges not included in the sorted list are appended to the end of the list.
+  *
+  * @param nodeId The id of the node to sort edges for.
+  * @param direction The direction of the edges from the node to sort.
+  * @param edges The ordered list of edges.
   */
-  traverse({ node = this._root, direction = "down", filter, visitor }, depth = 0) {
+  sortEdges(nodeId, direction, edges) {
+    untracked(() => {
+      const current = this._edges[this.getEdgeKey(nodeId, direction)];
+      if (current) {
+        const unsorted = current.filter((id) => !edges.includes(id)) ?? [];
+        const sorted = edges.filter((id) => current.includes(id)) ?? [];
+        current.splice(0, current.length, ...[
+          ...sorted,
+          ...unsorted
+        ]);
+      }
+    });
+  }
+  /**
+  * Remove an edge from the graph.
+  */
+  removeEdge({ source, target }) {
+    untracked(() => {
+      const outboundIndex = this._edges[this.getEdgeKey(source, "outbound")]?.findIndex((id) => id === target);
+      if (outboundIndex !== -1) {
+        this._edges[this.getEdgeKey(source, "outbound")].splice(outboundIndex, 1);
+      }
+      const inboundIndex = this._edges[this.getEdgeKey(target, "inbound")]?.findIndex((id) => id === source);
+      if (inboundIndex !== -1) {
+        this._edges[this.getEdgeKey(target, "inbound")].splice(inboundIndex, 1);
+      }
+    });
+  }
+  /**
+  * Recursive depth-first traversal.
+  *
+  * @param options.node The node to start traversing from.
+  * @param options.direction The direction to traverse graph edges.
+  * @param options.filter A predicate to filter nodes which are passed to the `visitor` callback.
+  * @param options.visitor A callback which is called for each node visited during traversal.
+  */
+  traverse({ node = this.root, direction = "outbound", filter, visitor }, path = []) {
+    if (path.includes(node.id)) {
+      return;
+    }
     if (!filter || filter(node)) {
-      visitor?.(node, this.getPath(node.id));
+      visitor?.(node, [
+        ...path,
+        node.id
+      ]);
     }
-    if (direction === "down") {
-      Object.values(node.children).forEach((child) => this.traverse({
-        node: child,
-        filter,
-        visitor
-      }));
-    } else if (direction === "up" && node.parent) {
-      this.traverse({
-        node: node.parent,
-        direction,
-        filter,
-        visitor
-      }, depth + 1);
+    Object.values(this._getNodes({
+      id: node.id,
+      direction
+    })).forEach((child) => this.traverse({
+      node: child,
+      direction,
+      filter,
+      visitor
+    }, [
+      ...path,
+      node.id
+    ]));
+  }
+  /**
+  * Get the path between two nodes in the graph.
+  */
+  getPath({ source = "root", target }) {
+    const start = this.findNode(source);
+    if (!start) {
+      return void 0;
     }
+    let found;
+    this.traverse({
+      node: start,
+      filter: () => !found,
+      visitor: (node, path) => {
+        if (node.id === target) {
+          found = path;
+        }
+      }
+    });
+    return found;
   }
 };
 
 // packages/sdk/app-graph/src/graph-builder.ts
-import { untracked } from "@preact/signals-core";
-import { deepSignal as deepSignal2 } from "deepsignal/react";
 import { EventSubscriptions } from "@dxos/async";
-import { Keyboard } from "@dxos/keyboard";
-import { getHostPlatform } from "@dxos/util";
-var KEY_BINDING = "KeyBinding";
 var GraphBuilder = class {
   constructor() {
-    this._nodeBuilders = /* @__PURE__ */ new Map();
-    this._unsubscribe = /* @__PURE__ */ new Map();
+    this._extensions = /* @__PURE__ */ new Map();
+    this._unsubscribe = new EventSubscriptions();
   }
   /**
   * Register a node builder which will be called in order to construct the graph.
   */
-  addNodeBuilder(id, builder) {
-    this._nodeBuilders.set(id, builder);
+  addExtension(id, extension) {
+    this._extensions.set(id, extension);
     return this;
   }
   /**
   * Remove a node builder from the graph builder.
   */
-  removeNodeBuilder(id) {
-    this._nodeBuilders.delete(id);
+  removeExtension(id) {
+    this._extensions.delete(id);
     return this;
   }
   /**
-  * Construct the graph, starting by calling all registered node builders on the root node.
-  * Node builders will be filtered out as they are used such that they are only used once on any given path.
+  * Construct the graph, starting by calling all registered extensions.
   * @param previousGraph If provided, the graph will be updated in place.
-  * @param startingPath If provided, the graph will be updated starting at the given path.
-  */
-  build(previousGraph, startingPath = []) {
-    const graph = previousGraph ?? new Graph(this._createNode(() => graph, {
-      id: "root",
-      label: "Root"
-    }));
-    return this._build(graph, graph.root, startingPath);
-  }
-  /**
-  * Called recursively.
   */
-  _build(graph, node, path = [], ignoreBuilders = []) {
-    graph._setPath(node.id, path);
-    const subscriptions = this._unsubscribe.get(node.id) ?? new EventSubscriptions();
-    subscriptions.clear();
-    Array.from(this._nodeBuilders.entries()).filter(([id]) => ignoreBuilders.findIndex((ignore) => ignore === id) === -1).forEach(([_, builder]) => {
-      const unsubscribe = builder(node);
-      unsubscribe && subscriptions.add(unsubscribe);
+  build(previousGraph) {
+    this._unsubscribe.clear();
+    const graph = previousGraph ?? new Graph();
+    Array.from(this._extensions.values()).forEach((builder) => {
+      const unsubscribe = builder(graph);
+      unsubscribe && this._unsubscribe.add(unsubscribe);
     });
-    this._unsubscribe.set(node.id, subscriptions);
     return graph;
   }
-  _createNode(getGraph, partial, path = [], ignoreBuilders = []) {
-    const node = deepSignal2({
-      parent: null,
-      data: null,
-      properties: {},
-      childrenMap: {},
-      actionsMap: {},
-      // TODO(burdon): Document.
-      ...partial,
-      get children() {
-        return Object.values(node.childrenMap);
-      },
-      get actions() {
-        return Object.values(node.actionsMap);
-      },
-      //
-      // Properties
-      //
-      addProperty: (key, value) => {
-        untracked(() => {
-          node.properties[key] = value;
-        });
-      },
-      removeProperty: (key) => {
-        untracked(() => {
-          delete node.properties[key];
-        });
-      },
-      //
-      // Nodes
-      //
-      addNode: (builder, ...partials) => {
-        return untracked(() => {
-          return partials.map((partial2) => {
-            const builders = [
-              ...ignoreBuilders,
-              builder
-            ];
-            const childPath = [
-              ...path,
-              "childrenMap",
-              partial2.id
-            ];
-            const child = this._createNode(getGraph, {
-              ...partial2,
-              parent: node
-            }, childPath, builders);
-            node.childrenMap[child.id] = child;
-            this._build(getGraph(), child, childPath, builders);
-            return child;
-          });
-        });
-      },
-      removeNode: (id) => {
-        return untracked(() => {
-          const child = node.childrenMap[id];
-          delete node.childrenMap[id];
-          return child;
-        });
-      },
-      //
-      // Actions
-      //
-      addAction: (...partials) => {
-        return untracked(() => {
-          return partials.map((partial2) => {
-            const action = this._createAction(partial2);
-            let shortcut;
-            if (typeof action.keyBinding === "object") {
-              const availablePlatforms = Object.keys(action.keyBinding);
-              const platform = getHostPlatform();
-              shortcut = availablePlatforms.includes(platform) ? action.keyBinding[platform] : platform === "ios" ? action.keyBinding.macos : platform === "linux" || platform === "unknown" ? action.keyBinding.windows : void 0;
-            } else {
-              shortcut = action.keyBinding;
-            }
-            if (shortcut) {
-              Keyboard.singleton.getContext(path.join("/")).bind({
-                shortcut,
-                handler: () => {
-                  action.invoke({
-                    caller: KEY_BINDING
-                  });
-                },
-                data: action.label
-              });
-            }
-            node.actionsMap[action.id] = action;
-            return action;
-          });
-        });
-      },
-      removeAction: (id) => {
-        return untracked(() => {
-          const action = node.actionsMap[id];
-          if (action.keyBinding) {
-          }
-          delete node.actionsMap[id];
-          return action;
-        });
-      }
-    });
-    partial.actions && partial.actions.forEach((action) => node.addAction(action));
-    return node;
-  }
-  _createAction(partial) {
-    const action = deepSignal2({
-      properties: {},
-      ...partial,
-      actionsMap: {},
-      get actions() {
-        return Object.values(action.actionsMap);
-      },
-      addAction: (...partials) => {
-        return untracked(() => {
-          return partials.map((partial2) => {
-            const subAction = this._createAction(partial2);
-            action.actionsMap[subAction.id] = subAction;
-            return subAction;
-          });
-        });
-      },
-      removeAction: (id) => {
-        return untracked(() => {
-          const subAction = action.actionsMap[id];
-          delete action.actionsMap[id];
-          return subAction;
-        });
-      },
-      addProperty: (key, value) => {
-        return untracked(() => {
-          action.properties[key] = value;
-        });
-      },
-      removeProperty: (key) => {
-        return untracked(() => {
-          delete action.properties[key];
-        });
-      }
-    });
-    partial.actions && partial.actions.forEach((subAction) => action.addAction(subAction));
-    return action;
-  }
 };
 
-// packages/sdk/app-graph/src/node.ts
-var isGraphNode = (data) => data && typeof data === "object" ? "id" in data && "label" in data : false;
+// packages/sdk/app-graph/src/helpers.ts
+var manageNodes = ({ graph, condition, nodes, removeEdges }) => {
+  if (condition) {
+    return graph.addNodes(...nodes);
+  } else {
+    nodes.forEach(({ id }) => graph.removeNode(id, removeEdges));
+  }
+};
 export {
   Graph,
   GraphBuilder,
-  KEY_BINDING,
-  isGraphNode
+  ROOT_ID,
+  actionGroupSymbol,
+  isAction,
+  isActionGroup,
+  isActionLike,
+  isGraphNode,
+  manageNodes
 };
 //# sourceMappingURL=index.mjs.map