@multiplatform.one/node-graph 7.7.2

package/dist/cjs/react-flow/flowAdapter.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","flowAdapter_exports","__export","preserveFlowState","toFlowEdges","toFlowNodes","module","exports","import_model","require","import_GraphEdge","import_edgeStyle","import_nodeMeasure","document","schema","options","nodes","map","node","flowNode","_node_size","_node_size1","spec","nodeKindSpec","kind","ports","resolvePorts","measured","graphNodeMeasure","size","portSpacingPx","measure","id","type","nodeType","position","initialWidth","width","initialHeight","minHeight","height","parentId","parent","draggable","locked","data","intent","edges","edge","flowEdge","appearance","graphEdgeType","source","sourceHandle","port","target","targetHandle","markerEnd","edgeMarkerEnd","label","next","previous","length","before","Map"],"sources":["../../../src/react-flow/flowAdapter.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/react-flow/graphHandle.cjs

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var graphHandle_exports = {};
+__export(graphHandle_exports, {
+  graphCommandNames: () => graphCommandNames
+});
+module.exports = __toCommonJS(graphHandle_exports);
+const graphCommandNames = ["fitView", "relayout", "zoomTo", "centerOn", "setSelection", "exportViewport", "undo", "redo", "perfStart", "perfStop", "perfMark", "setViewport", "synthPinch"];

package/dist/cjs/react-flow/graphHandle.native.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var graphHandle_exports = {};
+__export(graphHandle_exports, {
+  graphCommandNames: () => graphCommandNames
+});
+module.exports = __toCommonJS(graphHandle_exports);
+var graphCommandNames = ["fitView", "relayout", "zoomTo", "centerOn", "setSelection", "exportViewport", "undo", "redo", "perfStart", "perfStop", "perfMark", "setViewport", "synthPinch"];
+//# sourceMappingURL=graphHandle.native.js.map

package/dist/cjs/react-flow/graphHandle.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","graphHandle_exports","__export","graphCommandNames","module","exports"],"sources":["../../../src/react-flow/graphHandle.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,mBAAA;AAAAC,QAAA,CAAAD,mBAAA;EAAAE,iBAAA,EAAAA,CAAA,KAAAA;AAAA;AA4FOC,MAAM,CAAAC,OAAA,GAAAT,YAAoB,CAAAK,mBAAA;AAAA,IAC/BE,iBAAA,IACA,WACA,YACA,UACA,YACA,gBACA,kBACA,QACA,QACA,aACA,YACA,YACA,eACF,a","ignoreList":[]}

