ooxml-core 0.21.2 → 0.22.0

package/dist/geometry/index.mjs

@@ -15085,4 +15085,310 @@ function flattenSvgPath(d, curveSegments = 16) {
   return loops;
 }
 
-export { ACTION_BUTTON_CONNECTION_SITES, ACTION_BUTTON_PRESET_DEFINITIONS, ACTION_BUTTON_TEXT_RECTS, ANGLE_SCALE, ARROW_CALLOUT_CONNECTION_SITES, ARROW_CALLOUT_PRESET_DEFINITIONS, ARROW_CONNECTION_SITES, ARROW_PRESET_DEFINITIONS, ARROW_TEXT_RECTS, BASIC_SHAPE_CONNECTION_SITES_A, BASIC_SHAPE_CONNECTION_SITES_B, BRACE_CONNECTION_SITES, BRACE_TEXT_RECTS, CALLOUT_CONNECTION_SITES, CALLOUT_TEXT_RECTS, CARDINAL_SITES, CHART_MARK_PRESET_DEFINITIONS, CIRCULAR_ARROW_CONNECTION_SITES, CIRCULAR_ARROW_TEXT_RECTS, CLIP_PATHS_CORE, CLIP_PATHS_EXTENDED, CLOUD_CALLOUT_PRESET_DEFINITIONS, CLOUD_CALLOUT_TAIL_COUNT, CLOUD_LOBE_COUNT, COM_AVLST_GROUND_TRUTH, CONNECTORS_BRACKETS_PRESET_DEFINITIONS, CURVED_ARROWS_CONNECTORS_PRESET_DEFINITIONS, CURVED_ARROW_CONNECTION_SITES, EPSILON, EXACT_CURVED_ARROW_PRESET_DEFINITIONS, EXTENDED_SHAPE_DEFINITIONS, FLOWCHART_CONNECTION_SITES, FLOWCHART_PRESET_DEFINITIONS, FLOWCHART_TEXT_RECTS, GEAR9_CONNECTION_SITES, LEFT_CIRCULAR_ARROW_CONNECTION_SITES, LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES, MATH_SYMBOL_CONNECTION_SITES, MISC_ARROW_CONNECTION_SITES, MISC_PRESET_DEFINITIONS, MISC_SHAPE_CONNECTION_SITES, MISC_TEXT_RECTS_A, MISC_TEXT_RECTS_B, POLYGON_CONNECTION_SITES, POLYGON_TEXT_RECTS, PRESET_GEOMETRY_ALIASES, PRESET_SHAPE_CATEGORY_LABELS, PRESET_SHAPE_CLIP_PATHS, PRESET_SHAPE_DEFINITIONS, PRESET_SHAPE_GEOMETRY_TABLE, PRIMARY_SHAPE_DEFINITIONS, QUAD_CONNECTION_SITES, QUAD_TEXT_RECTS, RECTS_SNIPS_PRESET_DEFINITIONS, RECT_VARIANT_CONNECTION_SITES, REFINED_ARROW_PRESET_DEFINITIONS, RIBBON_CONNECTION_SITES, RIBBON_TEXT_RECTS, SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS, STAR_CONNECTION_SITES, STAR_TEXT_RECTS, ST_SHAPE_TYPE_VALUES, TABS_DECORATIONS_PRESET_DEFINITIONS, TAB_CONNECTION_SITES, TAB_TEXT_RECTS, _internalForTests, angleToRadians, at, buildCalloutLeaderLineSvgPath, clipPolygons, combineShapes, computeUnionWalk, convexHull, createBuiltinVariables, cross2, cxn, dedupPoly, elbowCurveSegments, elbowWaypoints, ensureCCW, ensureCW, evaluateFormula, evaluateGuides, findAllIntersections, flattenSvgPath, fmtNum, fragmentShapes, gd, gear6, gear9, getAdjustmentAwareClipPath, getCalloutLeaderLineGeometry, getCalloutTier, getCalloutViewBoxBounds, getCloudCalloutClipPath, getCloudClipPath, getPresetConnectionSites, getPresetShapeClipPath, getPresetTextRect, insertIntersections, intersectPolygons, intersectShapes, intersectSvgPaths, isCalloutShape, isConvex, isHorizontalPrimaryAxis, isStShapeType, lineIntersection, lookupPresetConnectionSites, lookupPresetTextRectOverride, mergeOverlappingPolygons, mergeShapes, normalizeStShapeType, parseAdjustmentValues, parseFormula, parseGuideDefinitions, pointInPolygon, pointInTriangle, polygonArea, polygonsToSvgPath, resolveCoordinate, resolveOperand, segmentIntersection, signedArea, subtractPolygons, subtractShapes, subtractSvgPaths, sutherlandHodgman, svgPathToPolygons, triangulate, unionPolygons, unionShapes, unionSvgPaths, vec2Eq };
+// geometry/snap-guides.ts
+var SNAP_THRESHOLD = 6;
+function computeSnapToShape(dragX, dragY, dragW, dragH, siblings, draggedIds, guides, threshold = SNAP_THRESHOLD) {
+  let bestDx = Infinity;
+  let bestDy = Infinity;
+  let snapX = dragX;
+  let snapY = dragY;
+  const lines = [];
+  const dragCx = dragX + dragW / 2;
+  const dragCy = dragY + dragH / 2;
+  const dragRight = dragX + dragW;
+  const dragBottom = dragY + dragH;
+  const hRefs = [dragX, dragCx, dragRight];
+  const vRefs = [dragY, dragCy, dragBottom];
+  for (const sib of siblings) {
+    if (draggedIds.has(sib.id)) {
+      continue;
+    }
+    const sibCx = sib.x + sib.width / 2;
+    const sibCy = sib.y + sib.height / 2;
+    const sibRight = sib.x + sib.width;
+    const sibBottom = sib.y + sib.height;
+    for (const ref of [sib.x, sibCx, sibRight]) {
+      for (const hr of hRefs) {
+        const dx = Math.abs(ref - hr);
+        if (dx < threshold && dx < bestDx) {
+          bestDx = dx;
+          snapX = dragX + (ref - hr);
+        }
+      }
+    }
+    for (const ref of [sib.y, sibCy, sibBottom]) {
+      for (const vr of vRefs) {
+        const dy = Math.abs(ref - vr);
+        if (dy < threshold && dy < bestDy) {
+          bestDy = dy;
+          snapY = dragY + (ref - vr);
+        }
+      }
+    }
+  }
+  for (const guide of guides) {
+    if (guide.axis === "v") {
+      for (const hr of hRefs) {
+        const dx = Math.abs(guide.position - hr);
+        if (dx < threshold && dx < bestDx) {
+          bestDx = dx;
+          snapX = dragX + (guide.position - hr);
+        }
+      }
+    } else {
+      for (const vr of vRefs) {
+        const dy = Math.abs(guide.position - vr);
+        if (dy < threshold && dy < bestDy) {
+          bestDy = dy;
+          snapY = dragY + (guide.position - vr);
+        }
+      }
+    }
+  }
+  if (bestDx < threshold) {
+    const snappedCx = snapX + dragW / 2;
+    const snappedRight = snapX + dragW;
+    for (const sib of siblings) {
+      if (draggedIds.has(sib.id)) {
+        continue;
+      }
+      for (const ref of [sib.x, sib.x + sib.width / 2, sib.x + sib.width]) {
+        if (Math.abs(ref - snapX) < 1 || Math.abs(ref - snappedCx) < 1 || Math.abs(ref - snappedRight) < 1) {
+          lines.push({ axis: "v", position: ref });
+        }
+      }
+    }
+    for (const g of guides) {
+      if (g.axis === "v" && (Math.abs(g.position - snapX) < 1 || Math.abs(g.position - snappedCx) < 1 || Math.abs(g.position - snappedRight) < 1)) {
+        lines.push({ axis: "v", position: g.position });
+      }
+    }
+  }
+  if (bestDy < threshold) {
+    const snappedCy = snapY + dragH / 2;
+    const snappedBottom = snapY + dragH;
+    for (const sib of siblings) {
+      if (draggedIds.has(sib.id)) {
+        continue;
+      }
+      for (const ref of [sib.y, sib.y + sib.height / 2, sib.y + sib.height]) {
+        if (Math.abs(ref - snapY) < 1 || Math.abs(ref - snappedCy) < 1 || Math.abs(ref - snappedBottom) < 1) {
+          lines.push({ axis: "h", position: ref });
+        }
+      }
+    }
+    for (const g of guides) {
+      if (g.axis === "h" && (Math.abs(g.position - snapY) < 1 || Math.abs(g.position - snappedCy) < 1 || Math.abs(g.position - snappedBottom) < 1)) {
+        lines.push({ axis: "h", position: g.position });
+      }
+    }
+  }
+  return { x: snapX, y: snapY, lines };
+}
+function xCandidates(box) {
+  return {
+    leading: box.x,
+    centre: box.x + box.width / 2,
+    trailing: box.x + box.width
+  };
+}
+function yCandidates(box) {
+  return {
+    leading: box.y,
+    centre: box.y + box.height / 2,
+    trailing: box.y + box.height
+  };
+}
+function findSnapHit(movingValues, others, axisCandidates, threshold) {
+  let best = null;
+  let bestDist = threshold + 1;
+  for (const other of others) {
+    const target = axisCandidates(other);
+    const targetValues = [target.leading, target.centre, target.trailing];
+    for (const mv of movingValues) {
+      for (const tv of targetValues) {
+        const dist = mv > tv ? mv - tv : tv - mv;
+        if (dist <= threshold && dist < bestDist) {
+          bestDist = dist;
+          best = { delta: tv - mv, matchedLine: tv, otherBox: other };
+        }
+      }
+    }
+  }
+  return best;
+}
+function unionExtent(aStart, aEnd, bStart, bEnd) {
+  const start = aStart < bStart ? aStart : bStart;
+  const end = aEnd > bEnd ? aEnd : bEnd;
+  return { start, end };
+}
+function computeSnap(box, others, threshold) {
+  const guides = [];
+  let snappedX = box.x;
+  let snappedY = box.y;
+  const xMoving = xCandidates(box);
+  const hitX = findSnapHit(
+    [xMoving.leading, xMoving.centre, xMoving.trailing],
+    others,
+    xCandidates,
+    threshold
+  );
+  if (hitX !== null) {
+    snappedX = box.x + hitX.delta;
+    const { start, end } = unionExtent(
+      box.y,
+      box.y + box.height,
+      hitX.otherBox.y,
+      hitX.otherBox.y + hitX.otherBox.height
+    );
+    guides.push({ axis: "x", pos: hitX.matchedLine, start, end });
+  }
+  const yMoving = yCandidates(box);
+  const hitY = findSnapHit(
+    [yMoving.leading, yMoving.centre, yMoving.trailing],
+    others,
+    yCandidates,
+    threshold
+  );
+  if (hitY !== null) {
+    snappedY = box.y + hitY.delta;
+    const { start, end } = unionExtent(
+      snappedX,
+      snappedX + box.width,
+      hitY.otherBox.x,
+      hitY.otherBox.x + hitY.otherBox.width
+    );
+    guides.push({ axis: "y", pos: hitY.matchedLine, start, end });
+  }
+  return { x: snappedX, y: snappedY, guides };
+}
+function snapToGridStep(value, step) {
+  if (step <= 0) {
+    return value;
+  }
+  return Math.round(value / step) * step || 0;
+}
+function snapValue(value, size) {
+  return Math.round(value / size) * size;
+}
+function snapBox(box, size) {
+  return {
+    x: snapValue(box.x, size),
+    y: snapValue(box.y, size),
+    width: Math.max(size, snapValue(box.width, size)),
+    height: Math.max(size, snapValue(box.height, size))
+  };
+}
+
+// geometry/align-distribute.ts
+function usesSlideReference(elementCount, options) {
+  if (!options?.slideSize) {
+    return false;
+  }
+  return options.reference === "slide" || options.reference === void 0 && elementCount === 1;
+}
+function resolveAlignReferenceBox(elements, options) {
+  if (elements.length === 0) {
+    return null;
+  }
+  if (usesSlideReference(elements.length, options)) {
+    return { minX: 0, minY: 0, maxX: options.slideSize.width, maxY: options.slideSize.height };
+  }
+  if (elements.length < 2) {
+    return null;
+  }
+  return {
+    minX: Math.min(...elements.map((e) => e.x)),
+    minY: Math.min(...elements.map((e) => e.y)),
+    maxX: Math.max(...elements.map((e) => e.x + e.width)),
+    maxY: Math.max(...elements.map((e) => e.y + e.height))
+  };
+}
+function alignElements(elements, edge, options) {
+  const result = /* @__PURE__ */ new Map();
+  const ref = resolveAlignReferenceBox(elements, options);
+  if (!ref) {
+    return result;
+  }
+  const { minX, minY, maxX, maxY } = ref;
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  for (const el of elements) {
+    switch (edge) {
+      case "left":
+        result.set(el.id, { x: minX });
+        break;
+      case "right":
+        result.set(el.id, { x: maxX - el.width });
+        break;
+      case "centerH":
+        result.set(el.id, { x: centerX - el.width / 2 });
+        break;
+      case "top":
+        result.set(el.id, { y: minY });
+        break;
+      case "bottom":
+        result.set(el.id, { y: maxY - el.height });
+        break;
+      case "middle":
+        result.set(el.id, { y: centerY - el.height / 2 });
+        break;
+    }
+  }
+  return result;
+}
+function distributeElements(elements, axis, options) {
+  const result = /* @__PURE__ */ new Map();
+  const horizontal = axis === "horizontal";
+  const start = (e) => horizontal ? e.x : e.y;
+  const size = (e) => horizontal ? e.width : e.height;
+  const sorted = [...elements].sort((a, b) => start(a) - start(b));
+  const totalSize = sorted.reduce((sum, e) => sum + size(e), 0);
+  let cursor;
+  let gap;
+  if (usesSlideReference(elements.length, options)) {
+    if (sorted.length === 0) {
+      return result;
+    }
+    const span = horizontal ? options.slideSize.width : options.slideSize.height;
+    gap = (span - totalSize) / (sorted.length + 1);
+    cursor = gap;
+  } else {
+    if (sorted.length < 3) {
+      return result;
+    }
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    const span = start(last) + size(last) - start(first);
+    gap = (span - totalSize) / (sorted.length - 1);
+    cursor = start(first);
+  }
+  for (const el of sorted) {
+    result.set(el.id, horizontal ? { x: cursor } : { y: cursor });
+    cursor += size(el) + gap;
+  }
+  return result;
+}
+function onlyMoved(boxes, positions) {
+  const byId = new Map(boxes.map((box) => [box.id, box]));
+  const result = /* @__PURE__ */ new Map();
+  for (const [id, pos] of positions) {
+    const box = byId.get(id);
+    if (!box) {
+      continue;
+    }
+    const moved = pos.x !== void 0 && pos.x !== box.x || pos.y !== void 0 && pos.y !== box.y;
+    if (moved) {
+      result.set(id, pos);
+    }
+  }
+  return result;
+}
+function computeAlign(boxes, mode, options) {
+  return onlyMoved(boxes, alignElements(boxes, mode, options));
+}
+function computeDistribute(boxes, mode, options) {
+  return onlyMoved(boxes, distributeElements(boxes, mode, options));
+}
+
+export { ACTION_BUTTON_CONNECTION_SITES, ACTION_BUTTON_PRESET_DEFINITIONS, ACTION_BUTTON_TEXT_RECTS, ANGLE_SCALE, ARROW_CALLOUT_CONNECTION_SITES, ARROW_CALLOUT_PRESET_DEFINITIONS, ARROW_CONNECTION_SITES, ARROW_PRESET_DEFINITIONS, ARROW_TEXT_RECTS, BASIC_SHAPE_CONNECTION_SITES_A, BASIC_SHAPE_CONNECTION_SITES_B, BRACE_CONNECTION_SITES, BRACE_TEXT_RECTS, CALLOUT_CONNECTION_SITES, CALLOUT_TEXT_RECTS, CARDINAL_SITES, CHART_MARK_PRESET_DEFINITIONS, CIRCULAR_ARROW_CONNECTION_SITES, CIRCULAR_ARROW_TEXT_RECTS, CLIP_PATHS_CORE, CLIP_PATHS_EXTENDED, CLOUD_CALLOUT_PRESET_DEFINITIONS, CLOUD_CALLOUT_TAIL_COUNT, CLOUD_LOBE_COUNT, COM_AVLST_GROUND_TRUTH, CONNECTORS_BRACKETS_PRESET_DEFINITIONS, CURVED_ARROWS_CONNECTORS_PRESET_DEFINITIONS, CURVED_ARROW_CONNECTION_SITES, EPSILON, EXACT_CURVED_ARROW_PRESET_DEFINITIONS, EXTENDED_SHAPE_DEFINITIONS, FLOWCHART_CONNECTION_SITES, FLOWCHART_PRESET_DEFINITIONS, FLOWCHART_TEXT_RECTS, GEAR9_CONNECTION_SITES, LEFT_CIRCULAR_ARROW_CONNECTION_SITES, LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES, MATH_SYMBOL_CONNECTION_SITES, MISC_ARROW_CONNECTION_SITES, MISC_PRESET_DEFINITIONS, MISC_SHAPE_CONNECTION_SITES, MISC_TEXT_RECTS_A, MISC_TEXT_RECTS_B, POLYGON_CONNECTION_SITES, POLYGON_TEXT_RECTS, PRESET_GEOMETRY_ALIASES, PRESET_SHAPE_CATEGORY_LABELS, PRESET_SHAPE_CLIP_PATHS, PRESET_SHAPE_DEFINITIONS, PRESET_SHAPE_GEOMETRY_TABLE, PRIMARY_SHAPE_DEFINITIONS, QUAD_CONNECTION_SITES, QUAD_TEXT_RECTS, RECTS_SNIPS_PRESET_DEFINITIONS, RECT_VARIANT_CONNECTION_SITES, REFINED_ARROW_PRESET_DEFINITIONS, RIBBON_CONNECTION_SITES, RIBBON_TEXT_RECTS, SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS, SNAP_THRESHOLD, STAR_CONNECTION_SITES, STAR_TEXT_RECTS, ST_SHAPE_TYPE_VALUES, TABS_DECORATIONS_PRESET_DEFINITIONS, TAB_CONNECTION_SITES, TAB_TEXT_RECTS, _internalForTests, alignElements, angleToRadians, at, buildCalloutLeaderLineSvgPath, clipPolygons, combineShapes, computeAlign, computeDistribute, computeSnap, computeSnapToShape, computeUnionWalk, convexHull, createBuiltinVariables, cross2, cxn, dedupPoly, distributeElements, elbowCurveSegments, elbowWaypoints, ensureCCW, ensureCW, evaluateFormula, evaluateGuides, findAllIntersections, flattenSvgPath, fmtNum, fragmentShapes, gd, gear6, gear9, getAdjustmentAwareClipPath, getCalloutLeaderLineGeometry, getCalloutTier, getCalloutViewBoxBounds, getCloudCalloutClipPath, getCloudClipPath, getPresetConnectionSites, getPresetShapeClipPath, getPresetTextRect, insertIntersections, intersectPolygons, intersectShapes, intersectSvgPaths, isCalloutShape, isConvex, isHorizontalPrimaryAxis, isStShapeType, lineIntersection, lookupPresetConnectionSites, lookupPresetTextRectOverride, mergeOverlappingPolygons, mergeShapes, normalizeStShapeType, parseAdjustmentValues, parseFormula, parseGuideDefinitions, pointInPolygon, pointInTriangle, polygonArea, polygonsToSvgPath, resolveAlignReferenceBox, resolveCoordinate, resolveOperand, segmentIntersection, signedArea, snapBox, snapToGridStep, snapValue, subtractPolygons, subtractShapes, subtractSvgPaths, sutherlandHodgman, svgPathToPolygons, triangulate, unionPolygons, unionShapes, unionSvgPaths, usesSlideReference, vec2Eq };

