@dxos/graph 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/dist/lib/browser/index.mjs

@@ -1,27 +1,157 @@
-// src/model.ts
-import { effect } from "@preact/signals-core";
-import { inspectCustom } from "@dxos/debug";
-import { failedInvariant, invariant as invariant2 } from "@dxos/invariant";
-import { live } from "@dxos/live-object";
-import { isTruthy, removeBy } from "@dxos/util";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// src/util.ts
+// src/selection.ts
+import { Atom, Registry } from "@effect-atom/atom-react";
 import { invariant } from "@dxos/invariant";
-var __dxlog_file = "/__w/dxos/dxos/packages/common/graph/src/util.ts";
+var __dxlog_file = "/__w/dxos/dxos/packages/common/graph/src/selection.ts";
+var SelectionModel = class {
+  _singleSelect;
+  _registry;
+  _selected;
+  constructor(_singleSelect = false) {
+    this._singleSelect = _singleSelect;
+    this._registry = Registry.make();
+    this._selected = Atom.make(/* @__PURE__ */ new Set());
+  }
+  /**
+  * Returns the selected IDs atom for subscription.
+  */
+  get selected() {
+    return this._selected;
+  }
+  /**
+  * Gets the current selected IDs as a Set.
+  */
+  getSelected() {
+    return this._registry.get(this._selected);
+  }
+  /**
+  * Gets the current selected IDs as an array.
+  */
+  getSelectedIds() {
+    return Array.from(this._registry.get(this._selected).values());
+  }
+  /**
+  * Subscribe to selection changes.
+  */
+  subscribe(cb) {
+    this._registry.get(this._selected);
+    return this._registry.subscribe(this._selected, () => {
+      cb(this._registry.get(this._selected));
+    });
+  }
+  toJSON() {
+    return {
+      selected: this.getSelectedIds()
+    };
+  }
+  /**
+  * Gets the current selection size.
+  */
+  getSize() {
+    return this._registry.get(this._selected).size;
+  }
+  contains(id) {
+    return this._registry.get(this._selected).has(id);
+  }
+  clear() {
+    this._registry.set(this._selected, /* @__PURE__ */ new Set());
+  }
+  add(id) {
+    invariant(id, void 0, {
+      F: __dxlog_file,
+      L: 76,
+      S: this,
+      A: [
+        "id",
+        ""
+      ]
+    });
+    const current = this._registry.get(this._selected);
+    this._registry.set(this._selected, new Set(this._singleSelect ? [
+      id
+    ] : [
+      ...Array.from(current.values()),
+      id
+    ]));
+  }
+  remove(id) {
+    invariant(id, void 0, {
+      F: __dxlog_file,
+      L: 85,
+      S: this,
+      A: [
+        "id",
+        ""
+      ]
+    });
+    const current = this._registry.get(this._selected);
+    this._registry.set(this._selected, new Set(Array.from(current.values()).filter((_id) => _id !== id)));
+  }
+  // TODO(burdon): Handle single select.
+  setSelected(ids, subtract = false) {
+    const current = this._registry.get(this._selected);
+    this._registry.set(this._selected, /* @__PURE__ */ new Set([
+      ...subtract ? Array.from(current.values()) : [],
+      ...ids
+    ]));
+  }
+  toggleSelected(ids, subtract = false) {
+    const current = this._registry.get(this._selected);
+    const set = new Set(subtract ? Array.from(current.values()) : void 0);
+    ids.forEach((id) => {
+      if (current.has(id)) {
+        set.delete(id);
+      } else {
+        set.add(id);
+      }
+    });
+    this._registry.set(this._selected, set);
+  }
+};
+
+// src/Graph.ts
+var Graph_exports = {};
+__export(Graph_exports, {
+  Edge: () => Edge,
+  Graph: () => Graph,
+  Node: () => Node,
+  createEdgeId: () => createEdgeId,
+  parseEdgeId: () => parseEdgeId
+});
+import * as Schema from "effect/Schema";
+import { invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/common/graph/src/Graph.ts";
+var Node = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  data: Schema.optional(Schema.Any)
+});
+var Edge = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  source: Schema.String,
+  target: Schema.String,
+  data: Schema.optional(Schema.Any)
+});
 var KEY_REGEX = /\w+/;
 var createEdgeId = ({ source, target, relation }) => {
-  invariant(source.match(KEY_REGEX), `invalid source: ${source}`, {
-    F: __dxlog_file,
-    L: 13,
+  invariant2(source.match(KEY_REGEX), `invalid source: ${source}`, {
+    F: __dxlog_file2,
+    L: 52,
     S: void 0,
     A: [
       "source.match(KEY_REGEX)",
       "`invalid source: ${source}`"
     ]
   });
-  invariant(target.match(KEY_REGEX), `invalid target: ${target}`, {
-    F: __dxlog_file,
-    L: 14,
+  invariant2(target.match(KEY_REGEX), `invalid target: ${target}`, {
+    F: __dxlog_file2,
+    L: 53,
     S: void 0,
     A: [
       "target.match(KEY_REGEX)",
@@ -36,9 +166,9 @@ var createEdgeId = ({ source, target, relation }) => {
 };
 var parseEdgeId = (id) => {
   const [source, relation, target] = id.split("_");
-  invariant(source.length && target.length, void 0, {
-    F: __dxlog_file,
-    L: 20,
+  invariant2(source.length && target.length, void 0, {
+    F: __dxlog_file2,
+    L: 59,
     S: void 0,
     A: [
       "source.length && target.length",
@@ -51,19 +181,45 @@ var parseEdgeId = (id) => {
     target
   };
 };
+var Graph = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  nodes: Schema.mutable(Schema.Array(Node)),
+  edges: Schema.mutable(Schema.Array(Edge))
+});
 
-// src/model.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/common/graph/src/model.ts";
+// src/GraphModel.ts
+var GraphModel_exports = {};
+__export(GraphModel_exports, {
+  AbstractBuilder: () => AbstractBuilder,
+  AbstractGraphModel: () => AbstractGraphModel,
+  Builder: () => Builder,
+  GraphModel: () => GraphModel,
+  ReactiveGraphModel: () => ReactiveGraphModel,
+  ReadonlyGraphModel: () => ReadonlyGraphModel
+});
+import { Atom as Atom2 } from "@effect-atom/atom-react";
+import { inspectCustom } from "@dxos/debug";
+import { failedInvariant, invariant as invariant3 } from "@dxos/invariant";
+import { isTruthy, removeBy } from "@dxos/util";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/common/graph/src/GraphModel.ts";
 var ReadonlyGraphModel = class {
   _graph;
   /**
+  * Optional function to wrap mutations.
+  * When set, all graph mutations are wrapped in this function.
+  */
+  _change;
+  /**
   * NOTE: Pass in simple Graph or Live.
+  * @param graph - The graph data.
+  * @param change - Optional function to wrap mutations (e.g., Obj.change for ECHO objects).
   */
-  constructor(graph) {
+  constructor(graph, change) {
     this._graph = graph ?? {
       nodes: [],
       edges: []
     };
+    this._change = change;
   }
   [inspectCustom]() {
     return this.toJSON();
@@ -131,9 +287,22 @@ var ReadonlyGraphModel = class {
   }
 };
 var AbstractGraphModel = class extends ReadonlyGraphModel {
+  /**
+  * Execute a mutation on the graph.
+  * If a change function is set, wraps the mutation in it.
+  */
+  _mutate(fn) {
+    if (this._change != null) {
+      this._change(() => fn(this._graph));
+    } else {
+      fn(this._graph);
+    }
+  }
   clear() {
-    this._graph.nodes.length = 0;
-    this._graph.edges.length = 0;
+    this._mutate((graph) => {
+      graph.nodes.length = 0;
+      graph.edges.length = 0;
+    });
     return this;
   }
   addGraph(graph) {
@@ -149,43 +318,45 @@ var AbstractGraphModel = class extends ReadonlyGraphModel {
     return this;
   }
   addNode(node) {
-    invariant2(node.id, "ID is required", {
-      F: __dxlog_file2,
-      L: 157,
+    invariant3(node.id, "ID is required", {
+      F: __dxlog_file3,
+      L: 182,
       S: this,
       A: [
         "node.id",
         "'ID is required'"
       ]
     });
-    invariant2(!this.findNode(node.id), `node already exists: ${node.id}`, {
-      F: __dxlog_file2,
-      L: 158,
+    invariant3(!this.findNode(node.id), `node already exists: ${node.id}`, {
+      F: __dxlog_file3,
+      L: 183,
       S: this,
       A: [
         "!this.findNode(node.id)",
         "`node already exists: ${node.id}`"
       ]
     });
-    this._graph.nodes.push(node);
+    this._mutate((graph) => {
+      graph.nodes.push(node);
+    });
     return node;
   }
   addNodes(nodes) {
     return nodes.map((node) => this.addNode(node));
   }
   addEdge(edge) {
-    invariant2(edge.source, void 0, {
-      F: __dxlog_file2,
-      L: 168,
+    invariant3(edge.source, void 0, {
+      F: __dxlog_file3,
+      L: 195,
       S: this,
       A: [
         "edge.source",
         ""
       ]
     });
-    invariant2(edge.target, void 0, {
-      F: __dxlog_file2,
-      L: 169,
+    invariant3(edge.target, void 0, {
+      F: __dxlog_file3,
+      L: 196,
       S: this,
       A: [
         "edge.target",
@@ -198,27 +369,33 @@ var AbstractGraphModel = class extends ReadonlyGraphModel {
         ...edge
       };
     }
-    invariant2(!this.findNode(edge.id), void 0, {
-      F: __dxlog_file2,
-      L: 174,
+    invariant3(!this.findNode(edge.id), void 0, {
+      F: __dxlog_file3,
+      L: 201,
       S: this,
       A: [
         "!this.findNode(edge.id!)",
         ""
       ]
     });
-    this._graph.edges.push(edge);
+    this._mutate((graph) => {
+      graph.edges.push(edge);
+    });
     return edge;
   }
   addEdges(edges) {
     return edges.map((edge) => this.addEdge(edge));
   }
   removeNode(id) {
-    const edges = removeBy(this._graph.edges, (edge) => edge.source === id || edge.target === id);
-    const nodes = removeBy(this._graph.nodes, (node) => node.id === id);
+    let removedEdges = [];
+    let removedNodes = [];
+    this._mutate((graph) => {
+      removedEdges = removeBy(graph.edges, (edge) => edge.source === id || edge.target === id);
+      removedNodes = removeBy(graph.nodes, (node) => node.id === id);
+    });
     return this.copy({
-      nodes,
-      edges
+      nodes: removedNodes,
+      edges: removedEdges
     });
   }
   removeNodes(ids) {
@@ -226,10 +403,13 @@ var AbstractGraphModel = class extends ReadonlyGraphModel {
     return this.copy().addGraphs(graphs);
   }
   removeEdge(id) {
-    const edges = removeBy(this._graph.edges, (edge) => edge.id === id);
+    let removedEdges = [];
+    this._mutate((graph) => {
+      removedEdges = removeBy(graph.edges, (edge) => edge.id === id);
+    });
     return this.copy({
       nodes: [],
-      edges
+      edges: removedEdges
     });
   }
   removeEdges(ids) {
@@ -237,7 +417,7 @@ var AbstractGraphModel = class extends ReadonlyGraphModel {
     return this.copy().addGraphs(graphs);
   }
 };
-var AbstractGraphBuilder = class {
+var AbstractBuilder = class {
   _model;
   constructor(_model) {
     this._model = _model;
@@ -271,153 +451,178 @@ var AbstractGraphBuilder = class {
 };
 var GraphModel = class _GraphModel extends AbstractGraphModel {
   get builder() {
-    return new GraphBuilder(this);
+    return new Builder(this);
   }
   copy(graph) {
-    return new _GraphModel({
-      nodes: graph?.nodes ?? [],
-      edges: graph?.edges ?? []
-    });
+    return new _GraphModel(graph);
   }
 };
-var subscribe = (model, cb, fire = false) => {
-  if (fire) {
-    cb(model, model.graph);
-  }
-  return effect(() => {
-    cb(model, model.graph);
-  });
-};
 var ReactiveGraphModel = class _ReactiveGraphModel extends GraphModel {
-  constructor(graph) {
-    super(live({
+  _registry;
+  _graphAtom;
+  constructor(_registry, graph) {
+    const initialGraph = {
       nodes: graph?.nodes ?? [],
       edges: graph?.edges ?? []
-    }));
+    };
+    super(initialGraph), this._registry = _registry;
+    this._graphAtom = Atom2.make(initialGraph);
   }
-  copy(graph) {
-    return new _ReactiveGraphModel(graph);
+  get registry() {
+    return this._registry;
   }
-  subscribe(cb, fire = false) {
-    return subscribe(this, cb, fire);
+  /**
+  * Get the graph atom for reactive subscriptions.
+  */
+  get graphAtom() {
+    return this._graphAtom;
   }
-};
-var GraphBuilder = class extends AbstractGraphBuilder {
-  call(cb) {
-    cb(this);
-    return this;
+  get graph() {
+    return this._registry.get(this._graphAtom);
   }
-};
-
-// src/selection.ts
-import { computed, signal } from "@preact/signals-core";
-import { invariant as invariant3 } from "@dxos/invariant";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/common/graph/src/selection.ts";
-var SelectionModel = class {
-  _singleSelect;
-  _selected = signal(/* @__PURE__ */ new Set());
-  _selectedIds = computed(() => Array.from(this._selected.value.values()));
-  constructor(_singleSelect = false) {
-    this._singleSelect = _singleSelect;
+  get nodes() {
+    return this.graph.nodes;
   }
-  toJSON() {
-    return {
-      selected: Array.from(this._selected.value.values())
-    };
+  get edges() {
+    return this.graph.edges;
   }
-  get size() {
-    return this._selected.value.size;
+  copy(graph) {
+    return new _ReactiveGraphModel(this._registry, graph);
   }
-  get selected() {
-    return this._selectedIds;
+  clear() {
+    this._registry.set(this._graphAtom, {
+      nodes: [],
+      edges: []
+    });
+    return this;
   }
-  contains(id) {
-    return this._selected.value.has(id);
+  /**
+  * Set the entire graph at once, triggering a single notification.
+  */
+  setGraph(graph) {
+    this._registry.set(this._graphAtom, graph);
+    return this;
   }
-  clear() {
-    this._selected.value = /* @__PURE__ */ new Set();
+  addNode(node) {
+    invariant3(node.id, "ID is required", {
+      F: __dxlog_file3,
+      L: 374,
+      S: this,
+      A: [
+        "node.id",
+        "'ID is required'"
+      ]
+    });
+    invariant3(!this.findNode(node.id), `node already exists: ${node.id}`, {
+      F: __dxlog_file3,
+      L: 375,
+      S: this,
+      A: [
+        "!this.findNode(node.id)",
+        "`node already exists: ${node.id}`"
+      ]
+    });
+    const current = this._registry.get(this._graphAtom);
+    this._registry.set(this._graphAtom, {
+      ...current,
+      nodes: [
+        ...current.nodes,
+        node
+      ]
+    });
+    return node;
   }
-  add(id) {
-    invariant3(id, void 0, {
+  addEdge(edge) {
+    invariant3(edge.source, void 0, {
       F: __dxlog_file3,
-      L: 41,
+      L: 385,
       S: this,
       A: [
-        "id",
+        "edge.source",
         ""
       ]
     });
-    this._selected.value = new Set(this._singleSelect ? [
-      id
-    ] : [
-      ...Array.from(this._selected.value.values()),
-      id
-    ]);
-  }
-  remove(id) {
-    invariant3(id, void 0, {
+    invariant3(edge.target, void 0, {
       F: __dxlog_file3,
-      L: 48,
+      L: 386,
       S: this,
       A: [
-        "id",
+        "edge.target",
+        ""
+      ]
+    });
+    if (!edge.id) {
+      edge = {
+        id: createEdgeId(edge),
+        ...edge
+      };
+    }
+    invariant3(!this.findNode(edge.id), void 0, {
+      F: __dxlog_file3,
+      L: 390,
+      S: this,
+      A: [
+        "!this.findNode(edge.id!)",
         ""
       ]
     });
-    this._selected.value = new Set(Array.from(this._selected.value.values()).filter((_id) => _id !== id));
+    const current = this._registry.get(this._graphAtom);
+    this._registry.set(this._graphAtom, {
+      ...current,
+      edges: [
+        ...current.edges,
+        edge
+      ]
+    });
+    return edge;
   }
-  // TODO(burdon): Handle single select.
-  setSelected(ids, shift = false) {
-    this._selected.value = /* @__PURE__ */ new Set([
-      ...shift ? Array.from(this._selected.value.values()) : [],
-      ...ids
-    ]);
+  removeNode(id) {
+    const current = this._registry.get(this._graphAtom);
+    const removedEdges = current.edges.filter((edge) => edge.source === id || edge.target === id);
+    const removedNodes = current.nodes.filter((node) => node.id === id);
+    this._registry.set(this._graphAtom, {
+      nodes: current.nodes.filter((node) => node.id !== id),
+      edges: current.edges.filter((edge) => edge.source !== id && edge.target !== id)
+    });
+    return this.copy({
+      nodes: removedNodes,
+      edges: removedEdges
+    });
   }
-  toggleSelected(ids, shift = false) {
-    const set = new Set(shift ? Array.from(this._selected.value.values()) : void 0);
-    ids.forEach((id) => {
-      if (this._selected.value.has(id)) {
-        set.delete(id);
-      } else {
-        set.add(id);
-      }
+  removeEdge(id) {
+    const current = this._registry.get(this._graphAtom);
+    const removedEdges = current.edges.filter((edge) => edge.id === id);
+    this._registry.set(this._graphAtom, {
+      ...current,
+      edges: current.edges.filter((edge) => edge.id !== id)
+    });
+    return this.copy({
+      nodes: [],
+      edges: removedEdges
+    });
+  }
+  /**
+  * Subscribe to graph changes.
+  */
+  subscribe(cb, fire = false) {
+    if (fire) {
+      cb(this, this.graph);
+    }
+    this._registry.get(this._graphAtom);
+    return this._registry.subscribe(this._graphAtom, () => {
+      cb(this, this.graph);
     });
-    this._selected.value = set;
   }
 };
-
-// src/types.ts
-import * as Schema from "effect/Schema";
-var BaseGraphNode = Schema.Struct({
-  id: Schema.String,
-  type: Schema.optional(Schema.String),
-  data: Schema.optional(Schema.Any)
-});
-var BaseGraphEdge = Schema.Struct({
-  id: Schema.String,
-  type: Schema.optional(Schema.String),
-  source: Schema.String,
-  target: Schema.String,
-  data: Schema.optional(Schema.Any)
-});
-var Graph = Schema.Struct({
-  id: Schema.optional(Schema.String),
-  nodes: Schema.mutable(Schema.Array(BaseGraphNode)),
-  edges: Schema.mutable(Schema.Array(BaseGraphEdge))
-});
+var Builder = class extends AbstractBuilder {
+  call(cb) {
+    cb(this);
+    return this;
+  }
+};
 export {
-  AbstractGraphBuilder,
-  AbstractGraphModel,
-  BaseGraphEdge,
-  BaseGraphNode,
-  Graph,
-  GraphBuilder,
-  GraphModel,
-  ReactiveGraphModel,
-  ReadonlyGraphModel,
-  SelectionModel,
-  createEdgeId,
-  parseEdgeId,
-  subscribe
+  Graph_exports as Graph,
+  GraphModel_exports as GraphModel,
+  SelectionModel
 };
 //# sourceMappingURL=index.mjs.map