@weasel-js/diagram 1.9.2 → 1.9.4

package/dist/index.js

@@ -1,11 +1,73 @@
-import { layered, portOf, outlinePath, diagramNodeOf, forceRelaxation, center, force, tree, portsOf, sizeToBody, measureBody, buildBody } from './chunk-UBM2J3HJ.js';
-export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, force, forceRelaxation, forestOf, graphOrder, isPinned, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree } from './chunk-UBM2J3HJ.js';
-import { dragPanContribution, WeaselProvider, useScene, useSelection, useLatest, reconcileSpecs, SceneCanvas, fitViewToBounds, AUTO_POSE_DESCRIPTOR, pointAlongPath, translatePoseViaDescriptor, polylineFromPoints, registerNodeShape, effectivePose, usePoseRun, RECT_POSE_DESCRIPTOR, composeAffordanceLayer } from '@weasel-js/core';
+import { insetOf, layered, portsOf, portOf, outlinePath, diagramNodeOf, expandGroupEdges, forceRelaxation, center, force, tree, DIAGRAM_TRAIT_KEY, DEFAULT_GROUP_INSET, sizeToBody, measureBody, buildBody } from './chunk-EDSBULQM.js';
+export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, expandGroupEdges, force, forceRelaxation, forestOf, graphOrder, insetOf, isPinned, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, packClusters, pinnedSet, portOf, portsOf, portsOnOutline, rankGaps, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree, untilSettled } from './chunk-EDSBULQM.js';
+import { dragPanContribution, WeaselProvider, useScene, useSelection, useLatest, reconcileSpecs, SceneCanvas, fitViewToBounds, AUTO_POSE_DESCRIPTOR, translatePoseViaDescriptor, pointAlongPath, polylineFromPoints, registerNodeShape, effectivePose, usePoseRun, RECT_POSE_DESCRIPTOR, commandFill, commandStroke, composeAffordanceLayer } from '@weasel-js/core';
 import { portCurvePoints } from '@weasel-js/geom';
 import { AUTO_POSE_DESCRIPTOR as AUTO_POSE_DESCRIPTOR$1 } from '@weasel-js/core/math';
 import { forwardRef, useEffect, useMemo, useRef, useState, useImperativeHandle, useCallback } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
