@xxrandr/conecta-diagram 0.0.0-stage → 0.1.4

package/dist/chunk-IT5H6WO2.js

@@ -0,0 +1,626 @@
+import {
+  evaluateCondition
+} from "./chunk-GXOBW2BK.js";
+import {
+  FlowError,
+  assertFlow,
+  assertJson,
+  clone,
+  equal,
+  freeze
+} from "./chunk-Q62JPMJH.js";
+
+// src/core/globals.ts
+function globalValueType(value) {
+  return Array.isArray(value) ? "array" : typeof value === "boolean" ? "boolean" : typeof value === "number" && Number.isSafeInteger(value) ? "integer" : "json";
+}
+function flowCreationOrder(document) {
+  return document.creationOrder ? [...document.creationOrder] : [
+    ...document.nodes.map((node) => ({
+      type: "node",
+      id: node.id
+    })),
+    ...document.edges.map((edge) => ({
+      type: "edge",
+      id: edge.id
+    }))
+  ];
+}
+function orderedFlowItems(document) {
+  return [
+    ...(document.globals ?? []).map((variable) => ({
+      type: "global",
+      id: variable.id
+    })),
+    ...flowCreationOrder(document)
+  ];
+}
+
+// src/core/store.ts
+var FlowStore = class {
+  constructor(document, options = {}) {
+    this.options = options;
+    assertFlow(document);
+    this.limit = options.historyLimit ?? 100;
+    if (!Number.isSafeInteger(this.limit) || this.limit < 0)
+      throw new FlowError(
+        "INVALID_LIMIT",
+        "historyLimit must be a nonnegative integer."
+      );
+    this.document = freeze(clone(document));
+  }
+  options;
+  document;
+  past = [];
+  future = [];
+  listeners = /* @__PURE__ */ new Set();
+  revision = 0;
+  editing = false;
+  notifying = false;
+  limit;
+  /** Frozen at runtime; mutate through transaction() instead. */
+  getSnapshot() {
+    return this.document;
+  }
+  getRevision() {
+    return this.revision;
+  }
+  get canUndo() {
+    return this.past.length > 0;
+  }
+  get canRedo() {
+    return this.future.length > 0;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  transaction(reason, edit) {
+    this.guard();
+    this.editing = true;
+    let next;
+    try {
+      next = clone(this.document);
+      const result = edit(next);
+      if (result && typeof result.then === "function") {
+        throw new FlowError(
+          "ASYNC_TRANSACTION",
+          "Transactions must be synchronous."
+        );
+      }
+      const before = [
+        ...this.document.nodes.map((node) => ["node", node.id]),
+        ...this.document.edges.map((edge) => ["edge", edge.id])
+      ];
+      const after = [
+        ...next.nodes.map((node) => ["node", node.id]),
+        ...next.edges.map((edge) => ["edge", edge.id])
+      ];
+      if (!equal(before, after) && equal(next.creationOrder, this.document.creationOrder)) {
+        const current = new Set(
+          after.map((reference) => JSON.stringify(reference))
+        );
+        const order = flowCreationOrder(this.document).filter(
+          (reference) => current.has(JSON.stringify([reference.type, reference.id]))
+        );
+        const recorded = new Set(
+          order.map(
+            (reference) => JSON.stringify([reference.type, reference.id])
+          )
+        );
+        for (const [type, id] of after)
+          if (!recorded.has(JSON.stringify([type, id])))
+            order.push({ type, id });
+        next.creationOrder = order;
+      }
+      assertFlow(next);
+      next = freeze(clone(next));
+    } finally {
+      this.editing = false;
+    }
+    if (equal(next, this.document)) return;
+    if (this.limit)
+      this.past = [...this.past, this.document].slice(-this.limit);
+    this.future = [];
+    this.document = next;
+    this.emit(reason);
+  }
+  replace(document) {
+    assertFlow(document);
+    this.transaction("replace", (draft) => {
+      for (const key of Object.keys(draft))
+        delete draft[key];
+      Object.assign(draft, clone(document));
+    });
+  }
+  addNode(node) {
+    assertJson(node);
+    this.transaction("add-node", (draft) => {
+      draft.nodes.push(clone(node));
+    });
+  }
+  addGlobal(variable) {
+    assertJson(variable);
+    this.transaction("add-global", (draft) => {
+      (draft.globals ??= []).push(clone(variable));
+    });
+  }
+  updateGlobal(id, update) {
+    this.transaction("update-global", (draft) => {
+      const index = draft.globals?.findIndex((variable2) => variable2.id === id) ?? -1;
+      if (index < 0)
+        throw new FlowError("GLOBAL_NOT_FOUND", `Unknown global ${id}.`);
+      const variable = update(draft.globals[index]);
+      if (variable.id !== id)
+        throw new FlowError(
+          "ID_CHANGE",
+          "Global ids cannot be changed by updateGlobal."
+        );
+      draft.globals[index] = variable;
+    });
+  }
+  removeGlobal(id) {
+    this.transaction("remove-global", (draft) => {
+      if (draft.globals)
+        draft.globals = draft.globals.filter((variable) => variable.id !== id);
+    });
+  }
+  updateNode(id, update) {
+    this.transaction("update-node", (draft) => {
+      const index = draft.nodes.findIndex((node) => node.id === id);
+      if (index < 0)
+        throw new FlowError("NODE_NOT_FOUND", `Unknown node ${id}.`);
+      const next = update(draft.nodes[index]);
+      if (next.id !== id)
+        throw new FlowError(
+          "ID_CHANGE",
+          "Node ids cannot be changed by updateNode."
+        );
+      draft.nodes[index] = next;
+    });
+  }
+  moveNode(id, position) {
+    this.updateNode(id, (node) => ({ ...node, position }));
+  }
+  removeNode(id) {
+    this.transaction("remove-node", (draft) => {
+      draft.nodes = draft.nodes.filter((node) => node.id !== id);
+      draft.edges = draft.edges.filter(
+        (edge) => edge.source !== id && edge.target !== id
+      );
+    });
+  }
+  addEdge(edge) {
+    assertJson(edge);
+    this.transaction("add-edge", (draft) => {
+      draft.edges.push(clone(edge));
+    });
+  }
+  updateEdge(id, update) {
+    this.transaction("update-edge", (draft) => {
+      const index = draft.edges.findIndex((edge) => edge.id === id);
+      if (index < 0)
+        throw new FlowError("EDGE_NOT_FOUND", `Unknown edge ${id}.`);
+      const next = update(draft.edges[index]);
+      if (next.id !== id)
+        throw new FlowError(
+          "ID_CHANGE",
+          "Edge ids cannot be changed by updateEdge."
+        );
+      draft.edges[index] = next;
+    });
+  }
+  removeEdge(id) {
+    this.transaction("remove-edge", (draft) => {
+      draft.edges = draft.edges.filter((edge) => edge.id !== id);
+    });
+  }
+  undo() {
+    this.guard();
+    const previous = this.past.pop();
+    if (!previous) return;
+    this.future.push(this.document);
+    this.document = previous;
+    this.emit("undo");
+  }
+  redo() {
+    this.guard();
+    const next = this.future.pop();
+    if (!next) return;
+    this.past.push(this.document);
+    this.document = next;
+    this.emit("redo");
+  }
+  guard() {
+    if (this.editing || this.notifying)
+      throw new FlowError(
+        "REENTRANT_EDIT",
+        "Nested edits and edits during notification are not supported."
+      );
+  }
+  emit(reason) {
+    this.revision++;
+    this.notifying = true;
+    try {
+      for (const listener of [...this.listeners]) {
+        try {
+          listener({
+            document: this.document,
+            reason,
+            revision: this.revision
+          });
+        } catch (error) {
+          try {
+            this.options.onListenerError?.(error);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      this.notifying = false;
+    }
+  }
+};
+
+// src/core/simulation.ts
+var FlowSimulator = class {
+  document;
+  state;
+  nextId = 1;
+  sequence = 0;
+  traceLimit;
+  maxTokens;
+  constructor(document, context = {}, options = {}) {
+    assertFlow(document, "executable");
+    this.checkContext(context);
+    this.traceLimit = options.traceLimit ?? 1e3;
+    this.maxTokens = options.maxTokens ?? 1e4;
+    if (!Number.isSafeInteger(this.traceLimit) || this.traceLimit < 0 || !Number.isSafeInteger(this.maxTokens) || this.maxTokens < 1) {
+      throw new FlowError(
+        "INVALID_LIMIT",
+        "traceLimit must be nonnegative and maxTokens positive integers."
+      );
+    }
+    this.document = freeze(clone(document));
+    this.state = {
+      status: "running",
+      context: clone(context),
+      tokens: [
+        {
+          id: this.id(),
+          nodeId: document.nodes.find((node) => node.type === "start").id,
+          status: "ready",
+          frames: []
+        }
+      ],
+      completedNodes: [],
+      traversedEdges: [],
+      events: [],
+      steps: 0
+    };
+  }
+  getSnapshot() {
+    return freeze(clone(this.state));
+  }
+  /** Process one ready token, using stable FIFO order. */
+  step() {
+    if (this.terminal()) return this.getSnapshot();
+    const token = this.state.tokens.find((item) => item.status === "ready");
+    if (!token) {
+      this.refresh();
+      return this.getSnapshot();
+    }
+    const node = this.document.nodes.find((item) => item.id === token.nodeId);
+    const outputs = this.document.edges.filter(
+      (edge) => edge.source === node.id
+    );
+    this.state.steps++;
+    this.event({ type: "entered", nodeId: node.id, tokenId: token.id });
+    if (node.type === "task" && node.mode === "async") {
+      token.status = "async";
+      this.event({ type: "waiting", nodeId: node.id, tokenId: token.id });
+    } else if (node.type === "wait") {
+      token.status = "signal";
+      this.event({
+        type: "waiting",
+        nodeId: node.id,
+        tokenId: token.id,
+        message: node.signal
+      });
+    } else if (node.type === "end") {
+      this.completed(token);
+      this.remove(token);
+    } else if (node.type === "decision") {
+      const edge = outputs.filter((item) => !item.default).sort(
+        (a, b) => (a.priority ?? 0) - (b.priority ?? 0) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+      ).find(
+        (item) => item.condition && evaluateCondition(item.condition, this.state.context)
+      ) ?? outputs.find((item) => item.default);
+      this.advance(token, edge);
+    } else if (node.type === "fork") {
+      if (this.state.tokens.length - 1 + outputs.length > this.maxTokens) {
+        this.failToken(token, "Active token limit exceeded.");
+      } else {
+        const group = this.id();
+        this.completed(token);
+        this.remove(token);
+        for (const edge of outputs) {
+          const child = {
+            id: this.id(),
+            nodeId: node.id,
+            status: "ready",
+            frames: [
+              ...clone(token.frames),
+              {
+                group,
+                fork: node.id,
+                join: node.join,
+                branch: edge.id,
+                expected: outputs.length
+              }
+            ]
+          };
+          this.state.tokens.push(child);
+          this.traverse(child, edge);
+        }
+      }
+    } else if (node.type === "join") {
+      const frame = token.frames.at(-1);
+      if (!frame || frame.join !== node.id || frame.fork !== node.fork) {
+        this.failToken(token, "Token reached a join outside its fork scope.");
+      } else {
+        token.status = "joining";
+        const siblings = this.state.tokens.filter(
+          (item) => item.nodeId === node.id && item.status === "joining" && item.frames.at(-1)?.group === frame.group
+        );
+        const branches = new Set(
+          siblings.map((item) => item.frames.at(-1).branch)
+        );
+        if (branches.size !== siblings.length)
+          this.failToken(
+            token,
+            "A parallel branch arrived at the join more than once."
+          );
+        else if (siblings.length === frame.expected) {
+          for (const sibling of siblings) this.remove(sibling);
+          token.frames.pop();
+          token.status = "ready";
+          this.state.tokens.push(token);
+          this.advance(token, outputs[0]);
+        } else
+          this.event({ type: "waiting", nodeId: node.id, tokenId: token.id });
+      }
+    } else this.advance(token, outputs[0]);
+    this.refresh();
+    return this.getSnapshot();
+  }
+  run(maxSteps = 1e3) {
+    if (!Number.isSafeInteger(maxSteps) || maxSteps < 1)
+      throw new FlowError(
+        "INVALID_LIMIT",
+        "maxSteps must be a positive integer."
+      );
+    for (let index = 0; index < maxSteps && this.state.status === "running"; index++)
+      this.step();
+    return {
+      reason: this.state.status === "running" ? "step-limit" : this.state.status,
+      snapshot: this.getSnapshot()
+    };
+  }
+  /** Complete one async activation, not every activation of the same node. */
+  complete(tokenId, patch = {}) {
+    return this.resume(tokenId, "async", patch);
+  }
+  /** External applications collect user input and explicitly deliver it here. */
+  signal(tokenId, signal, patch = {}) {
+    const token = this.findWaiting(tokenId, "signal");
+    const node = this.document.nodes.find((item) => item.id === token.nodeId);
+    if (node.type !== "wait" || node.signal !== signal)
+      throw new FlowError("SIGNAL_MISMATCH", `Unexpected signal ${signal}.`);
+    return this.resume(tokenId, "signal", patch);
+  }
+  fail(tokenId, message) {
+    if (this.terminal())
+      throw new FlowError(
+        "TERMINAL_SIMULATION",
+        "The simulation has finished."
+      );
+    const token = this.state.tokens.find((item) => item.id === tokenId);
+    if (!token)
+      throw new FlowError("TOKEN_NOT_FOUND", `Unknown token ${tokenId}.`);
+    this.failToken(token, message);
+    return this.getSnapshot();
+  }
+  cancel() {
+    if (!this.terminal()) {
+      this.state.status = "cancelled";
+      this.state.tokens = [];
+      this.event({ type: "cancelled" });
+    }
+    return this.getSnapshot();
+  }
+  resume(tokenId, status, patch) {
+    const token = this.findWaiting(tokenId, status);
+    this.checkContext(patch);
+    this.state.context = { ...this.state.context, ...clone(patch) };
+    this.advance(
+      token,
+      this.document.edges.find((edge) => edge.source === token.nodeId)
+    );
+    this.refresh();
+    return this.getSnapshot();
+  }
+  findWaiting(id, status) {
+    if (this.terminal())
+      throw new FlowError(
+        "TERMINAL_SIMULATION",
+        "The simulation has finished."
+      );
+    const token = this.state.tokens.find((item) => item.id === id);
+    if (!token || token.status !== status)
+      throw new FlowError(
+        "TOKEN_NOT_WAITING",
+        `Token ${id} is not waiting for ${status}.`
+      );
+    return token;
+  }
+  advance(token, edge) {
+    this.completed(token);
+    this.traverse(token, edge);
+    this.remove(token);
+    this.state.tokens.push(token);
+  }
+  traverse(token, edge) {
+    this.event({ type: "traversed", edgeId: edge.id, tokenId: token.id });
+    if (!this.state.traversedEdges.includes(edge.id))
+      this.state.traversedEdges.push(edge.id);
+    token.nodeId = edge.target;
+    token.status = "ready";
+  }
+  completed(token) {
+    if (!this.state.completedNodes.includes(token.nodeId))
+      this.state.completedNodes.push(token.nodeId);
+    this.event({ type: "completed", nodeId: token.nodeId, tokenId: token.id });
+  }
+  failToken(token, message) {
+    this.state.status = "failed";
+    this.state.error = message;
+    this.event({
+      type: "failed",
+      nodeId: token.nodeId,
+      tokenId: token.id,
+      message
+    });
+  }
+  remove(token) {
+    this.state.tokens = this.state.tokens.filter(
+      (item) => item.id !== token.id
+    );
+  }
+  id() {
+    return `t${this.nextId++}`;
+  }
+  terminal() {
+    return ["completed", "failed", "cancelled"].includes(this.state.status);
+  }
+  refresh() {
+    if (this.terminal()) return;
+    if (!this.state.tokens.length) this.state.status = "completed";
+    else if (this.state.tokens.some((token) => token.status === "ready"))
+      this.state.status = "running";
+    else if (this.state.tokens.every((token) => token.status === "joining")) {
+      this.failToken(this.state.tokens[0], "Parallel join deadlock.");
+    } else this.state.status = "waiting";
+  }
+  event(event) {
+    this.sequence++;
+    if (this.traceLimit) {
+      this.state.events.push({ ...event, sequence: this.sequence });
+      if (this.state.events.length > this.traceLimit) this.state.events.shift();
+    }
+  }
+  checkContext(context) {
+    assertJson(context);
+    if (!context || typeof context !== "object" || Array.isArray(context))
+      throw new FlowError("INVALID_CONTEXT", "Context must be a JSON object.");
+  }
+};
+
+// src/core/layout.ts
+function layoutFlow(document, options = {}) {
+  assertFlow(document);
+  const columnGap = options.columnGap ?? 220;
+  const rowGap = options.rowGap ?? 120;
+  if (!Number.isFinite(columnGap) || columnGap <= 0 || !Number.isFinite(rowGap) || rowGap <= 0)
+    throw new RangeError("Layout gaps must be positive finite numbers.");
+  const result = clone(document);
+  const levels = /* @__PURE__ */ new Map();
+  const queue = result.nodes.filter(
+    (node) => node.type === "start" || !result.edges.some((edge) => edge.target === node.id)
+  ).map((node) => node.id);
+  for (const id of queue) levels.set(id, 0);
+  for (let index = 0; index < queue.length; index++) {
+    const id = queue[index];
+    for (const edge of result.edges.filter((edge2) => edge2.source === id)) {
+      if (!levels.has(edge.target)) {
+        levels.set(edge.target, levels.get(id) + 1);
+        queue.push(edge.target);
+      }
+    }
+  }
+  let fallback = Math.max(0, ...levels.values()) + 1;
+  const rows = /* @__PURE__ */ new Map();
+  for (const node of result.nodes) {
+    const level = levels.get(node.id) ?? fallback++;
+    const row = rows.get(level) ?? 0;
+    rows.set(level, row + 1);
+    node.position = options.direction === "down" ? { x: 100 + row * columnGap, y: 80 + level * rowGap } : { x: 100 + level * columnGap, y: 80 + row * rowGap };
+  }
+  return result;
+}
+
+// src/core/performance.ts
+var finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+var text = (value) => typeof value === "string" && value.trim().length > 0;
+var uint64 = (value) => typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value) && value.length <= 20 && BigInt(value) <= 18446744073709551615n;
+var PerformanceTimeline = class {
+  runs = /* @__PURE__ */ new Map();
+  record(sample) {
+    assertJson(sample);
+    if (!sample || ![sample.runId, sample.nodeId, sample.commandId, sample.process].every(
+      text
+    ) || !finite(sample.startMs) || !finite(sample.durationMs) || !Number.isSafeInteger(sample.cost) || sample.cost < 0 || !Number.isFinite(sample.startMs + sample.durationMs))
+      throw new FlowError(
+        "INVALID_PERFORMANCE",
+        "Expected backend run identity, finite times and a nonnegative safe integer cost."
+      );
+    if (sample.network !== void 0 && (!Array.isArray(sample.network) || sample.network.some(
+      (item) => !item || !finite(item.startMs) || !finite(item.durationMs) || !Number.isFinite(item.startMs + item.durationMs) || !text(item.label) || item.bytes !== void 0 && !uint64(item.bytes)
+    )))
+      throw new FlowError(
+        "INVALID_PERFORMANCE",
+        "Invalid backend network interval."
+      );
+    if (sample.memory !== void 0 && (!Array.isArray(sample.memory) || sample.memory.some(
+      (item) => !item || !finite(item.timeMs) || !uint64(item.bytes)
+    )))
+      throw new FlowError(
+        "INVALID_PERFORMANCE",
+        "Invalid backend memory sample."
+      );
+    const previous = this.runs.get(sample.runId);
+    if (previous) {
+      if (!equal(previous, sample))
+        throw new FlowError(
+          "PERFORMANCE_CONFLICT",
+          "A node-run metric id cannot be reused with different data."
+        );
+      return false;
+    }
+    if (this.runs.size >= 1e4)
+      throw new FlowError(
+        "PERFORMANCE_LIMIT",
+        "Start a new performance view after 10000 node runs."
+      );
+    this.runs.set(sample.runId, freeze(clone(sample)));
+    return true;
+  }
+  getSnapshot() {
+    return freeze(clone([...this.runs.values()]));
+  }
+  clear() {
+    this.runs.clear();
+  }
+};
+
+export {
+  globalValueType,
+  flowCreationOrder,
+  orderedFlowItems,
+  FlowStore,
+  FlowSimulator,
+  layoutFlow,
+  PerformanceTimeline
+};

package/dist/chunk-LKOWNTPR.cjs

@@ -0,0 +1 @@
+"use strict";