@oh-just-another/state 0.59.0 → 0.60.0

package/dist/editor/public/stroke-eraser.d.ts

@@ -0,0 +1,50 @@
+import { type BrushElement, type Scene, type Patch } from "@oh-just-another/scene";
+import { type ElementId, type Vec2 } from "@oh-just-another/types";
+import { type Interval } from "./stroke-eraser-coverage.js";
+/**
+ * Grow a brush's accumulated covered spans by the eraser segment `a → b` (world)
+ * at `radius` and return the merged result. INCREMENTAL: the live gesture calls
+ * this once per pointer move with only the new segment, so a drag costs
+ * O(points) per move instead of re-scanning the whole path each frame. `radius`
+ * is the visible cursor ring in world units. Pure — returns a new interval list.
+ */
+export declare const markErasedIntervals: (brush: BrushElement, existing: readonly Interval[], a: Vec2, b: Vec2, radius: number) => Interval[];
+/**
+ * STROKE-ERASER core (pure). Cut a single brush against an eraser path: the arc
+ * spans of the brush polyline within `radius` of the path are removed and the
+ * survivors split into fragment {@link BrushElement}s (endpoints on the ring).
+ * When nothing is covered, `erasedAny` is `false` and `fragments` is `[brush]`
+ * unchanged so the caller can skip the swap. One-shot (scans the whole path) —
+ * the live gesture uses the incremental {@link markErasedIntervals} instead.
+ */
+export declare const computeEraseBrushStroke: (brush: BrushElement, eraserPathWorld: readonly Vec2[], radius: number, makeId: () => ElementId) => {
+    fragments: BrushElement[];
+    erasedAny: boolean;
+};
+/**
+ * Commit the accumulated stroke-erase: `erased` maps each touched brush id to the
+ * covered arc-length spans built incrementally by {@link markErasedIntervals}.
+ * Each such brush is replaced with its fragments (remove original + add fragments)
+ * and any link bound to it is detached (drop the binding — don't re-bind to a
+ * fragment). Returns the next scene + patches for ONE history batch, or `null`
+ * when nothing is cut.
+ */
+export declare const computeEraseFromMasks: (scene: Scene, erased: ReadonlyMap<ElementId, readonly Interval[]>, makeId: () => ElementId) => {
+    readonly scene: Scene;
+    readonly patches: Patch[];
+    readonly removedIds: ElementId[];
+    readonly addedIds: ElementId[];
+} | null;
+/**
+ * Live-preview counterpart of {@link computeEraseFromMasks}: the cut fragments for
+ * every brush with covered spans so far, WITHOUT mutating the scene or consuming
+ * real ids. `fragments` are drawn on the overlay and `hidden` (the touched
+ * originals) suppressed in the main pass, so the user sees the cut before
+ * releasing. Fragment ids are deterministic per frame (never enter history).
+ * `null` when nothing is cut yet.
+ */
+export declare const computeStrokeErasePreviewFromMasks: (scene: Scene, erased: ReadonlyMap<ElementId, readonly Interval[]>) => {
+    fragments: BrushElement[];
+    hidden: Set<ElementId>;
+} | null;
+//# sourceMappingURL=stroke-eraser.d.ts.map

package/dist/editor/public/stroke-eraser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-eraser.d.ts","sourceRoot":"","sources":["../../../src/editor/public/stroke-eraser.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,YAAY,EAEjB,KAAK,KAAK,EACV,KAAK,KAAK,EACX,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,IAAI,EACV,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,6BAA6B,CAAC;AA+DrC;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,YAAY,EACnB,UAAU,SAAS,QAAQ,EAAE,EAC7B,GAAG,IAAI,EACP,GAAG,IAAI,EACP,QAAQ,MAAM,KACb,QAAQ,EAIV,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,YAAY,EACnB,iBAAiB,SAAS,IAAI,EAAE,EAChC,QAAQ,MAAM,EACd,QAAQ,MAAM,SAAS,KACtB;IAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAajD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,KAAK,EACZ,QAAQ,WAAW,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC,EACnD,QAAQ,MAAM,SAAS,KACtB;IACD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC;CAChC,GAAG,IAkCH,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kCAAkC,GAC7C,OAAO,KAAK,EACZ,QAAQ,WAAW,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC,KAClD;IAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;CAAE,GAAG,IAgB1D,CAAC"}

