ooxml-core 1.4.0 → 1.6.0

package/dist/geometry/index.cjs

@@ -15478,11 +15478,11 @@ function createRotationDrag(center, startPointer, startRotation, options = {}) {
 
 // geometry/rotate-handle-placement.ts
 function resolveRotateHandlePlacement(input) {
-  const { preferred, selection, bounds, hitWidth, hitHeight, obstacles } = input;
+  const { preferred, selection, bounds: bounds2, hitWidth, hitHeight, obstacles } = input;
   if (![
     ...Object.values(preferred),
     ...Object.values(selection),
-    ...Object.values(bounds),
+    ...Object.values(bounds2),
     hitWidth,
     hitHeight
   ].every(Number.isFinite) || hitWidth <= 0 || hitHeight <= 0) {
@@ -15496,7 +15496,7 @@ function resolveRotateHandlePlacement(input) {
   };
   const fits = ({ x, y }) => {
     const rect2 = { left: x - halfX, right: x + halfX, top: y - halfY, bottom: y + halfY };
-    return rect2.left >= bounds.left + 1 && rect2.right <= bounds.right - 1 && rect2.top >= bounds.top + 1 && rect2.bottom <= bounds.bottom - 1 && // A target over the rotation center has no usable initial bearing.
+    return rect2.left >= bounds2.left + 1 && rect2.right <= bounds2.right - 1 && rect2.top >= bounds2.top + 1 && rect2.bottom <= bounds2.bottom - 1 && // A target over the rotation center has no usable initial bearing.
     !(center.x >= rect2.left && center.x <= rect2.right && center.y >= rect2.top && center.y <= rect2.bottom) && !obstacles.some(
       (other) => rect2.left < other.right + 2 && rect2.right > other.left - 2 && rect2.top < other.bottom + 2 && rect2.bottom > other.top - 2
     );
@@ -15524,10 +15524,10 @@ function resolveRotateHandlePlacement(input) {
     { x: center.x, y: selection.bottom + padY },
     { x: selection.left - padX, y: center.y }
   ];
-  const left = Math.max(selection.left, bounds.left) + halfX + 3;
-  const right = Math.min(selection.right, bounds.right) - halfX - 3;
-  const top = Math.max(selection.top, bounds.top) + halfY + 3;
-  const bottom = Math.min(selection.bottom, bounds.bottom) - halfY - 3;
+  const left = Math.max(selection.left, bounds2.left) + halfX + 3;
+  const right = Math.min(selection.right, bounds2.right) - halfX - 3;
+  const top = Math.max(selection.top, bounds2.top) + halfY + 3;
+  const bottom = Math.min(selection.bottom, bounds2.bottom) - halfY - 3;
   if (left <= right && top <= bottom) {
     for (const fraction of [0.25, 0.75]) {
       const x = left + (right - left) * fraction;
@@ -15541,6 +15541,357 @@ function resolveRotateHandlePlacement(input) {
   })[0] ?? null;
 }
 
+// geometry/graph-layout.ts
+var GRAPH_LAYOUT_STYLES = [
+  "flowchart-tb",
+  "flowchart-lr",
+  "hierarchy",
+  "compact-tree",
+  "circular"
+];
+function components(graph) {
+  const seen = /* @__PURE__ */ new Set();
+  const connected = [];
+  const isolated = [];
+  for (const node of graph.nodes) {
+    if (seen.has(node.id)) continue;
+    const ids = [];
+    const stack = [node.id];
+    seen.add(node.id);
+    while (stack.length) {
+      const id = stack.pop();
+      ids.push(id);
+      for (const next of [...graph.out.get(id), ...graph.into.get(id)])
+        if (!seen.has(next)) {
+          seen.add(next);
+          stack.push(next);
+        }
+    }
+    if (ids.length === 1) isolated.push(node.id);
+    else {
+      const order = new Map(graph.nodes.map((entry, index) => [entry.id, index]));
+      connected.push(ids.sort((a, b) => order.get(a) - order.get(b)));
+    }
+  }
+  return { connected, isolated };
+}
+function roots(ids, graph) {
+  const found = ids.filter((id) => !graph.into.get(id).some((from) => ids.includes(from)));
+  return found.length ? found : [ids[0]];
+}
+function forwardEdges(ids, graph) {
+  const state = /* @__PURE__ */ new Map();
+  const forward = new Map(ids.map((id) => [id, []]));
+  const visit = (start) => {
+    const stack = [{ id: start, next: 0 }];
+    state.set(start, 1);
+    while (stack.length) {
+      const top = stack.at(-1);
+      const targets = graph.out.get(top.id);
+      if (top.next >= targets.length) {
+        state.set(top.id, 2);
+        stack.pop();
+        continue;
+      }
+      const target = targets[top.next++];
+      const mark = state.get(target);
+      if (mark === 1) continue;
+      forward.get(top.id).push(target);
+      if (mark === void 0) {
+        state.set(target, 1);
+        stack.push({ id: target, next: 0 });
+      }
+    }
+  };
+  for (const root of roots(ids, graph)) if (!state.has(root)) visit(root);
+  for (const id of ids) if (!state.has(id)) visit(id);
+  return forward;
+}
+function layers(ids, forward, shortest) {
+  const rank = /* @__PURE__ */ new Map();
+  const incoming = new Map(ids.map((id) => [id, 0]));
+  for (const targets of forward.values())
+    for (const target of targets) incoming.set(target, incoming.get(target) + 1);
+  const queue = ids.filter((id) => incoming.get(id) === 0);
+  for (const id of queue) rank.set(id, 0);
+  for (let index = 0; index < queue.length; index++) {
+    const id = queue[index];
+    for (const target of forward.get(id)) {
+      const candidate = rank.get(id) + 1;
+      if (shortest) {
+        if (!rank.has(target)) rank.set(target, candidate);
+      } else rank.set(target, Math.max(rank.get(target) ?? 0, candidate));
+      incoming.set(target, incoming.get(target) - 1);
+      if (incoming.get(target) === 0) queue.push(target);
+    }
+  }
+  const result = [];
+  for (const id of ids) {
+    const level = rank.get(id) ?? 0;
+    (result[level] ??= []).push(id);
+  }
+  return result.filter((layer) => layer.length);
+}
+function orderLayers(layered, graph) {
+  const result = layered.map((layer) => [...layer]);
+  const position = /* @__PURE__ */ new Map();
+  const index = () => result.forEach((layer) => layer.forEach((id, at2) => position.set(id, at2)));
+  index();
+  for (let sweep = 0; sweep < 4; sweep++) {
+    const down = sweep % 2 === 0;
+    const range = down ? result.map((_, at2) => at2).slice(1) : result.map((_, at2) => at2).slice(0, -1).reverse();
+    for (const at2 of range) {
+      const neighbour = new Set(result[down ? at2 - 1 : at2 + 1]);
+      const weight = (id) => {
+        const linked = [...graph.out.get(id), ...graph.into.get(id)].filter(
+          (other) => neighbour.has(other)
+        );
+        return linked.length ? linked.reduce((sum, other) => sum + position.get(other), 0) / linked.length : position.get(id);
+      };
+      const weights = new Map(result[at2].map((id) => [id, weight(id)]));
+      result[at2].sort(
+        (a, b) => weights.get(a) - weights.get(b) || position.get(a) - position.get(b)
+      );
+      index();
+    }
+  }
+  return result;
+}
+function placeLayers(ordered, size, horizontal, spacing, layerSpacing) {
+  const placed = [];
+  const along = (node) => horizontal ? node.width : node.height;
+  const across = (node) => horizontal ? node.height : node.width;
+  let cursor = 0;
+  for (const layer of ordered) {
+    const nodes = layer.map((id) => size.get(id));
+    const depth = Math.max(...nodes.map(along));
+    const span = nodes.reduce((sum, node) => sum + across(node), 0) + spacing * (nodes.length - 1);
+    let offset = -span / 2;
+    for (const node of nodes) {
+      const centre = offset + across(node) / 2;
+      const primary = cursor + depth / 2;
+      placed.push({
+        id: node.id,
+        x: horizontal ? primary : centre,
+        y: horizontal ? centre : primary,
+        width: node.width,
+        height: node.height
+      });
+      offset += across(node) + spacing;
+    }
+    cursor += depth + layerSpacing;
+  }
+  return placed;
+}
+function placeCompactTree(ids, forward, graph, size, spacing, layerSpacing) {
+  const placed = [];
+  const seen = /* @__PURE__ */ new Set();
+  const indent = Math.max(...ids.map((id) => size.get(id).width)) / 2 + layerSpacing / 2;
+  let y = 0;
+  const visit = (start) => {
+    const stack = [{ id: start, depth: 0 }];
+    while (stack.length) {
+      const { id, depth } = stack.pop();
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const node = size.get(id);
+      placed.push({
+        id,
+        x: depth * indent + node.width / 2,
+        y: y + node.height / 2,
+        width: node.width,
+        height: node.height
+      });
+      y += node.height + spacing;
+      const children = forward.get(id).filter((child) => !seen.has(child));
+      for (const child of children.reverse()) stack.push({ id: child, depth: depth + 1 });
+    }
+  };
+  for (const root of roots(ids, graph)) visit(root);
+  for (const id of ids) visit(id);
+  return placed;
+}
+function placeCircle(ids, forward, size, spacing) {
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const start of ids) {
+    const stack = [start];
+    while (stack.length) {
+      const id = stack.pop();
+      if (seen.has(id)) continue;
+      seen.add(id);
+      order.push(id);
+      stack.push(...[...forward.get(id)].reverse());
+    }
+  }
+  const extent = (id) => Math.hypot(size.get(id).width, size.get(id).height);
+  const circumference = order.reduce((sum, id) => sum + extent(id) + spacing, 0);
+  const radius = Math.max(circumference / (2 * Math.PI), Math.max(...order.map(extent)));
+  return order.map((id, index) => {
+    const angle = -Math.PI / 2 + 2 * Math.PI * index / order.length;
+    const node = size.get(id);
+    return {
+      id,
+      x: radius * Math.cos(angle),
+      y: radius * Math.sin(angle),
+      width: node.width,
+      height: node.height
+    };
+  });
+}
+function bounds(placed) {
+  const left = Math.min(...placed.map((box) => box.x - box.width / 2));
+  const top = Math.min(...placed.map((box) => box.y - box.height / 2));
+  const right = Math.max(...placed.map((box) => box.x + box.width / 2));
+  const bottom = Math.max(...placed.map((box) => box.y + box.height / 2));
+  return { left, top, width: right - left, height: bottom - top };
+}
+function placeGrid(ids, size, spacing) {
+  const columns = Math.ceil(Math.sqrt(ids.length));
+  const cellWidth = Math.max(...ids.map((id) => size.get(id).width));
+  const cellHeight = Math.max(...ids.map((id) => size.get(id).height));
+  return ids.map((id, index) => ({
+    id,
+    x: index % columns * (cellWidth + spacing) + cellWidth / 2,
+    y: Math.floor(index / columns) * (cellHeight + spacing) + cellHeight / 2,
+    width: size.get(id).width,
+    height: size.get(id).height
+  }));
+}
+function layoutGraph(nodes, edges, style, options = {}) {
+  if (!GRAPH_LAYOUT_STYLES.includes(style)) throw new Error("Unknown graph layout style.");
+  const spacing = options.spacing ?? 0.5;
+  const layerSpacing = options.layerSpacing ?? spacing;
+  if (![spacing, layerSpacing].every((value) => Number.isFinite(value) && value >= 0))
+    throw new Error("Layout spacing must be finite and not negative.");
+  const size = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (size.has(node.id)) throw new Error("Layout node IDs must be unique.");
+    if (![node.width, node.height].every((value) => Number.isFinite(value) && value >= 0))
+      throw new Error("Layout node sizes must be finite and not negative.");
+    size.set(node.id, node);
+  }
+  const graph = {
+    nodes,
+    out: new Map(nodes.map((node) => [node.id, []])),
+    into: new Map(nodes.map((node) => [node.id, []]))
+  };
+  for (const edge of edges) {
+    if (!size.has(edge.from) || !size.has(edge.to) || edge.from === edge.to) continue;
+    if (graph.out.get(edge.from).includes(edge.to)) continue;
+    graph.out.get(edge.from).push(edge.to);
+    graph.into.get(edge.to).push(edge.from);
+  }
+  const { connected, isolated } = components(graph);
+  const horizontal = style === "flowchart-lr";
+  const blocks = connected.map((ids) => {
+    const forward = forwardEdges(ids, graph);
+    if (style === "circular") return placeCircle(ids, forward, size, spacing);
+    if (style === "compact-tree")
+      return placeCompactTree(ids, forward, graph, size, spacing, layerSpacing);
+    const ordered = orderLayers(layers(ids, forward, style === "hierarchy"), graph);
+    return placeLayers(ordered, size, horizontal, spacing, layerSpacing);
+  });
+  const result = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  let extent = 0;
+  for (const block of blocks) {
+    const box = bounds(block);
+    for (const item of block)
+      result.set(item.id, {
+        x: item.x - box.left + (horizontal ? 0 : cursor),
+        y: item.y - box.top + (horizontal ? cursor : 0)
+      });
+    cursor += (horizontal ? box.height : box.width) + spacing * 2;
+    extent = Math.max(extent, horizontal ? box.width : box.height);
+  }
+  if (isolated.length) {
+    const grid = placeGrid(isolated, size, spacing);
+    const offset = blocks.length ? extent + layerSpacing * 2 : 0;
+    for (const item of grid)
+      result.set(item.id, {
+        x: item.x + (horizontal ? offset : 0),
+        y: item.y + (horizontal ? 0 : offset)
+      });
+  }
+  return result;
+}
+
+// geometry/auto-align.ts
+var median = (values) => {
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+function clusters(boxes, centre, tolerance) {
+  const sorted = [...boxes].sort((a, b) => centre(a) - centre(b));
+  const result = [];
+  let mean = 0;
+  for (const box of sorted) {
+    const current = result.at(-1);
+    if (current && Math.abs(centre(box) - mean) <= tolerance) {
+      current.push(box);
+      mean += (centre(box) - mean) / current.length;
+    } else {
+      result.push([box]);
+      mean = centre(box);
+    }
+  }
+  return result;
+}
+function space(groups, start, size, minimumGap) {
+  const extents = groups.map((group) => {
+    const centre = group.reduce((sum, box) => sum + start(box) + size(box) / 2, 0) / group.length;
+    const half = Math.max(...group.map((box) => size(box) / 2));
+    return { centre, half };
+  });
+  const gaps = extents.slice(1).map(
+    (extent, index) => extent.centre - extent.half - extents[index].centre - extents[index].half
+  );
+  const gap = Math.max(
+    minimumGap,
+    gaps.length ? gaps.reduce((sum, value) => sum + value, 0) / gaps.length : 0
+  );
+  const result = /* @__PURE__ */ new Map();
+  let cursor = extents[0] ? extents[0].centre - extents[0].half : 0;
+  groups.forEach((group, index) => {
+    const { half } = extents[index];
+    for (const box of group) result.set(box.id, cursor + half);
+    cursor += half * 2 + gap;
+  });
+  return result;
+}
+function autoAlignBoxes(boxes, options = {}) {
+  if (new Set(boxes.map((box) => box.id)).size !== boxes.length)
+    throw new Error("Auto align box IDs must be unique.");
+  if (!boxes.every(
+    (box) => [box.x, box.y, box.width, box.height].every((value) => Number.isFinite(value))
+  ))
+    throw new Error("Auto align boxes must be finite.");
+  const result = /* @__PURE__ */ new Map();
+  if (!boxes.length) return result;
+  const toleranceX = options.tolerance?.x ?? median(boxes.map((box) => box.width)) / 2;
+  const toleranceY = options.tolerance?.y ?? median(boxes.map((box) => box.height)) / 2;
+  const minimumGap = options.minimumGap ?? 0;
+  const rows = clusters(boxes, (box) => box.y + box.height / 2, toleranceY);
+  const columns = clusters(boxes, (box) => box.x + box.width / 2, toleranceX);
+  const ys = space(
+    rows,
+    (box) => box.y,
+    (box) => box.height,
+    minimumGap
+  );
+  const xs = space(
+    columns,
+    (box) => box.x,
+    (box) => box.width,
+    minimumGap
+  );
+  for (const box of boxes)
+    result.set(box.id, { x: xs.get(box.id) - box.width / 2, y: ys.get(box.id) - box.height / 2 });
+  return result;
+}
+
 exports.ACTION_BUTTON_CONNECTION_SITES = ACTION_BUTTON_CONNECTION_SITES;
 exports.ACTION_BUTTON_PRESET_DEFINITIONS = ACTION_BUTTON_PRESET_DEFINITIONS;
 exports.ACTION_BUTTON_TEXT_RECTS = ACTION_BUTTON_TEXT_RECTS;
@@ -15576,6 +15927,7 @@ exports.FLOWCHART_CONNECTION_SITES = FLOWCHART_CONNECTION_SITES;
 exports.FLOWCHART_PRESET_DEFINITIONS = FLOWCHART_PRESET_DEFINITIONS;
 exports.FLOWCHART_TEXT_RECTS = FLOWCHART_TEXT_RECTS;
 exports.GEAR9_CONNECTION_SITES = GEAR9_CONNECTION_SITES;
+exports.GRAPH_LAYOUT_STYLES = GRAPH_LAYOUT_STYLES;
 exports.IDENTITY_AFFINE = IDENTITY_AFFINE;
 exports.LEFT_CIRCULAR_ARROW_CONNECTION_SITES = LEFT_CIRCULAR_ARROW_CONNECTION_SITES;
 exports.LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES = LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES;
@@ -15612,6 +15964,7 @@ exports._internalForTests = _internalForTests;
 exports.alignElements = alignElements;
 exports.angleToRadians = angleToRadians;
 exports.at = at;
+exports.autoAlignBoxes = autoAlignBoxes;
 exports.buildCalloutLeaderLineSvgPath = buildCalloutLeaderLineSvgPath;
 exports.clipPolygons = clipPolygons;
 exports.combineShapes = combineShapes;
@@ -15661,6 +16014,7 @@ exports.isCalloutShape = isCalloutShape;
 exports.isConvex = isConvex;
 exports.isHorizontalPrimaryAxis = isHorizontalPrimaryAxis;
 exports.isStShapeType = isStShapeType;
+exports.layoutGraph = layoutGraph;
 exports.lineIntersection = lineIntersection;
 exports.lookupPresetConnectionSites = lookupPresetConnectionSites;
 exports.lookupPresetTextRectOverride = lookupPresetTextRectOverride;

package/dist/geometry/index.d.ts

@@ -83,4 +83,6 @@ export * from './snap-guides.js';
 export * from './align-distribute.js';
 export * from './rotation-drag.js';
 export * from './rotate-handle-placement.js';
+export * from './graph-layout.js';
+export * from './auto-align.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0CAA0C,CAAC;AACzD,cAAc,yCAAyC,CAAC;AACxD,cAAc,uCAAuC,CAAC;AACtD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,kCAAkC,CAAC;AACjD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,qCAAqC,CAAC;AACpD,cAAc,iCAAiC,CAAC;AAChD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qDAAqD,CAAC;AACpE,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,qDAAqD,CAAC;AACpE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wCAAwC,CAAC;AACvD,cAAc,oDAAoD,CAAC;AACnE,cAAc,kCAAkC,CAAC;AACjD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AAEnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../geometry/index.ts"],"names":[],"mappings":"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"}