package/dist/cjs/react-flow/nodeCensus.cjs

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var nodeCensus_exports = {};
+__export(nodeCensus_exports, {
+  mountedNodeCount: () => mountedNodeCount,
+  registerMountedNode: () => registerMountedNode,
+  resetNodeCensus: () => resetNodeCensus,
+  subscribeNodeCensus: () => subscribeNodeCensus
+});
+module.exports = __toCommonJS(nodeCensus_exports);
+const mounted = /* @__PURE__ */new Set();
+const listeners = /* @__PURE__ */new Set();
+function notify() {
+  for (const listener of listeners) listener();
+}
+function registerMountedNode(id) {
+  const had = mounted.has(id);
+  mounted.add(id);
+  if (!had) notify();
+  return () => {
+    if (mounted.delete(id)) notify();
+  };
+}
+function mountedNodeCount() {
+  return mounted.size;
+}
+function subscribeNodeCensus(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function resetNodeCensus() {
+  mounted.clear();
+  notify();
+}

package/dist/cjs/react-flow/nodeCensus.native.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var nodeCensus_exports = {};
+__export(nodeCensus_exports, {
+  mountedNodeCount: () => mountedNodeCount,
+  registerMountedNode: () => registerMountedNode,
+  resetNodeCensus: () => resetNodeCensus,
+  subscribeNodeCensus: () => subscribeNodeCensus
+});
+module.exports = __toCommonJS(nodeCensus_exports);
+var mounted = /* @__PURE__ */new Set();
+var listeners = /* @__PURE__ */new Set();
+function notify() {
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = listeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var listener = _step.value;
+      listener();
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+}
+function registerMountedNode(id) {
+  var had = mounted.has(id);
+  mounted.add(id);
+  if (!had) notify();
+  return function () {
+    if (mounted.delete(id)) notify();
+  };
+}
+function mountedNodeCount() {
+  return mounted.size;
+}
+function subscribeNodeCensus(listener) {
+  listeners.add(listener);
+  return function () {
+    listeners.delete(listener);
+  };
+}
+function resetNodeCensus() {
+  mounted.clear();
+  notify();
+}
+//# sourceMappingURL=nodeCensus.native.js.map

package/dist/cjs/react-flow/nodeCensus.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","nodeCensus_exports","__export","mountedNodeCount","registerMountedNode","resetNodeCensus","subscribeNodeCensus","module","exports","mounted","Set","listeners","notify","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","Symbol","iterator","_step","next","done","listener","err","return","id"],"sources":["../../../src/react-flow/nodeCensus.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,kBAAA;AAAAC,QAAA,CAAAD,kBAAA;EAAAE,gBAAA,EAAAA,CAAA,KAAAA,gBAAA;EAAAC,mBAAA,EAAAA,CAAA,KAAAA,mBAAA;EAAAC,eAAA,EAAAA,CAAA,KAAAA,eAAA;EAAAC,mBAAA,EAAAA,CAAA,KAAAA;AAAA;AA8BAC,MAAM,CAAAC,OAAA,GAAUZ,YAAA,CAAAK,kBAAgB;AAChC,IAAAQ,OAAM,kBAAY,IAAAC,GAAA,CAAI;AAEtB,IAAAC,SAAS,kBAAe,IAAAD,GAAA;AACtB,SAAAE,MAAWA,CAAA;EACb,IAAAC,yBAAA;IAAAC,iBAAA;IAAAC,cAAA;EASO;IACL,KAAM,IAAAC,SAAc,GAAAL,SAAM,CAAAM,MAAA,CAAAC,QAAA,KAAAC,KAAA,IAAAN,yBAAA,IAAAM,KAAA,GAAAH,SAAA,CAAAI,IAAA,IAAAC,IAAA,GAAAR,yBAAA;MAC1B,IAAQS,QAAM,GAAAH,KAAA,CAAAnB,KAAA;MACVsB,QAAM;IACV;EACE,SAAIC,GAAA,EAAQ;IACdT,iBAAA;IACFC,cAAA,GAAAQ,GAAA;EAEO,UAAS;IACd;MACF,KAAAV,yBAAA,IAAAG,SAAA,CAAAQ,MAAA;QAEOR,SAAS,CAAAQ,MAAA;MACd;IACA,UAAO;MACL,IAAAV,iBAAiB,EAAQ;QAC3B,MAAAC,cAAA;MACF;IAGO;EACL;AACA;AACF,SAAAX,oBAAAqB,EAAA","ignoreList":[]}

package/dist/cjs/react-flow/useGraphController.cjs

@@ -0,0 +1,297 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useGraphController_exports = {};
+__export(useGraphController_exports, {
+  applyGraphCommand: () => applyGraphCommand,
+  defaultGraphNodeType: () => defaultGraphNodeType,
+  resetControllerWarnings: () => resetControllerWarnings,
+  useGraphController: () => useGraphController
+});
+module.exports = __toCommonJS(useGraphController_exports);
+var import_react = require("react");
+var import_model = require("../model/index.cjs");
+var import_layout = require("../layout/layout.cjs");
+var import_nodeMeasure = require("../nodes/nodeMeasure.cjs");
+var import_flowAdapter = require("./flowAdapter.cjs");
+var import_xy = require("./xy.cjs");
+const warned = /* @__PURE__ */new Set();
+function warnOnce(message) {
+  if (process.env.NODE_ENV === "production") return;
+  if (warned.has(message)) return;
+  warned.add(message);
+  console.warn(`[@multiplatform.one/node-graph] ${message}`);
+}
+function resetControllerWarnings() {
+  warned.clear();
+}
+const defaultGraphNodeType = "mpGraphNode";
+const emptyDocument = {
+  version: 1,
+  nodes: [],
+  edges: []
+};
+function positionsOf(nodes) {
+  const out = {};
+  for (const node of nodes) out[node.id] = node.position;
+  return out;
+}
+function dragDeltas(document, nodes) {
+  const live = positionsOf(nodes);
+  const deltas = {};
+  for (const node of document.nodes) {
+    const to = live[node.id];
+    if (!to) continue;
+    const dx = to.x - node.position.x;
+    const dy = to.y - node.position.y;
+    if (dx === 0 && dy === 0) continue;
+    deltas[node.id] = {
+      x: dx,
+      y: dy
+    };
+  }
+  return deltas;
+}
+function useGraphController(options) {
+  const {
+    schema,
+    document: controlledDocument,
+    defaultDocument,
+    onDocumentChange,
+    onConnectionRefused,
+    readOnly = false,
+    size = "medium",
+    coarsePointer = false,
+    nodeType = defaultGraphNodeType,
+    readMeasuredSizes
+  } = options;
+  const controlled = controlledDocument !== void 0;
+  if (controlled && defaultDocument !== void 0) {
+    warnOnce("useGraphController received both `document` and `defaultDocument`. `document` wins; drop `defaultDocument` to silence this.");
+  }
+  const [ownDocument, setOwnDocument] = (0, import_react.useState)(() => defaultDocument ?? controlledDocument ?? emptyDocument);
+  const document = controlled ? controlledDocument : ownDocument;
+  const history = (0, import_react.useMemo)(() => (0, import_model.createHistory)(options.history),
+  // The journal is per-controller, not per-render. Rebuilding it on an
+  // inline `{ limit: 100 }` literal would silently erase the undo stack on
+  // every render of the parent.
+  // oxlint-disable-next-line exhaustive-deps
+  []);
+  const [historyVersion, setHistoryVersion] = (0, import_react.useState)(0);
+  const portSpacingPx = coarsePointer ? (0, import_nodeMeasure.portSpacing)({
+    coarsePointer
+  }) : import_nodeMeasure.FINE_PORT_PITCH;
+  const mapping = (0, import_react.useMemo)(() => ({
+    size,
+    portSpacingPx,
+    nodeType
+  }), [size, portSpacingPx, nodeType]);
+  const [nodes, setNodes] = (0, import_react.useState)(() => (0, import_flowAdapter.toFlowNodes)(document, schema, mapping));
+  const [edges, setEdges] = (0, import_react.useState)(() => (0, import_flowAdapter.toFlowEdges)(document, schema));
+  const nodesRef = (0, import_react.useRef)(nodes);
+  nodesRef.current = nodes;
+  const documentRef = (0, import_react.useRef)(document);
+  documentRef.current = document;
+  const schemaRef = (0, import_react.useRef)(schema);
+  schemaRef.current = schema;
+  (0, import_react.useEffect)(() => {
+    const current = schemaRef.current;
+    setNodes(previous => (0, import_flowAdapter.preserveFlowState)((0, import_flowAdapter.toFlowNodes)(document, current, mapping), previous));
+    setEdges((0, import_flowAdapter.toFlowEdges)(document, current));
+  }, [document, schema.id, mapping]);
+  const commit = (0, import_react.useCallback)(command => {
+    const current = documentRef.current;
+    const next = history.commit(current, command);
+    setHistoryVersion(version => version + 1);
+    if (!controlled) setOwnDocument(next);
+    documentRef.current = next;
+    onDocumentChange?.(next, command);
+  }, [controlled, history, onDocumentChange]);
+  const onNodesChange = (0, import_react.useCallback)(changes => {
+    const next = (0, import_xy.applyNodeChanges)(changes, nodesRef.current);
+    nodesRef.current = next;
+    setNodes(next);
+    if (layoutTouchedRef.current) {
+      for (const change of changes) {
+        if (change.type === "position") layoutTouchedRef.current.add(change.id);
+      }
+    }
+    if (readOnly) return;
+    const dragEnded = changes.some(change => change.type === "position" && change.dragging === false);
+    if (!dragEnded) return;
+    const deltas = dragDeltas(documentRef.current, next);
+    if (Object.keys(deltas).length === 0) return;
+    commit({
+      t: "moveNodes",
+      deltas
+    });
+  }, [commit, readOnly]);
+  const onEdgesChange = (0, import_react.useCallback)(changes => {
+    const next = (0, import_xy.applyEdgeChanges)(changes, edges);
+    setEdges(next);
+    if (readOnly) return;
+    const removed = changes.filter(change => change.type === "remove").map(change => change.id);
+    if (removed.length === 0) return;
+    commit({
+      t: "removeEdges",
+      ids: removed
+    });
+  }, [commit, edges, readOnly]);
+  const connectionContext = (0, import_react.useCallback)(connection => {
+    if (!connection.source || !connection.target) return void 0;
+    if (!connection.sourceHandle || !connection.targetHandle) return void 0;
+    return {
+      document: documentRef.current,
+      schema,
+      source: {
+        node: connection.source,
+        port: connection.sourceHandle
+      },
+      target: {
+        node: connection.target,
+        port: connection.targetHandle
+      }
+    };
+  }, [schema]);
+  const isValidConnection = (0, import_react.useCallback)(connection => {
+    if (readOnly) return false;
+    const ctx = connectionContext(connection);
+    if (!ctx) return false;
+    return (0, import_model.validateConnection)(ctx).ok;
+  }, [connectionContext, readOnly]);
+  const onConnect = (0, import_react.useCallback)(connection => {
+    if (readOnly) return;
+    const ctx = connectionContext(connection);
+    if (!ctx) return;
+    const verdict = (0, import_model.validateDrop)(ctx);
+    if (!verdict.ok) {
+      onConnectionRefused?.(verdict);
+      return;
+    }
+    const kind = defaultEdgeKind(schema);
+    if (!kind) return;
+    const spec = schema.edges[kind];
+    const edge = {
+      id: `${ctx.source.node}:${ctx.source.port}->${ctx.target.node}:${ctx.target.port}`,
+      kind,
+      source: ctx.source,
+      target: ctx.target,
+      // The kind's own `defaultData`. `E[kind]` cannot be proven from a
+      // runtime string, so the cast is at the ONE place the kind is chosen,
+      // not spread through the command type.
+      data: spec?.defaultData ?? {}
+    };
+    commit({
+      t: "addEdges",
+      edges: [edge]
+    });
+  }, [commit, connectionContext, onConnectionRefused, readOnly, schema]);
+  const measuredRef = (0, import_react.useRef)(readMeasuredSizes);
+  measuredRef.current = readMeasuredSizes;
+  const layoutGenerationRef = (0, import_react.useRef)(0);
+  const layoutTouchedRef = (0, import_react.useRef)(null);
+  const [layoutRunner, setLayoutRunner] = (0, import_react.useState)("none");
+  const [lastLayoutMs, setLastLayoutMs] = (0, import_react.useState)(null);
+  const [layoutPending, setLayoutPending] = (0, import_react.useState)(false);
+  const relayout = (0, import_react.useCallback)(async (layoutOptions = {}) => {
+    const source = documentRef.current;
+    if (source.nodes.length === 0) return null;
+    const generation = layoutGenerationRef.current += 1;
+    layoutTouchedRef.current = /* @__PURE__ */new Set();
+    setLayoutPending(true);
+    let result;
+    try {
+      result = await (0, import_layout.layout)(source, schemaRef.current, {
+        ...layoutOptions,
+        size,
+        coarsePointer,
+        measured: layoutOptions.measured ?? measuredRef.current?.()
+      });
+    } finally {
+      if (layoutGenerationRef.current === generation) setLayoutPending(false);
+    }
+    if (layoutGenerationRef.current !== generation) return result;
+    const touched = layoutTouchedRef.current ?? /* @__PURE__ */new Set();
+    layoutTouchedRef.current = null;
+    setLayoutRunner(result.runner ?? "inline");
+    setLastLayoutMs(result.ms);
+    if (readOnly) return result;
+    const positions = (0, import_layout.reconcilePositions)(result, touched);
+    if (Object.keys(positions).length === 0) return result;
+    (0, import_react.startTransition)(() => {
+      commit({
+        t: "setPositions",
+        positions
+      });
+    });
+    return result;
+  }, [coarsePointer, commit, readOnly, size]);
+  const undo = (0, import_react.useCallback)(() => {
+    const next = history.undo(documentRef.current);
+    setHistoryVersion(version => version + 1);
+    if (next === documentRef.current) return;
+    if (!controlled) setOwnDocument(next);
+    documentRef.current = next;
+    onDocumentChange?.(next, {
+      t: "batch",
+      commands: []
+    });
+  }, [controlled, history, onDocumentChange]);
+  const redo = (0, import_react.useCallback)(() => {
+    const next = history.redo(documentRef.current);
+    setHistoryVersion(version => version + 1);
+    if (next === documentRef.current) return;
+    if (!controlled) setOwnDocument(next);
+    documentRef.current = next;
+    onDocumentChange?.(next, {
+      t: "batch",
+      commands: []
+    });
+  }, [controlled, history, onDocumentChange]);
+  return {
+    document,
+    nodes,
+    edges,
+    onNodesChange,
+    onEdgesChange,
+    onConnect,
+    isValidConnection,
+    commit,
+    undo,
+    redo,
+    // `historyVersion` is what makes these re-read after a commit; the journal
+    // itself is a stable object, so nothing else would tell React to look.
+    canUndo: (0, import_react.useMemo)(() => history.canUndo(), [history, historyVersion]),
+    canRedo: (0, import_react.useMemo)(() => history.canRedo(), [history, historyVersion]),
+    relayout,
+    layoutRunner,
+    lastLayoutMs,
+    layoutPending
+  };
+}
+function defaultEdgeKind(schema) {
+  const names = Object.keys(schema.edges);
+  return names.includes("flow") ? "flow" : names[0];
+}
+function applyGraphCommand(document, command) {
+  return (0, import_model.applyCommand)(document, command);
+}