package/dist/geometry/snap-guides.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Pure snap-and-alignment-guide geometry shared by the React, Vue, and Angular
+ * editor bindings. No framework imports, no DOM, no side effects - only data
+ * in, data out. All inputs are treated as immutable.
+ *
+ * Two snap models live here because the bindings grew two distinct flavours;
+ * both are exact ports kept feature-for-feature so consumers stay unchanged:
+ *
+ *  1. `computeSnapToShape` (React / Vue model) - snaps a dragged box to the
+ *     edges/centres of sibling boxes **and** user-placed guides within
+ *     {@link SNAP_THRESHOLD}px, returning `{ x, y, lines }` where `lines` are
+ *     thin axis-positioned guide indicators (no span info).
+ *
+ *  2. `computeSnap` (Angular model) - snaps a box to a list of other boxes
+ *     within an explicit `threshold`, returning `{ x, y, guides }` where each
+ *     guide additionally carries the perpendicular `start`/`end` span covering
+ *     both boxes. At most one snap per axis (closest wins).
+ *
+ * `snapToGridStep` rounds a single value to the nearest grid multiple.
+ *
+ * The pointer/drag driver (event handling, refs, reactive state) stays in each
+ * binding; only this geometry is shared.
+ */
+/** Max gap (slide px) at which an edge/centre snaps to a sibling or guide. */
+export declare const SNAP_THRESHOLD = 6;
+/** A sibling element reduced to its bounding box. */
+export interface SnapSibling {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A user-placed alignment guide: `axis: 'v'` is a vertical line at x=`position`. */
+export interface SnapGuideInput {
+    axis: 'h' | 'v';
+    position: number;
+}
+/** A snap alignment line: `axis: 'v'` is a vertical line at x=`position`. */
+export interface SnapLine {
+    axis: 'h' | 'v';
+    position: number;
+}
+/** Result of {@link computeSnapToShape}: (optionally snapped) position + lines. */
+export interface SnapToShapeResult {
+    x: number;
+    y: number;
+    lines: SnapLine[];
+}
+/**
+ * Compute snap-to-shape alignment lines and optionally snap a dragged element's
+ * position to the nearest matching edge/centre of sibling elements and guides.
+ *
+ * Returns `{ x, y, lines }` where x/y are (optionally snapped) positions and
+ * lines is the set of visual guide indicators to render.
+ *
+ * @param threshold - Snap distance in slide px (defaults to {@link SNAP_THRESHOLD}).
+ */
+export declare function computeSnapToShape(dragX: number, dragY: number, dragW: number, dragH: number, siblings: readonly SnapSibling[], draggedIds: Set<string>, guides: readonly SnapGuideInput[], threshold?: number): SnapToShapeResult;
+/** An axis-aligned bounding box in stage (slide) coordinates. */
+export interface SnapBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * A single span guide line to draw.
+ *
+ * `axis: 'x'` → a vertical line at x = `pos`, spanning y ∈ [start, end].
+ * `axis: 'y'` → a horizontal line at y = `pos`, spanning x ∈ [start, end].
+ */
+export interface SnapGuide {
+    axis: 'x' | 'y';
+    /** The fixed coordinate of the line on its own axis. */
+    pos: number;
+    /** Start of the line along the perpendicular axis. */
+    start: number;
+    /** End of the line along the perpendicular axis. */
+    end: number;
+}
+/** The result of a {@link computeSnap} computation for one drag frame. */
+export interface SnapResult {
+    /** Snapped x origin of the moving box. */
+    x: number;
+    /** Snapped y origin of the moving box. */
+    y: number;
+    /** Guide lines to draw; empty when nothing is within threshold. */
+    guides: SnapGuide[];
+}
+/**
+ * Compute snap adjustments and span guide lines for a box being dragged.
+ *
+ * For each axis independently the moving box exposes three candidate positions
+ * (leading, centre, trailing) and so does every other box. If any
+ * `|candidate − otherPos| ≤ threshold`, the closest pair snaps: the returned
+ * x (or y) is adjusted so the candidate aligns exactly with the other
+ * position, and a {@link SnapGuide} is emitted spanning both boxes'
+ * perpendicular extents. At most one snap per axis (closest wins). When nothing
+ * is within threshold, x/y are returned unchanged and guides is empty.
+ */
+export declare function computeSnap(box: SnapBox, others: readonly SnapBox[], threshold: number): SnapResult;
+/**
+ * Snap a raw position value to the nearest grid step.
+ *
+ * @param value - Raw position in stage coordinates.
+ * @param step  - Grid spacing in px (must be > 0; if ≤ 0 the value is returned
+ *               unchanged so callers do not need to guard against zero).
+ * @returns The nearest multiple of `step`.
+ */
+export declare function snapToGridStep(value: number, step: number): number;
+/**
+ * Round a value to the nearest multiple of `size` (the grid spacing).
+ *
+ * Unlike {@link snapToGridStep} this does not guard against a non-positive
+ * step (Vue's "Snap to Grid" caller always passes a positive grid size) and
+ * does not normalise −0; it mirrors React's `Math.round(v / gs) * gs`.
+ */
+export declare function snapValue(value: number, size: number): number;
+/**
+ * Snap a box's position + size to the grid (View ▸ Snap to Grid). Sizes are
+ * clamped to at least one grid cell so an element never collapses to zero.
+ */
+export declare function snapBox(box: SnapBox, size: number): SnapBox;
+//# sourceMappingURL=snap-guides.d.ts.map

package/dist/geometry/snap-guides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap-guides.d.ts","sourceRoot":"","sources":["../../geometry/snap-guides.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAMH,8EAA8E;AAC9E,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,qDAAqD;AACrD,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,6EAA6E;AAC7E,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,mFAAmF;AACnF,MAAM,WAAW,iBAAiB;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,QAAQ,EAAE,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,MAAM,EAAE,SAAS,cAAc,EAAE,EACjC,SAAS,GAAE,MAAuB,GAChC,iBAAiB,CA+HnB;AAMD,iEAAiE;AACjE,MAAM,WAAW,OAAO;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAChB,wDAAwD;IACxD,GAAG,EAAE,MAAM,CAAC;IACZ,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,0EAA0E;AAC1E,MAAM,WAAW,UAAU;IAC1B,0CAA0C;IAC1C,CAAC,EAAE,MAAM,CAAC;IACV,0CAA0C;IAC1C,CAAC,EAAE,MAAM,CAAC;IACV,mEAAmE;IACnE,MAAM,EAAE,SAAS,EAAE,CAAC;CACpB;AAsED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAC1B,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,SAAS,EAAE,MAAM,GACf,UAAU,CA2CZ;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAOlE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAO3D"}