+function traitOf(node) {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const trait = data[DIAGRAM_TRAIT_KEY];
+  return trait !== null && typeof trait === "object" ? trait : null;
+}
+function diagramGroupOf(node) {
+  const group = traitOf(node)?.group;
+  return group !== null && typeof group === "object" ? group : null;
+}
+function diagramAnchorOf(node) {
+  const anchor = traitOf(node)?.anchor;
+  return anchor !== null && typeof anchor === "object" && "at" in anchor ? anchor : null;
+}
+function groupDerivePose(opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  return (node, deps) => {
+    const group = diagramGroupOf(node);
+    if (group === null) return null;
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const dep of deps) {
+      if (dep === void 0) continue;
+      const b = geometry.getBounds(dep.pose);
+      x0 = Math.min(x0, b.x);
+      y0 = Math.min(y0, b.y);
+      x1 = Math.max(x1, b.x + b.width);
+      y1 = Math.max(y1, b.y + b.height);
+    }
+    if (!Number.isFinite(x0)) return null;
+    const inset = insetOf(group.inset);
+    return geometry.fromBounds(
+      {
+        x: x0 - inset.left,
+        y: y0 - inset.top,
+        width: x1 - x0 + inset.left + inset.right,
+        height: y1 - y0 + inset.top + inset.bottom
+      },
+      node.pose
+    );
+  };
+}
+function anchorDerivePose(opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  return (node, deps) => {
+    const anchor = diagramAnchorOf(node);
+    const dep = deps[0];
+    if (anchor === null || dep === void 0) return null;
+    const target = geometry.getBounds(dep.pose);
+    const own = geometry.getBounds(node.pose);
+    const self = anchor.self ?? anchor.at;
+    const x = target.x + anchor.at.u * target.width + (anchor.offset?.x ?? 0) - self.u * own.width;
+    const y = target.y + anchor.at.v * target.height + (anchor.offset?.y ?? 0) - self.v * own.height;
+    return translatePoseViaDescriptor(node.pose, x - own.x, y - own.y, geometry);
+  };
+}
+var DIAGRAM_GROUP = "diagram:group";
+var DIAGRAM_ANCHOR = "diagram:anchor";
+var GROUP_DERIVE_POSE = groupDerivePose();
+var ANCHOR_DERIVE_POSE = anchorDerivePose();
 var NAMED = { start: 0, mid: 0.5, end: 1 };
 function diagramLabelOf(node) {
   const data = node.data;
@@ -41,6 +103,23 @@ function labelDerivePose(opts = {}) {
 var DIAGRAM_LABEL = "diagram:label";
 var LABEL_DERIVE_POSE = labelDerivePose();
 
+// src/selfLoop.ts
+var dot = (a, b) => a.x * b.x + a.y * b.y;
+function selfLoop(ports, standoff) {
+  const facing = ports.filter((p) => p.normal !== null);
+  const most = (dir, among) => among.reduce(
+    (best, p) => best === void 0 || dot(p.normal, dir) > dot(best.normal, dir) ? p : best,
+    void 0
+  );
+  const from = most({ x: 1, y: 0 }, facing);
+  if (from === void 0) return null;
+  const to = most({ x: 0, y: -1 }, facing.filter((p) => Math.abs(dot(p.normal, from.normal)) < 0.5));
+  if (to === void 0) return null;
+  const out = { x: from.point.x + from.normal.x * standoff, y: from.point.y + from.normal.y * standoff };
+  const reach = dot({ x: to.point.x - out.x, y: to.point.y - out.y }, to.normal) + standoff;
+  return { from, to, via: { x: out.x + to.normal.x * reach, y: out.y + to.normal.y * reach } };
+}
+
 // src/edge.ts
 var straight = (req) => [req.from.point, ...req.waypoints, req.to.point];
 var orthogonal = (req) => {
@@ -61,12 +140,15 @@ var orthogonal = (req) => {
       out.push(b);
       continue;
     }
+    const prev = out.length > 1 ? out[out.length - 2] : null;
     if (leaveHorizontal) {
       const mid = (a.x + b.x) / 2;
-      out.push({ x: mid, y: a.y }, { x: mid, y: b.y }, b);
+      if (prev !== null && (mid - a.x) * (a.x - prev.x) < 0) out.push({ x: a.x, y: b.y }, b);
+      else out.push({ x: mid, y: a.y }, { x: mid, y: b.y }, b);
     } else {
       const mid = (a.y + b.y) / 2;
-      out.push({ x: a.x, y: mid }, { x: b.x, y: mid }, b);
+      if (prev !== null && (mid - a.y) * (a.y - prev.y) < 0) out.push({ x: b.x, y: a.y }, b);
+      else out.push({ x: a.x, y: mid }, { x: b.x, y: mid }, b);
     }
   }
   return out;
@@ -136,17 +218,24 @@ function edgeDerivePath(opts = {}) {
     const b = geometry.getBounds(d.pose);
     return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
   };
+  const standoffOf = (d) => {
+    const b = geometry.getBounds(d.pose);
+    return Math.min(b.width, b.height) / 2;
+  };
   return (node, deps) => {
     const edge = diagramEdgeOf(node);
     if (edge === null) return null;
     const [fromDep, toDep] = deps;
     if (fromDep === void 0 || toDep === void 0) return null;
-    const from = resolveEnd(edge.from, fromDep, centerOf(toDep), portOpts, allPorts);
-    const to = resolveEnd(edge.to, toDep, centerOf(fromDep), portOpts, allPorts);
+    const loop = fromDep.node.id === toDep.node.id && edge.from.port === void 0 && edge.to.port === void 0 ? selfLoop(allPorts(fromDep), opts.selfLoopStandoff ?? standoffOf(fromDep)) : null;
+    const from = loop?.from ?? resolveEnd(edge.from, fromDep, centerOf(toDep), portOpts, allPorts);
+    const to = loop?.to ?? resolveEnd(edge.to, toDep, centerOf(fromDep), portOpts, allPorts);
     if (from === void 0 || to === void 0) return null;
+    const authored = edge.waypoints ?? [];
+    const waypoints = loop !== null && authored.length === 0 ? [loop.via] : authored;
     const routers = opts.routers ?? ROUTERS;
     const router = edge.router !== void 0 && routers[edge.router] || straight;
-    const points = router({ from, to, waypoints: edge.waypoints ?? [] });
+    const points = router({ from, to, waypoints });
     return points.length < 2 ? null : polylineFromPoints(points);
   };
 }
@@ -161,6 +250,8 @@ function withDiagramRegistry(registry = {}) {
     },
     derivePose: {
       [DIAGRAM_LABEL]: LABEL_DERIVE_POSE,
+      [DIAGRAM_GROUP]: GROUP_DERIVE_POSE,
+      [DIAGRAM_ANCHOR]: ANCHOR_DERIVE_POSE,
       ...registry.derivePose
     }
   };
