@ankhorage/zora 22.1.1 → 22.1.3

package/web-dist/components/graph-view/GraphView.js

@@ -122375,82 +122375,35 @@ var EVENT_TYPES = [
   ["mouseout", "pointer-leave"]
 ];
 
-// node_modules/@ankhorage/utility/dist/algorithms/findMinimumAcceptedNumber.js
-var DEFAULT_ITERATIONS = 16;
-var MAX_ITERATIONS = 64;
-function findMinimumAcceptedNumber(input) {
-  validateInput(input);
-  const { accepts, maximum, minimum } = input;
-  const iterations = input.iterations ?? DEFAULT_ITERATIONS;
-  if (accepts(minimum))
-    return minimum;
-  if (!accepts(maximum))
-    return;
-  return searchAcceptedBoundary(minimum, maximum, iterations, accepts);
-}
-function searchAcceptedBoundary(minimum, maximum, iterations, accepts) {
-  let lower = minimum;
-  let upper = maximum;
-  for (let iteration = 0;iteration < iterations; iteration += 1) {
-    const midpoint = lower + (upper - lower) / 2;
-    if (midpoint === lower || midpoint === upper)
-      break;
-    if (accepts(midpoint))
-      upper = midpoint;
-    else
-      lower = midpoint;
-  }
-  return upper;
-}
-function validateInput(input) {
-  const iterations = input.iterations ?? DEFAULT_ITERATIONS;
-  if (!Number.isFinite(input.minimum) || !Number.isFinite(input.maximum)) {
-    throw new RangeError("Search bounds must be finite numbers.");
-  }
-  if (input.minimum > input.maximum) {
-    throw new RangeError("Search minimum must not exceed maximum.");
-  }
-  if (!Number.isInteger(iterations) || iterations < 0 || iterations > MAX_ITERATIONS) {
-    throw new RangeError(`Search iterations must be an integer from 0 to ${MAX_ITERATIONS}.`);
-  }
-}
-// src/features/graph-view/adapters/inbound/web-artifact/compactGraphSpacing.ts
-var LABEL_OVERLAP_RATIO = 0.12;
-var MAX_EXPANSION_ATTEMPTS = 8;
-var MAX_NODE_COUNT = 2000;
+// src/features/graph-view/adapters/inbound/web-artifact/createGraphSpacingEvaluator.ts
 var MAX_PAIR_CHECKS = 200000;