package/dist/editor/public/stroke-eraser.js

@@ -0,0 +1,176 @@
+import { req } from "../../util.js";
+import { addElement, removeElement, removeLink, orderBetween, isBrush, endpointElementId, } from "@oh-just-another/scene";
+import { elementId as castElementId, } from "@oh-just-another/types";
+import { ERASE_FRAGMENT_MIN_ARC } from "../../constants.js";
+import { brushArc, coveredArcAgainstSegment, complementIntervals, mergeIntervals, localPointAtArc, } from "./stroke-eraser-coverage.js";
+const EPS = 1e-6;
+/**
+ * Rebuild a brush's surviving pieces from the COVERED arc-length spans the eraser
+ * removed. The kept spans (complement of `covered`) each become a fresh fragment
+ * {@link BrushElement}: the span endpoints — already pinned to the eraser ring by
+ * {@link coveredArcAgainstSegment}'s bisection — are the fragment's first/last
+ * points, with the original vertices strictly inside the span in between. Points
+ * are re-localised to the fragment's first world position, per-point widths kept,
+ * fractional `order`s around the original's slot, never `closed`.
+ *
+ * Cutting by ARC LENGTH (not vertex index) is what makes the eraser remove the
+ * geometry it visibly covers regardless of how densely the stroke was sampled — a
+ * big disc grazing a sparse line no longer slips between two far-apart vertices. A
+ * kept span shorter than {@link ERASE_FRAGMENT_MIN_ARC} is dropped (litter).
+ */
+const buildFragmentsFromCoverage = (brush, covered, makeId) => {
+    const arc = brushArc(brush);
+    if (arc.total === 0)
+        return []; // a single-point brush leaves nothing once cut
+    const kept = complementIntervals(covered, arc.total);
+    const fragments = [];
+    let prevOrder = brush.order;
+    let idx = 0;
+    for (const [L0, L1] of kept) {
+        if (L1 - L0 < ERASE_FRAGMENT_MIN_ARC)
+            continue; // drop stray nubs
+        const runPts = [localPointAtArc(arc, L0)];
+        for (let i = 0; i < arc.pts.length; i++) {
+            const c = req(arc.cum[i]);
+            if (c > L0 + EPS && c < L1 - EPS)
+                runPts.push({ ...req(arc.pts[i]) });
+        }
+        runPts.push(localPointAtArc(arc, L1));
+        if (runPts.length < 2)
+            continue;
+        const anchor = req(runPts[0]);
+        const worldFirst = { x: brush.position.x + anchor.x, y: brush.position.y + anchor.y };
+        const localPoints = runPts.map((p) => ({
+            x: p.x - anchor.x,
+            y: p.y - anchor.y,
+            width: p.width,
+        }));
+        const order = idx === 0 ? brush.order : orderBetween(prevOrder, null);
+        prevOrder = order;
+        idx++;
+        fragments.push({
+            id: makeId(),
+            layerId: brush.layerId,
+            type: "brush",
+            position: worldFirst,
+            rotation: 0,
+            scale: { x: 1, y: 1 },
+            order,
+            style: brush.style,
+            points: localPoints,
+        });
+    }
+    return fragments;
+};
+/**
+ * Grow a brush's accumulated covered spans by the eraser segment `a → b` (world)
+ * at `radius` and return the merged result. INCREMENTAL: the live gesture calls
+ * this once per pointer move with only the new segment, so a drag costs
+ * O(points) per move instead of re-scanning the whole path each frame. `radius`
+ * is the visible cursor ring in world units. Pure — returns a new interval list.
+ */
+export const markErasedIntervals = (brush, existing, a, b, radius) => {
+    const add = coveredArcAgainstSegment(brushArc(brush), a, b, radius);
+    if (add.length === 0)
+        return existing.length > 0 ? mergeIntervals(existing) : [];
+    return mergeIntervals([...existing, ...add]);
+};
+/**
+ * STROKE-ERASER core (pure). Cut a single brush against an eraser path: the arc
+ * spans of the brush polyline within `radius` of the path are removed and the
+ * survivors split into fragment {@link BrushElement}s (endpoints on the ring).
+ * When nothing is covered, `erasedAny` is `false` and `fragments` is `[brush]`
+ * unchanged so the caller can skip the swap. One-shot (scans the whole path) —
+ * the live gesture uses the incremental {@link markErasedIntervals} instead.
+ */
+export const computeEraseBrushStroke = (brush, eraserPathWorld, radius, makeId) => {
+    if (eraserPathWorld.length === 0)
+        return { fragments: [brush], erasedAny: false };
+    const arc = brushArc(brush);
+    let covered = [];
+    const segs = Math.max(1, eraserPathWorld.length - 1);
+    for (let i = 0; i < segs; i++) {
+        const a = req(eraserPathWorld[i]);
+        const b = req(eraserPathWorld[Math.min(i + 1, eraserPathWorld.length - 1)]);
+        const add = coveredArcAgainstSegment(arc, a, b, radius);
+        if (add.length > 0)
+            covered = mergeIntervals([...covered, ...add]);
+    }
+    if (covered.length === 0)
+        return { fragments: [brush], erasedAny: false };
+    return { fragments: buildFragmentsFromCoverage(brush, covered, makeId), erasedAny: true };
+};
+/**
+ * Commit the accumulated stroke-erase: `erased` maps each touched brush id to the
+ * covered arc-length spans built incrementally by {@link markErasedIntervals}.
+ * Each such brush is replaced with its fragments (remove original + add fragments)
+ * and any link bound to it is detached (drop the binding — don't re-bind to a
+ * fragment). Returns the next scene + patches for ONE history batch, or `null`
+ * when nothing is cut.
+ */
+export const computeEraseFromMasks = (scene, erased, makeId) => {
+    let s = scene;
+    const patches = [];
+    const removedIds = [];
+    const addedIds = [];
+    const droppedLinks = new Set();
+    for (const [brushId, covered] of erased) {
+        if (covered.length === 0)
+            continue;
+        const el = scene.elements.get(brushId);
+        if (el === undefined || !isBrush(el))
+            continue;
+        const fragments = buildFragmentsFromCoverage(el, covered, makeId);
+        // Detach links bound to this brush before removing it.
+        for (const edge of [...s.links.values()]) {
+            if (droppedLinks.has(edge.id))
+                continue;
+            if (endpointElementId(edge.from) === el.id || endpointElementId(edge.to) === el.id) {
+                const r = removeLink(s, edge.id);
+                s = r.scene;
+                patches.push(r.patch);
+                droppedLinks.add(edge.id);
+            }
+        }
+        const removed = removeElement(s, el.id);
+        s = removed.scene;
+        patches.push(removed.patch);
+        removedIds.push(el.id);
+        for (const frag of fragments) {
+            const added = addElement(s, frag);
+            s = added.scene;
+            patches.push(added.patch);
+            addedIds.push(frag.id);
+        }
+    }
+    if (patches.length === 0)
+        return null;
+    return { scene: s, patches, removedIds, addedIds };
+};
+/**
+ * Live-preview counterpart of {@link computeEraseFromMasks}: the cut fragments for
+ * every brush with covered spans so far, WITHOUT mutating the scene or consuming
+ * real ids. `fragments` are drawn on the overlay and `hidden` (the touched
+ * originals) suppressed in the main pass, so the user sees the cut before
+ * releasing. Fragment ids are deterministic per frame (never enter history).
+ * `null` when nothing is cut yet.
+ */
+export const computeStrokeErasePreviewFromMasks = (scene, erased) => {
+    const fragments = [];
+    const hidden = new Set();
+    for (const [brushId, covered] of erased) {
+        if (covered.length === 0)
+            continue;
+        const el = scene.elements.get(brushId);
+        if (el === undefined || !isBrush(el))
+            continue;
+        let n = 0;
+        const parts = buildFragmentsFromCoverage(el, covered, () => castElementId(`stroke-erase-preview-${el.id}-${n++}`));
+        hidden.add(el.id);
+        fragments.push(...parts);
+    }
+    if (hidden.size === 0)
+        return null;
+    return { fragments, hidden };
+};
+//# sourceMappingURL=stroke-eraser.js.map

