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

package/dist/lib/browser/index.mjs

@@ -1,352 +1,292 @@
 // 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() {
-    /**
-    * @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);
-        }
+  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
       };
-      return node;
     };
+    return toJSON(this._root);
   }
   /**
-  * Alias for `findNode('root')`.
+  * The root node of the graph which is the entry point for all knowledge.
   */
   get root() {
-    return this.findNode(ROOT_ID);
+    return this._root;
   }
   /**
-  * Convert the graph to a JSON object.
+  * Get the path through the graph from the root to the node with the given id.
   */
-  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}`, {
+  getPath(id) {
+    return this._index[id];
+  }
+  /**
+  * @internal
+  */
+  _setPath(id, path) {
+    invariant(id && path, "Invalid path.", {
       F: __dxlog_file,
-      L: 85,
+      L: 82,
       S: this,
       A: [
-        "root",
-        "`Node not found: ${id}`"
+        "id && path",
+        "'Invalid path.'"
       ]
     });
-    return toJSON(root);
+    this._index[id] = path;
   }
   /**
   * Find the node with the given id in the graph.
   */
   findNode(id) {
-    const nodeBase = this._nodes[id];
-    if (!nodeBase) {
+    const path = this.getPath(id);
+    if (!path) {
       return void 0;
     }
-    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);
-      }
-    });
+    return path.length > 0 ? get(this._root, path) : this._root;
   }
   /**
-  * 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.
+  * Recursive breadth-first traversal.
   */
-  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;
-    }
+  traverse({ node = this._root, direction = "down", filter, visitor }, depth = 0) {
     if (!filter || filter(node)) {
-      visitor?.(node, [
-        ...path,
-        node.id
-      ]);
+      visitor?.(node, this.getPath(node.id));
     }
-    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;
+    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);
     }
-    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._extensions = /* @__PURE__ */ new Map();
-    this._unsubscribe = new EventSubscriptions();
+    this._nodeBuilders = /* @__PURE__ */ new Map();
+    this._unsubscribe = /* @__PURE__ */ new Map();
   }
   /**
   * Register a node builder which will be called in order to construct the graph.
   */
-  addExtension(id, extension) {
-    this._extensions.set(id, extension);
+  addNodeBuilder(id, builder) {
+    this._nodeBuilders.set(id, builder);
     return this;
   }
   /**
   * Remove a node builder from the graph builder.
   */
-  removeExtension(id) {
-    this._extensions.delete(id);
+  removeNodeBuilder(id) {
+    this._nodeBuilders.delete(id);
     return this;
   }
   /**
-  * Construct the graph, starting by calling all registered extensions.
+  * 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.
   * @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(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);
+  _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);
     });
+    this._unsubscribe.set(node.id, subscriptions);
     return graph;
   }
-};
-
-// 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));
+  _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;
 export {
   Graph,
   GraphBuilder,
-  ROOT_ID,
-  actionGroupSymbol,
-  isAction,
-  isActionGroup,
-  isActionLike,
-  isGraphNode,
-  manageNodes
+  KEY_BINDING,
+  isGraphNode
 };
 //# sourceMappingURL=index.mjs.map