-var SEARCH_ITERATIONS = 8;
-function compactGraphSpacing(cy, spacingFactor) {
+function createGraphSpacingEvaluator(cy, options = {}) {
   const leaves = cy.nodes(":childless");
-  if (leaves.length < 2 || cy.nodes().length > MAX_NODE_COUNT || cy.nodes(":locked").length > 0)
-    return spacingFactor;
-  const bounds = leaves.boundingBox();
-  const center = { x: (bounds.x1 + bounds.x2) / 2, y: (bounds.y1 + bounds.y2) / 2 };
+  const viewport = { width: cy.width(), height: cy.height() };
+  if (leaves.length < 2 || viewport.width <= 0 || viewport.height <= 0)
+    return null;
+  const leafBounds = leaves.boundingBox();
+  const center = {
+    x: (leafBounds.x1 + leafBounds.x2) / 2,
+    y: (leafBounds.y1 + leafBounds.y2) / 2
+  };
   const leafGeometry = leaves.map(readLeafGeometry);
-  const groups = cy.nodes(":parent").map((node) => readGroupGeometry(node.id(), node.ancestors().map((parent) => parent.id()), node.boundingBox(), leafGeometry));
-  const accepts = (factor) => !hasUnsafeCollisions(resolveCollisionBoxes(leafGeometry, groups, center, factor));
-  const currentAccepted = accepts(1);
-  const minimum = currentAccepted ? Math.min(1, 0.1 / spacingFactor) : 1;
-  const maximum = currentAccepted ? 1 : findExpansionMaximum(accepts);
-  if (maximum === undefined)
-    return spacingFactor;
-  const factor = findMinimumAcceptedNumber({
-    minimum,
-    maximum,
-    iterations: SEARCH_ITERATIONS,
-    accepts
-  });
-  if (factor === undefined)
-    return spacingFactor;
-  applyScale(cy, leafGeometry, center, factor);
-  return spacingFactor * factor;
+  const context = {
+    center,
+    fitPadding: Math.max(0, options.fitPadding ?? 50),
+    leaves: leafGeometry,
+    groups: cy.nodes(":parent").map((node) => readGroupGeometry(node, leafGeometry)),
+    maxFitZoom: positiveNumber(options.maxFitZoom, Infinity),
+    viewport
+  };
+  return {
+    evaluate: (factor) => evaluateSpacingCandidate(context, factor),
+    apply: (factor) => applyScale(cy, leafGeometry, center, factor)
+  };
 }
 function readLeafGeometry(node) {
-  const nodeBox = node.boundingBox({
-    includeLabels: true,
-    includeOverlays: false,
-    includeUnderlays: false
-  });
+  const fitBox = readNodeBox(node, true);
+  const visualBox = readNodeBox(node, false);
   const labelBox = node.boundingBox({
     includeNodes: false,
     includeEdges: false,
@@ -122462,17 +122415,28 @@ function readLeafGeometry(node) {
     id: node.id(),
     ancestors: new Set(node.ancestors().map((parent) => parent.id())),
     position: { ...node.position() },
-    labelBox: isUsableBox(labelBox) ? labelBox : nodeBox,
-    nodeBox
+    fitBox,
+    labelBox: isUsableBox(labelBox) ? labelBox : null,
+    visualBox: isUsableBox(visualBox) ? visualBox : fitBox
   };
 }
-function readGroupGeometry(id, ancestorIds, parentBox, leaves) {
-  const descendants = leaves.filter((leaf) => leaf.ancestors.has(id));
-  const descendantUnion = unionBounds(descendants.map((leaf) => leaf.nodeBox)) ?? parentBox;
+function readNodeBox(node, includeLabels) {
+  return node.boundingBox({
+    includeNodes: true,
+    includeEdges: false,
+    includeLabels,
+    includeOverlays: false,
+    includeUnderlays: false
+  });
+}
+function readGroupGeometry(node, leaves) {
+  const descendants = leaves.filter((leaf) => leaf.ancestors.has(node.id()));
+  const parentBox = readNodeBox(node, true);
+  const descendantUnion = unionBounds(descendants.map((leaf) => leaf.fitBox)) ?? parentBox;
   return {
-    id,
-    ancestors: new Set(ancestorIds),
-    descendants,
+    id: node.id(),
+    ancestors: new Set(node.ancestors().map((parent) => parent.id())),
+    descendantIds: descendants.map((leaf) => leaf.id),
     insets: {
       left: Math.max(0, descendantUnion.x1 - parentBox.x1),
       right: Math.max(0, parentBox.x2 - descendantUnion.x2),
@@ -122481,78 +122445,104 @@ function readGroupGeometry(id, ancestorIds, parentBox, leaves) {
     }
   };
 }
-function resolveCollisionBoxes(leaves, groups, center, factor) {
-  const labels = leaves.map((leaf) => ({
+function evaluateSpacingCandidate(context, factor) {
+  const leaves = context.leaves.map((leaf) => resolveLeafGeometry(leaf, context.center, factor));
+  const byId = new Map(leaves.map((leaf) => [leaf.id, leaf]));
+  const groups = context.groups.flatMap((group) => resolveGroupBox(group, byId));
+  const fitBounds = unionBounds([
+    ...leaves.map((leaf) => leaf.fitBox),
+    ...groups.map((group) => group.box)
+  ]);
+  const rawFitZoom = fitBounds === undefined ? 1 : getFitZoom(fitBounds, context);
+  const effectiveFitZoom = Math.min(rawFitZoom, context.maxFitZoom);
+  return {
+    effectiveFitZoom,
+    ...readCollisionState(createCollisionBoxes(leaves, groups), effectiveFitZoom)
+  };
+}
+function resolveLeafGeometry(leaf, center, factor) {
+  return {
     id: leaf.id,
     ancestors: leaf.ancestors,
-    kind: "label",
-    box: shiftBounds(leaf.labelBox, leaf.position, center, factor)
-  }));
-  const compoundBoxes = groups.flatMap((group) => {
-    const descendants = group.descendants.map((leaf) => shiftBounds(leaf.nodeBox, leaf.position, center, factor));
-    const union = unionBounds(descendants);
-    if (!union)
-      return [];
-    return [
-      {
-        id: group.id,
-        ancestors: group.ancestors,
-        kind: "group",
-        box: expandBounds(union, group.insets)
-      }
-    ];
+    fitBox: shiftBounds(leaf.fitBox, leaf.position, center, factor),
+    labelBox: leaf.labelBox === null ? null : shiftBounds(leaf.labelBox, leaf.position, center, factor),
+    visualBox: shiftBounds(leaf.visualBox, leaf.position, center, factor)
+  };
+}
+function resolveGroupBox(group, leaves) {
+  const descendantBounds = group.descendantIds.flatMap((id) => {
+    const leaf = leaves.get(id);
+    return leaf === undefined ? [] : [leaf.fitBox];
   });
-  return [...labels, ...compoundBoxes];
+  const union = unionBounds(descendantBounds);
+  return union === undefined ? [] : [
+    {
+      id: group.id,
+      ancestors: group.ancestors,
+      kind: "group",
+      box: expandBounds(union, group.insets)
+    }
+  ];
 }
-function findExpansionMaximum(accepts) {
-  return Array.from({ length: MAX_EXPANSION_ATTEMPTS }, (_, index) => 2 ** (index + 1)).find(accepts);
+function createCollisionBoxes(leaves, groups) {
+  return [
+    ...leaves.flatMap((leaf) => leaf.labelBox === null ? [] : [{ id: leaf.id, ancestors: leaf.ancestors, kind: "label", box: leaf.labelBox }]),
+    ...leaves.map((leaf) => ({
+      id: leaf.id,
+      ancestors: leaf.ancestors,
+      kind: "visual",
+      box: leaf.visualBox
+    })),
+    ...groups
+  ];
 }
-function hasUnsafeCollisions(boxes) {
+function readCollisionState(boxes, zoom) {
   const sorted = [...boxes].sort((first, second) => first.box.x1 - second.box.x1);
   const budget = { remaining: MAX_PAIR_CHECKS };
+  const overlap = { maximum: 0 };
   for (const [index, first] of sorted.entries()) {
     for (let next = index + 1;next < sorted.length; next += 1) {
       const second = sorted.at(next);
-      if (!second)
+      if (second === undefined)
         break;
       if (second.box.x1 >= first.box.x2)
         break;
+      if (first.id === second.id || isIntentionalContainment(first, second))
+        continue;
+      const penetration = getOverlapPenetration(first.box, second.box);
+      if (penetration <= 0)
+        continue;
       budget.remaining -= 1;
       if (budget.remaining < 0)
-        return true;
-      if (isIntentionalContainment(first, second))
+        return { hardCollision: true, renderedBackgroundOverlap: Infinity };
+      if (first.kind === "visual" && second.kind === "visual") {
+        overlap.maximum = Math.max(overlap.maximum, penetration * zoom);
         continue;
-      if (isUnsafeOverlap(first, second))
-        return true;
+      }
+      return { hardCollision: true, renderedBackgroundOverlap: overlap.maximum };
     }
   }
-  return false;
+  return { hardCollision: false, renderedBackgroundOverlap: overlap.maximum };
 }
 function isIntentionalContainment(first, second) {
   return first.ancestors.has(second.id) || second.ancestors.has(first.id);
 }
-function isUnsafeOverlap(first, second) {
-  const overlapWidth = Math.min(first.box.x2, second.box.x2) - Math.max(first.box.x1, second.box.x1);
-  const overlapHeight = Math.min(first.box.y2, second.box.y2) - Math.max(first.box.y1, second.box.y1);
-  if (overlapWidth <= 0 || overlapHeight <= 0)
-    return false;
-  if (first.kind !== "label" || second.kind !== "label")
-    return true;
-  const widthRatio = overlapWidth / Math.min(first.box.w, second.box.w);
-  const heightRatio = overlapHeight / Math.min(first.box.h, second.box.h);
-  return widthRatio > LABEL_OVERLAP_RATIO && heightRatio > LABEL_OVERLAP_RATIO;
+function getOverlapPenetration(first, second) {
+  const width = Math.min(first.x2, second.x2) - Math.max(first.x1, second.x1);
+  const height = Math.min(first.y2, second.y2) - Math.max(first.y1, second.y1);
+  return width > 0 && height > 0 ? Math.min(width, height) : 0;
+}
+function getFitZoom(bounds, context) {
+  const width = context.viewport.width - 2 * context.fitPadding;
+  const height = context.viewport.height - 2 * context.fitPadding;
+  if (width <= 0 || height <= 0 || bounds.w <= 0 || bounds.h <= 0)
+    return 1;
+  return Math.min(width / bounds.w, height / bounds.h);
 }
 function shiftBounds(box, position, center, factor) {
   const dx = (position.x - center.x) * (factor - 1);
   const dy = (position.y - center.y) * (factor - 1);
-  return {
-    x1: box.x1 + dx,
-    y1: box.y1 + dy,
-    x2: box.x2 + dx,
-    y2: box.y2 + dy,
-    w: box.w,
-    h: box.h
-  };
+  return { ...box, x1: box.x1 + dx, y1: box.y1 + dy, x2: box.x2 + dx, y2: box.y2 + dy };
 }
 function expandBounds(box, insets) {
   const x1 = box.x1 - insets.left;
@@ -122573,6 +122563,9 @@ function unionBounds(boxes) {
 function isUsableBox(box) {
   return box.w > 0 && box.h > 0;
 }
+function positiveNumber(value, fallback) {
+  return value !== undefined && Number.isFinite(value) && value > 0 ? value : fallback;
+}
 function applyScale(cy, leaves, center, factor) {
   const positions = new Map(leaves.map((leaf) => [leaf.id, leaf.position]));
   cy.batch(() => {
@@ -122586,6 +122579,114 @@ function applyScale(cy, leaves, center, factor) {
   });
 }
 
+// src/features/graph-view/adapters/inbound/web-artifact/compactGraphSpacing.ts
+var MAX_EXPANSION_ATTEMPTS = 8;
+var MAX_NODE_COUNT = 2000;
+var MAX_RENDERED_BACKGROUND_OVERLAP = 4;
+var SEARCH_ITERATIONS = 8;
+var ZERO_TOLERANCE = 0.001;
+function compactGraphSpacing(cy, spacingFactor, options = {}) {
+  if (spacingFactor <= 0 || cy.nodes(":childless").length < 2 || cy.nodes().length > MAX_NODE_COUNT || cy.nodes(":locked").length > 0)
+    return spacingFactor;
+  const evaluator = createGraphSpacingEvaluator(cy, options);
+  if (evaluator === null)
+    return spacingFactor;
+  const current = evaluator.evaluate(1);
+  const maxFitZoom = options.maxFitZoom ?? Infinity;
+  const minReadableZoom = options.minReadableZoom ?? 0;
+  const factor = needsExpansion(current) ? chooseExpansionFactor(evaluator.evaluate, minReadableZoom) : chooseCompactionFactor(evaluator.evaluate, spacingFactor, maxFitZoom, minReadableZoom, current);
+  if (factor === 1)
+    return spacingFactor;
+  evaluator.apply(factor);
+  return spacingFactor * factor;
+}
+function chooseCompactionFactor(evaluate, spacingFactor, maxFitZoom, minReadableZoom, current) {
+  if (reachesFitTarget(current, maxFitZoom))
+    return 1;
+  const minimum = Math.min(1, 0.1 / spacingFactor);
+  if (current.renderedBackgroundOverlap > ZERO_TOLERANCE) {
+    if (reachesReadableTarget(current, minReadableZoom))
+      return 1;
+    return chooseSoftCompactionFactor(evaluate, minimum, 1, minReadableZoom);
+  }
+  const strictMinimum = findMinimumAcceptedFactor(minimum, 1, (factor) => isStrictCandidate(evaluate(factor)));
+  if (strictMinimum === undefined)
+    return 1;
+  const strict = evaluate(strictMinimum);
+  if (reachesFitTarget(strict, maxFitZoom)) {
+    return findMaximumAcceptedFactor(strictMinimum, 1, (factor) => {
+      const candidate = evaluate(factor);
+      return isStrictCandidate(candidate) && reachesFitTarget(candidate, maxFitZoom);
+    }) ?? strictMinimum;
+  }
+  if (reachesReadableTarget(strict, minReadableZoom))
+    return strictMinimum;
+  return chooseSoftCompactionFactor(evaluate, minimum, strictMinimum, minReadableZoom);
+}
+function chooseSoftCompactionFactor(evaluate, minimum, maximum, minReadableZoom) {
+  const softMinimum = findMinimumAcceptedFactor(minimum, maximum, (factor) => isSoftCandidate(evaluate(factor)));
+  if (softMinimum === undefined)
+    return maximum;
+  const soft = evaluate(softMinimum);
+  if (!reachesReadableTarget(soft, minReadableZoom))
+    return softMinimum;
+  return findMaximumAcceptedFactor(softMinimum, maximum, (factor) => {
+    const candidate = evaluate(factor);
+    return isSoftCandidate(candidate) && reachesReadableTarget(candidate, minReadableZoom);
+  }) ?? softMinimum;
+}
+function chooseExpansionFactor(evaluate, minReadableZoom) {
+  const strict = findExpansionFactor((factor) => isStrictCandidate(evaluate(factor)));
+  if (strict !== undefined && reachesReadableTarget(evaluate(strict), minReadableZoom))
+    return strict;
+  return findExpansionFactor((factor) => isSoftCandidate(evaluate(factor))) ?? strict ?? 1;
+}
+function isStrictCandidate(candidate) {
+  return !candidate.hardCollision && candidate.renderedBackgroundOverlap <= ZERO_TOLERANCE;
+}
+function isSoftCandidate(candidate) {
+  return !candidate.hardCollision && candidate.renderedBackgroundOverlap <= MAX_RENDERED_BACKGROUND_OVERLAP + ZERO_TOLERANCE;
+}
+function needsExpansion(candidate) {
+  return candidate.hardCollision || !isSoftCandidate(candidate);
+}
+function reachesFitTarget(candidate, maxFitZoom) {
+  if (!Number.isFinite(maxFitZoom))
+    return false;
+  return candidate.effectiveFitZoom >= maxFitZoom - ZERO_TOLERANCE;
+}
+function reachesReadableTarget(candidate, minReadableZoom) {
+  return minReadableZoom <= 0 || candidate.effectiveFitZoom >= minReadableZoom - ZERO_TOLERANCE;
+}
+function findMinimumAcceptedFactor(minimum, maximum, accepts) {
+  if (!accepts(maximum))
+    return;
+  if (accepts(minimum))
+    return minimum;
+  return Array.from({ length: SEARCH_ITERATIONS }).reduce((range) => {
+    const factor = (range.low + range.high) / 2;
+    return accepts(factor) ? { low: range.low, high: factor } : { low: factor, high: range.high };
+  }, { low: minimum, high: maximum }).high;
+}
+function findMaximumAcceptedFactor(minimum, maximum, accepts) {
+  if (!accepts(minimum))
+    return;
+  if (accepts(maximum))
+    return maximum;
+  return Array.from({ length: SEARCH_ITERATIONS }).reduce((range) => {
+    const factor = (range.low + range.high) / 2;
+    return accepts(factor) ? { low: factor, high: range.high } : { low: range.low, high: factor };
+  }, { low: minimum, high: maximum }).low;
+}
+function findExpansionFactor(accepts) {
+  if (accepts(1))
+    return 1;
+  const maximum = Array.from({ length: MAX_EXPANSION_ATTEMPTS }, (_, index) => 2 ** (index + 1)).find(accepts);
+  if (maximum === undefined)
+    return;
+  return findMinimumAcceptedFactor(maximum / 2, maximum, accepts);
+}
+
 // src/features/graph-view/adapters/inbound/web-artifact/fitGraphViewport.ts
 function fitGraphViewport(cy, options = {}, maxZoom = Infinity) {
   if (cy.destroyed())
@@ -122661,6 +122762,12 @@ function createGraphController(cy, fitPaddingRef, optimizeFit) {
         state.scale = 1;
       applyZoomLimits(cy, state);
     },
+    getFitZoomLimit() {
+      return state.relative ? state.fitZoom : Math.min(state.fitZoom, state.max);
+    },
+    getReadableZoomTarget() {
+      return state.readableZoom;
+    },
     settle(fit) {
       const logicalZoom = cy.zoom() / state.scale;
       const fonts = cy.nodes().filter((node) => !node.isParent() && Boolean(node.style("label"))).map((node) => Number.parseFloat(String(node.style("font-size")))).filter((size) => Number.isFinite(size) && size > 0);
@@ -123379,7 +123486,11 @@ function requestOptimizedFit(state, options) {
   if (!input)
     return;
   const previous = state.optimizedSpacingRef.current ?? input.spacingFactor ?? 1;
-  const spacing = compactGraphSpacing(state.cy, previous);
+  const spacing = compactGraphSpacing(state.cy, previous, {
+    fitPadding: options.padding ?? state.fitPaddingRef.current,
+    maxFitZoom: state.viewport.getFitZoomLimit(),
+    minReadableZoom: state.viewport.getReadableZoomTarget()
+  });
   state.geometryRef.current = getGraphGeometryKey(state.cy);
   state.loopSizer.update();
   state.viewport.settle(false);

package/web-dist/components/graph-view/GraphView.types-0.d.ts

@@ -54,7 +54,10 @@ export interface GraphViewViewport {
     readonly pan: GraphViewPoint;
 }
 export interface GraphViewFitOptions {
-    /** Optimize existing layout spacing without rerunning its algorithm; whole-graph fits only. */
+    /**
+     * Optimize effective rendered fit without rerunning the layout algorithm; whole-graph fits only.
+     * Stops at the configured fit-size target and keeps semantic labels collision-safe.
+     */
     readonly optimizeSpacing?: boolean;
     readonly nodeIds?: readonly string[];
     readonly padding?: number;