package/dist/editor/public/stroke-eraser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-eraser.js","sourceRoot":"","sources":["../../../src/editor/public/stroke-eraser.ts"],"names":[],"mappings":"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"}

package/dist/editor/public/stroke-smoothing.d.ts

@@ -0,0 +1,21 @@
+import { type Vec2 } from "@oh-just-another/types";
+/** Any point that carries at least a world position. */
+export interface SmoothablePoint {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Resample a sparse polyline into a smooth, dense point list by fitting a
+ * Catmull-Rom spline through the captured points (reusing `catmullRomBeziers`
+ * from `@oh-just-another/scene` — one spline implementation for the whole repo)
+ * and sampling `perSegment` sub-points per span.
+ *
+ * Freehand input (laser trail, brush stroke) is captured sparsely — one point
+ * per pointer-move — so the raw polyline is angular. The `blend` callback
+ * rebuilds each resampled point from its span endpoints and the interpolation
+ * parameter `u`, so per-point payload beyond position (timestamp for the laser,
+ * width for the brush) is carried across smoothly. Fewer than three points
+ * can't form a curve, so they pass through unchanged.
+ */
+export declare const smoothStrokePoints: <P extends SmoothablePoint>(points: readonly P[], perSegment: number, blend: (a: P, b: P, pos: Vec2, u: number) => P) => P[];
+//# sourceMappingURL=stroke-smoothing.d.ts.map

package/dist/editor/public/stroke-smoothing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-smoothing.d.ts","sourceRoot":"","sources":["../../../src/editor/public/stroke-smoothing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAIxD,wDAAwD;AACxD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,eAAe,EAC1D,QAAQ,SAAS,CAAC,EAAE,EACpB,YAAY,MAAM,EAClB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,KAC7C,CAAC,EAkBH,CAAC"}

package/dist/editor/public/stroke-smoothing.js

@@ -0,0 +1,37 @@
+import { req } from "@oh-just-another/types";
+import { bezier } from "@oh-just-another/math";
+import { catmullRomBeziers } from "@oh-just-another/scene";
+/**
+ * Resample a sparse polyline into a smooth, dense point list by fitting a
+ * Catmull-Rom spline through the captured points (reusing `catmullRomBeziers`
+ * from `@oh-just-another/scene` — one spline implementation for the whole repo)
+ * and sampling `perSegment` sub-points per span.
+ *
+ * Freehand input (laser trail, brush stroke) is captured sparsely — one point
+ * per pointer-move — so the raw polyline is angular. The `blend` callback
+ * rebuilds each resampled point from its span endpoints and the interpolation
+ * parameter `u`, so per-point payload beyond position (timestamp for the laser,
+ * width for the brush) is carried across smoothly. Fewer than three points
+ * can't form a curve, so they pass through unchanged.
+ */
+export const smoothStrokePoints = (points, perSegment, blend) => {
+    if (points.length < 3)
+        return points;
+    const segments = catmullRomBeziers(points.map((p) => ({ x: p.x, y: p.y })));
+    const first = req(points[0]);
+    const out = [first];
+    let prev = { x: first.x, y: first.y };
+    for (let i = 0; i < segments.length; i++) {
+        const seg = req(segments[i]);
+        const a = req(points[i]);
+        const b = req(points[i + 1]);
+        for (let j = 1; j <= perSegment; j++) {
+            const u = j / perSegment;
+            const p = bezier.cubicAt(prev, seg.c1, seg.c2, seg.to, u);
+            out.push(blend(a, b, p, u));
+        }
+        prev = seg.to;
+    }
+    return out;
+};
+//# sourceMappingURL=stroke-smoothing.js.map

package/dist/editor/public/stroke-smoothing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-smoothing.js","sourceRoot":"","sources":["../../../src/editor/public/stroke-smoothing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAa,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAQ3D;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,MAAoB,EACpB,UAAkB,EAClB,KAA8C,EACzC,EAAE;IACP,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,MAAa,CAAC;IAC5C,MAAM,QAAQ,GAAG,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5E,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7B,MAAM,GAAG,GAAQ,CAAC,KAAK,CAAC,CAAC;IACzB,IAAI,IAAI,GAAS,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACzB,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC;YACzB,MAAM,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YAC1D,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9B,CAAC;QACD,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;IAChB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC"}

package/dist/editor/public/tool-ops.d.ts

@@ -0,0 +1,130 @@
+import { type Element, type ImageCrop, type Link, type Patch, type Scene } from "@oh-just-another/scene";
+import type { Bounds, Color, ElementId, LinkId, Vec2 } from "@oh-just-another/types";
+/**
+ * The style colour of the top-most shape under `point`, or `null` when the
+ * point is empty. `role` chooses which channel to sample: `"fill"` (default)
+ * falls back to the stroke when there is no fill, and `"stroke"` the other way
+ * round — so clicking a stroke-only outline still yields a usable colour.
+ */
+export declare const pickColorAt: (scene: Scene, point: Vec2, role?: "fill" | "stroke") => Color | null;
+/** Target types accepted by {@link computeConvertType}. `"polygon"` = diamond. */
+export type ConvertTarget = "rectangle" | "ellipse" | "polygon";
+/**
+ * Convert every convertible shape in `ids` to `target`, preserving
+ * position / rotation / scale / style and the on-canvas footprint. rectangle
+ * and ellipse carry `width` × `height`; `"polygon"` renders a diamond
+ * inscribed in that box. Shapes already of the target type, and non-convertible
+ * types (text, image, …), are skipped. One undo step (batched for 2+). Returns
+ * `null` when nothing changed.
+ */
+export declare const computeConvertType: (scene: Scene, ids: Iterable<ElementId>, target: ConvertTarget) => {
+    readonly scene: Scene;
+    readonly patch: Patch;
+} | null;
+/** Clamp a crop rect into the valid `[0,1]` normalised range (non-empty). */
+export declare const clampCrop: (crop: ImageCrop) => ImageCrop;
+/**
+ * Set (or clear, with `null`) the normalised crop of the image `id`. No-op
+ * (returns `null`) when the shape is missing or not an image, or when the
+ * crop is unchanged. Setting a full-image crop (`0,0,1,1`) clears the field.
+ */
+export declare const computeSetImageCrop: (scene: Scene, id: ElementId, crop: ImageCrop | null) => {
+    readonly scene: Scene;
+    readonly patch: Patch;
+} | null;
+/**
+ * Normalised crop rect covering the whole image. Equivalent to no crop.
+ */
+export declare const FULL_CROP: ImageCrop;
+/** The 8 crop-frame handles: 4 corners + 4 edge midpoints. */
+export type CropHandle = "nw" | "n" | "ne" | "e" | "se" | "s" | "sw" | "w";
+/** Ordered so corner handles win a tie against the adjacent edge midpoints. */
+export declare const CROP_HANDLES: readonly CropHandle[];
+/**
+ * Local-space rect the WHOLE (uncropped) bitmap would occupy, aligned so its
+ * current crop-window equals the element's box `{0,0,width,height}`. The
+ * element currently shows the sub-rectangle `crop` of this virtual full image.
+ * Used to draw the crop ghost and to clamp handle drags to the image extent.
+ */
+export declare const cropFullImageLocalRect: (el: Element, crop: ImageCrop) => Bounds;
+/**
+ * World-space positions of the 8 crop handles for the element's current box
+ * `{0,0,width,height}` (the visible crop window). Honours rotation / scale via
+ * `localToWorld`. The window always equals the element bounds, so the crop
+ * fraction is not needed here — pass the (pending) element whose `width` /
+ * `height` / `position` describe the window.
+ */
+export declare const cropHandleWorldPoints: (el: Element) => Record<CropHandle, Vec2>;
+/**
+ * Result of a crop handle / body drag: the pending normalised `crop` plus the
+ * element's new world `position` and local `width` × `height`. Rotation / scale
+ * are unchanged, so the caller keeps them.
+ */
+export interface CropDragResult {
+    readonly crop: ImageCrop;
+    readonly position: Vec2;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Drag one crop handle to `worldPoint`. Moves the window edge(s) that handle
+ * controls (the opposite edge stays fixed), clamped so the window stays inside
+ * the virtual full image and never shrinks below {@link CROP_MIN_SIZE}. The
+ * source is never stretched: shrinking the window hides pixels rather than
+ * scaling them. `el` must be the ORIGINAL (unmutated) element so the reference
+ * frame stays stable across a multi-move drag.
+ */
+export declare const computeCropHandleDrag: (el: Element, crop: ImageCrop, handle: CropHandle, worldPoint: Vec2) => CropDragResult;
+/**
+ * Pan the source under a FIXED window: the element's box (position / size) is
+ * unchanged; only which region of the bitmap shows moves. `worldDelta` from
+ * `dragStartWorld` → `worldPoint` is projected into local space and converted
+ * to a crop shift, clamped so the window stays inside the image. `el` must be
+ * the ORIGINAL element and `crop` its ORIGINAL crop (drag-start snapshot).
+ */
+export declare const computeCropBodyPan: (el: Element, crop: ImageCrop, dragStartWorld: Vec2, worldPoint: Vec2) => {
+    readonly crop: ImageCrop;
+};
+/**
+ * Commit a pending crop drag: write the normalised `crop` AND the new element
+ * `position` / `width` / `height` in a single patch (one undo step). A crop
+ * that covers the whole image is stored as no crop (field cleared). No-op
+ * (`null`) for a missing / non-image shape or when nothing changed.
+ */
+export declare const computeCommitImageCrop: (scene: Scene, id: ElementId, next: CropDragResult) => {
+    readonly scene: Scene;
+    readonly patch: Patch;
+} | null;
+export type SpawnDirection = "left" | "right" | "up" | "down";
+/**
+ * Create a clone of `sourceId` offset by {@link SPAWN_CONNECTED_GAP_PX} in
+ * `direction`, plus a link from the source to the new node. The clone keeps the
+ * source's type, size, style and rotation. Returns the next scene, both patches
+ * (element add + link add), and the new ids; `null` when the source is missing.
+ */
+export declare const computeSpawnConnectedNode: (scene: Scene, sourceId: ElementId, direction: SpawnDirection, newElementId: ElementId, newLinkId: LinkId) => {
+    readonly scene: Scene;
+    readonly patches: readonly Patch[];
+    readonly newElementId: ElementId;
+    readonly linkId: LinkId;
+} | null;
+/**
+ * Pure geometry for a flowchart CREATE session: `count` clones of `sourceId`,
+ * each linked source→clone (floating). Does NOT mutate `scene` or history —
+ * returns the pending `elements` + `links` for a PREVIEW; the caller commits
+ * them later. Placement matches Excalidraw's `addNewNodes`:
+ *
+ * - `left` / `right` — the `count` siblings stack vertically, centred on the
+ *   source (step = source height + {@link SPAWN_CONNECTED_GAP_PX}), all offset
+ *   by one source-width + gap along the axis.
+ * - `up` / `down` — siblings spread horizontally, centred on the source
+ *   (step = source width + gap), all offset by one source-height + gap.
+ *
+ * `count === 1` reproduces {@link computeSpawnConnectedNode}'s single placement
+ * (zero perpendicular offset). Returns empty arrays when the source is missing.
+ */
+export declare const computeSpawnConnectedNodes: (scene: Scene, sourceId: ElementId, direction: SpawnDirection, count: number, makeElementId: () => ElementId, makeLinkId: () => LinkId) => {
+    readonly elements: Element[];
+    readonly links: Link[];
+};
+//# sourceMappingURL=tool-ops.d.ts.map

package/dist/editor/public/tool-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-ops.d.ts","sourceRoot":"","sources":["../../../src/editor/public/tool-ops.ts"],"names":[],"mappings":"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"}