@@ -398,11 +489,64 @@ function diagramPorts(opts) {
     contribution: createDiagramContribution(opts)
   };
 }
+
+// src/groupTree.ts
+function nestGroups(declared, isNode) {
+  const groupIds = new Set(declared.map((g) => g.id));
+  const parentOf = /* @__PURE__ */ new Map();
+  const claimedNodes = /* @__PURE__ */ new Set();
+  const direct = /* @__PURE__ */ new Map();
+  const isAncestorOrSelf = (candidate, of) => {
+    for (let at = of; at !== void 0; at = parentOf.get(at)) {
+      if (at === candidate) return true;
+    }
+    return false;
+  };
+  for (const group of declared) {
+    const own = [];
+    for (const id of group.members) {
+      if (isNode(id)) {
+        if (claimedNodes.has(id)) continue;
+        claimedNodes.add(id);
+        own.push(id);
+      } else if (groupIds.has(id) && !parentOf.has(id) && !isAncestorOrSelf(id, group.id)) {
+        parentOf.set(id, group.id);
+        own.push(id);
+      }
+    }
+    direct.set(group.id, own);
+  }
+  const flat = /* @__PURE__ */ new Map();
+  const flatten = (id) => {
+    const known = flat.get(id);
+    if (known !== void 0) return known;
+    const out = [];
+    for (const member of direct.get(id)) {
+      if (groupIds.has(member)) out.push(...flatten(member));
+      else out.push(member);
+    }
+    flat.set(id, out);
+    return out;
+  };
+  const live = new Set(declared.filter((g) => flatten(g.id).length > 0).map((g) => g.id));
+  return declared.filter((g) => live.has(g.id)).map((g) => {
+    const parent = parentOf.get(g.id);
+    return {
+      id: g.id,
+      direct: direct.get(g.id).filter((id) => !groupIds.has(id) || live.has(id)),
+      members: flat.get(g.id),
+      ...parent !== void 0 ? { parent } : {}
+    };
+  });
+}
+
+// src/graph.ts
 function buildGraph(source, opts = {}) {
   const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR$1;
   const nodes = [];
   const byId = /* @__PURE__ */ new Map();
   const candidates = [];
+  const groupNodes = [];
   for (const { node, pose } of source()) {
     if (diagramEdgeOf(node) !== null) {
       const deps = node.dependsOn;
@@ -413,6 +557,15 @@ function buildGraph(source, opts = {}) {
     }
     const trait = diagramNodeOf(node, opts.read);
     if (trait === null) continue;
+    if (trait.group !== void 0) {
+      const deps = node.dependsOn;
+      groupNodes.push({
+        id: node.id,
+        members: Array.isArray(deps) ? deps : [],
+        inset: insetOf(trait.group.inset)
+      });
+      continue;
+    }
     const entry = {
       id: node.id,
       bounds: geometry.getBounds(pose),
@@ -421,7 +574,21 @@ function buildGraph(source, opts = {}) {
     nodes.push(entry);
     byId.set(entry.id, entry);
   }
-  const edges = candidates.filter((e) => byId.has(e.from) && byId.has(e.to));
+  const insets = new Map(groupNodes.map((g) => [g.id, g.inset]));
+  const live = nestGroups(groupNodes, (id) => byId.has(id)).map((g) => {
+    for (const id of g.direct) {
+      const node = byId.get(id);
+      if (node !== void 0) node.group = g.id;
+    }
+    return {
+      id: g.id,
+      members: g.members,
+      inset: insets.get(g.id),
+      ...g.parent !== void 0 ? { parent: g.parent } : {}
+    };
+  });
+  const known = (id) => byId.has(id) || live.some((g) => g.id === id);
+  const edges = expandGroupEdges(candidates.filter((e) => known(e.from) && known(e.to)), live);
   const out = /* @__PURE__ */ new Map();
   const into = /* @__PURE__ */ new Map();
   for (const edge of edges) {
@@ -432,6 +599,7 @@ function buildGraph(source, opts = {}) {
   return {
     nodes,
     edges,
+    groups: live,
     node: (id) => byId.get(id),
     outgoing: (id) => out.get(id) ?? NONE,
     incoming: (id) => into.get(id) ?? NONE
@@ -443,17 +611,106 @@ function push(index, key, edge) {
   else list.push(edge);
 }
 
+// src/dataGroups.ts
+function resolveGroups(groups, ids, nodeIds, opts) {
+  for (const group of groups) {
+    if (ids.has(group.id)) throw new Error(`diagramScene: group id "${group.id}" is already a node or group id`);
+    ids.add(group.id);
+  }
+  const declared = new Map(groups.map((g) => [g.id, g]));
+  const nested = nestGroups(groups, (id) => nodeIds.has(id));
+  const depthOf = /* @__PURE__ */ new Map();
+  const byId = new Map(nested.map((g) => [g.id, g]));
+  const depth = (id) => {
+    const parent = byId.get(id).parent;
+    let d = depthOf.get(id);
+    if (d === void 0) depthOf.set(id, d = parent === void 0 ? 0 : depth(parent) + 1);
+    return d;
+  };
+  return nested.map((g, i) => ({ g, i })).sort((a, b) => depth(a.g.id) - depth(b.g.id) || a.i - b.i).map(({ g }) => {
+    const group = declared.get(g.id);
+    const pad = group.padding ?? opts.padding;
+    const title = group.label ? opts.title(group.label) : null;
+    const inset = { top: pad + (title ? title.height + pad / 2 : 0), right: pad, bottom: pad, left: pad };
+    return {
+      group,
+      direct: g.direct,
+      members: g.members,
+      inset,
+      pad,
+      title,
+      ...g.parent !== void 0 ? { parent: g.parent } : {}
+    };
+  });
+}
+function groupSpecs(groups, placedAt, styleOf) {
+  const byId = new Map(groups.map((g) => [g.group.id, g]));
+  const boxes = /* @__PURE__ */ new Map();
+  const boxOf = (id) => {
+    const known = boxes.get(id);
+    if (known !== void 0) return known;
+    const g = byId.get(id);
+    const rs = g.direct.map((m) => byId.has(m) ? boxOf(m) : placedAt.get(m));
+    const x = Math.min(...rs.map((r) => r.x)) - g.inset.left;
+    const y = Math.min(...rs.map((r) => r.y)) - g.inset.top;
+    const box = {
+      x,
+      y,
+      width: Math.max(...rs.map((r) => r.x + r.width)) + g.inset.right - x,
+      height: Math.max(...rs.map((r) => r.y + r.height)) + g.inset.bottom - y
+    };
+    boxes.set(id, box);
+    return box;
+  };
+  const specs = [];
+  for (const g of groups) {
+    const { style, text } = styleOf(g.group);
+    const { x, y, width, height } = boxOf(g.group.id);
+    specs.push({
+      id: g.group.id,
+      kind: "leaf",
+      layer: "main",
+      pose: { x, y, width, height },
+      data: {
+        diagram: { outline: "rect", group: { inset: g.inset } },
+        fill: { color: style.fill },
+        stroke: {
+          paint: { color: style.stroke },
+          width: style.strokeWidth ?? 1,
+          ...style.dash ? { dash: style.dash } : {}
+        }
+      },
+      dependsOn: g.direct,
+      derivePose: GROUP_DERIVE_POSE
+    });
+    if (g.title === null || !g.group.label) continue;
+    const anchor = { at: { u: 0, v: 0 }, offset: { x: g.pad, y: g.pad } };
+    specs.push({
+      id: `${g.group.id}/label`,
+      kind: "leaf",
+      layer: "main",
+      pickable: false,
+      pose: { x: x + g.pad, y: y + g.pad, width: g.title.width, height: g.title.height },
+      data: { diagram: { anchor }, text: g.group.label, style: text, fill: { color: style.text } },
+      dependsOn: [g.group.id],
+      derivePose: ANCHOR_DERIVE_POSE
+    });
+  }
+  return specs;
+}
+
 // src/fromData.ts
 var FONT = { fontFamily: "sans-serif", fontSize: 12 };
 var NODE = { fill: "#16222c", stroke: "#7ba7c7", text: "#dbe7f2" };
 var EDGE = { stroke: "#7ba7c7" };
+var GROUP = { fill: "rgba(123, 167, 199, 0.08)", stroke: "#7ba7c7", text: "#9fbdd6", strokeWidth: 1, dash: [4, 3] };
 var LABEL_PLACEMENT = { at: "mid", offset: 9 };
 var LINE = 1.4;
 var GLYPH = 0.6;
 var MIN_WIDTH = 64;
 var LAYOUTS = { layered, tree, force };
 var edgeIdOf = (e) => `edge:${e.from}${e.fromPort ? `.${e.fromPort}` : ""}->${e.to}${e.toPort ? `.${e.toPort}` : ""}${e.label ? `:${e.label}` : ""}`;
-function graphOf(nodes, edges) {
+function graphOf(nodes, edges, groups = []) {
   const byId = new Map(nodes.map((n) => [n.id, n]));
   const out = /* @__PURE__ */ new Map();
   const inc = /* @__PURE__ */ new Map();
@@ -464,6 +721,7 @@ function graphOf(nodes, edges) {
   return {
     nodes,
     edges,
+    groups,
     node: (id) => byId.get(id),
     outgoing: (id) => out.get(id) ?? [],
     incoming: (id) => inc.get(id) ?? []
@@ -485,6 +743,12 @@ function diagramScene(data, opts = {}) {
     if (ids.has(n.id)) throw new Error(`diagramScene: node id "${n.id}" appears more than once`);
     ids.add(n.id);
   }
+  const nodeIds = new Set(ids);
+  const titleStyle = { ...font, fontSize: font.fontSize - 1 };
+  const groups = resolveGroups(data.groups ?? [], ids, nodeIds, {
+    padding: opts.groupPadding ?? DEFAULT_GROUP_INSET,
+    title: (text) => measure(text, titleStyle)
+  });
   const seen = /* @__PURE__ */ new Set();
   const edges = data.edges.filter((e) => {
     const id = edgeIdOf(e);
@@ -507,13 +771,39 @@ function diagramScene(data, opts = {}) {
     );
     return { id: n.id, bounds: pose, pinned: n.pinned === true };
   });
-  const graph = graphOf(seeds, edges.map((e) => ({ id: edgeIdOf(e), from: e.from, to: e.to })));
+  const graphGroups = groups.map((g) => ({
+    id: g.group.id,
+    members: g.members,
+    inset: g.inset,
+    ...g.parent !== void 0 ? { parent: g.parent } : {}
+  }));
+  const seedOf = new Map(seeds.map((n) => [n.id, n]));
+  for (const g of groups) {
+    for (const m of g.direct) {
+      const seed = seedOf.get(m);
+      if (seed !== void 0) seed.group = g.group.id;
+    }
+  }
+  const graph = graphOf(
+    seeds,
+    expandGroupEdges(edges.map((e) => ({ id: edgeIdOf(e), from: e.from, to: e.to })), graphGroups),
+    graphGroups
+  );
   const layout = typeof opts.layout === "function" ? opts.layout : opts.layout === "none" ? null : LAYOUTS[opts.layout ?? "layered"];
   const moved = layout === null ? /* @__PURE__ */ new Map() : layout(graph, { order: "barycenter", ...opts.layoutOptions });
   const specs = [];
-  for (const [i, n] of data.nodes.entries()) {
+  const placedAt = new Map(data.nodes.map((n, i) => {
     const seed = seeds[i].bounds;
     const at = moved.get(n.id) ?? seed;
+    return [n.id, { x: at.x, y: at.y, width: seed.width, height: seed.height }];
+  }));
+  specs.push(...groupSpecs(groups, placedAt, (g) => ({
+    style: opts.groupStyle?.(g) ?? GROUP,
+    text: styleOf(titleStyle)
+  })));
+  for (const [i, n] of data.nodes.entries()) {
+    const seed = seeds[i].bounds;
+    const at = placedAt.get(n.id);
     const style = opts.nodeStyle?.(n) ?? NODE;
     const textData = (text, s) => ({ text, style: styleOf(s), fill: { color: style.text } });
     const built = buildBody(
@@ -829,11 +1119,14 @@ function diagramShape(opts = {}) {
       const outline = outlineOf(node);
       if (outline === void 0) return [];
       const d = node.data;
-      const fill = d.fill === void 0 ? opts.defaultFill : d.fill;
-      const stroke = d.stroke === void 0 ? opts.defaultStroke : d.stroke;
+      const box = geometry.getBounds(pose);
+      const declaredFill = d.fill === void 0 ? opts.defaultFill : d.fill;
+      const declaredStroke = d.stroke === void 0 ? opts.defaultStroke : d.stroke;
+      const fill = declaredFill && commandFill(declaredFill, box);
+      const stroke = declaredStroke && commandStroke(declaredStroke, box);
       return [{
         kind: "path",
-        path: outlinePath(outline, geometry.getBounds(pose)),
+        path: outlinePath(outline, box),
         ...fill ? { fill } : {},
         ...stroke ? { stroke } : {}
       }];
@@ -874,6 +1167,7 @@ function Inner({
   onSelect,
   onMove,
   onConnect,
+  enableKeybindings,
   canConnect,
   portOptions,
   live: liveOpts,
@@ -972,6 +1266,7 @@ function Inner({
       scene,
       selection,
       features: onMove ? ["view", "pick", "move"] : ["view", "pick"],
+      enableKeybindings: enableKeybindings ?? (onMove !== void 0 || onConnect !== void 0),
       ambient,
       onClick,
       width,
@@ -985,7 +1280,7 @@ function Inner({
   );
 }
 function fitDiagram(specs, size, fit = {}) {
-  const boxes = specs.filter((s) => s.kind === "container").map((s) => s.pose);
+  const boxes = specs.filter((s) => s.kind === "container" || diagramGroupOf(s) !== null).map((s) => s.pose);
   if (boxes.length === 0) return void 0;
   const x = Math.min(...boxes.map((b) => b.x));
   const y = Math.min(...boxes.map((b) => b.y));
@@ -1003,6 +1298,6 @@ function fitDiagram(specs, size, fit = {}) {
   });
 }
 
-export { CONNECT_ACTION_ID, DEFAULT_EDGE_STROKE, DIAGRAM_EDGE, DIAGRAM_LABEL, DiagramView, EASED_LAYOUTS, EDGE_DERIVE_PATH, GRAB_PORT_ACTION_ID, LABEL_DERIVE_POSE, LAYOUTS2 as LAYOUTS, LAYOUT_ACTION_ID, PORT_AFFORDANCE_KIND, PORT_LAYER_ID, ROUTERS, applyLayout, bezier, buildGraph, commitEdgeToScene, connectBinding, createConnectAction, createDiagramContribution, createLayoutAction, createPortAffordance, defaultCanConnect, diagramEdgeOf, diagramLabelOf, diagramPorts, diagramScene, diagramShape, easedProducer, edgeDerivePath, edgeIdOf, forceProducer, grabPortAction, grabPortBindings, labelDerivePose, layoutPoses, orthogonal, portLayer, portScratchOf, registerDiagramShape, resolveEnd, sceneParticipants, straight, useLiveLayout, useMirroredSelection, withDiagramRegistry };
+export { ANCHOR_DERIVE_POSE, CONNECT_ACTION_ID, DEFAULT_EDGE_STROKE, DIAGRAM_ANCHOR, DIAGRAM_EDGE, DIAGRAM_GROUP, DIAGRAM_LABEL, DiagramView, EASED_LAYOUTS, EDGE_DERIVE_PATH, GRAB_PORT_ACTION_ID, GROUP_DERIVE_POSE, LABEL_DERIVE_POSE, LAYOUTS2 as LAYOUTS, LAYOUT_ACTION_ID, PORT_AFFORDANCE_KIND, PORT_LAYER_ID, ROUTERS, anchorDerivePose, applyLayout, bezier, buildGraph, commitEdgeToScene, connectBinding, createConnectAction, createDiagramContribution, createLayoutAction, createPortAffordance, defaultCanConnect, diagramAnchorOf, diagramEdgeOf, diagramGroupOf, diagramLabelOf, diagramPorts, diagramScene, diagramShape, easedProducer, edgeDerivePath, edgeIdOf, forceProducer, grabPortAction, grabPortBindings, groupDerivePose, labelDerivePose, layoutPoses, orthogonal, portLayer, portScratchOf, registerDiagramShape, resolveEnd, sceneParticipants, selfLoop, straight, useLiveLayout, useMirroredSelection, withDiagramRegistry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map