mythik-react 0.1.0

package/dist/primitives/spatial-map-editing.js

@@ -0,0 +1,886 @@
+export const DEFAULT_GRID_SIZE = 20;
+export const DEFAULT_SNAP_THRESHOLD = 8;
+function finiteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function positiveFiniteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function nonNegativeFiniteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function normalizeScaleLimit(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function normalizeGridSize(size) {
+    if (typeof size === 'number') {
+        const value = positiveFiniteNumber(size, DEFAULT_GRID_SIZE);
+        return { x: value, y: value };
+    }
+    return {
+        x: positiveFiniteNumber(size?.x, DEFAULT_GRID_SIZE),
+        y: positiveFiniteNumber(size?.y, DEFAULT_GRID_SIZE),
+    };
+}
+function normalizePointConfig(point) {
+    return {
+        x: finiteNumber(point?.x, 0),
+        y: finiteNumber(point?.y, 0),
+    };
+}
+function normalizeSnapPolicy(policy) {
+    const enabled = policy?.enabled === true;
+    return {
+        enabled,
+        grid: {
+            enabled: enabled && policy.grid?.enabled === true,
+            size: normalizeGridSize(policy?.grid?.size),
+            offset: normalizePointConfig(policy?.grid?.offset),
+            threshold: nonNegativeFiniteNumber(policy?.grid?.threshold, DEFAULT_SNAP_THRESHOLD),
+        },
+        itemCenters: {
+            enabled: enabled && policy?.itemCenters?.enabled === true,
+            threshold: nonNegativeFiniteNumber(policy?.itemCenters?.threshold, DEFAULT_SNAP_THRESHOLD),
+        },
+    };
+}
+function normalizeGuidePolicy(policy) {
+    const enabled = policy?.enabled === true;
+    return {
+        enabled,
+        showCoordinates: enabled && policy?.showCoordinates === true,
+        showSnapLines: enabled && policy?.showSnapLines !== false,
+    };
+}
+export function getEditPolicy(mode, policy) {
+    const editing = mode === 'edit';
+    const configured = {
+        bounds: policy?.bounds ?? 'viewBox',
+        keyboardStep: policy?.keyboardStep ?? 1,
+        keyboardLargeStep: policy?.keyboardLargeStep ?? 10,
+        coordinatePrecision: policy?.coordinatePrecision ?? 0,
+    };
+    const minScale = normalizeScaleLimit(policy?.minScale, 0.1);
+    const rawMaxScale = normalizeScaleLimit(policy?.maxScale, 10);
+    const maxScale = rawMaxScale > minScale ? rawMaxScale : 10;
+    return {
+        dragItems: editing && policy?.dragItems !== false,
+        dragZones: editing && policy?.dragZones !== false,
+        keyboardMoveItems: editing && policy?.keyboardMoveItems !== false,
+        keyboardMoveZones: editing && policy?.keyboardMoveZones !== false,
+        resizeItems: editing && policy?.resizeItems !== false,
+        resizeZones: editing && policy?.resizeZones !== false,
+        rotateItems: editing && policy?.rotateItems !== false,
+        keyboardResizeItems: editing && policy?.keyboardResizeItems !== false,
+        keyboardResizeZones: editing && policy?.keyboardResizeZones !== false,
+        keyboardRotateItems: editing && policy?.keyboardRotateItems !== false,
+        shapeEditZones: editing && policy?.shapeEditZones !== false,
+        keyboardShapeEditZones: editing && policy?.keyboardShapeEditZones !== false,
+        bounds: configured.bounds,
+        boundsMode: 'position',
+        keyboardStep: configured.keyboardStep,
+        keyboardLargeStep: configured.keyboardLargeStep,
+        resizeStep: positiveFiniteNumber(policy?.resizeStep, 0.05),
+        resizeLargeStep: positiveFiniteNumber(policy?.resizeLargeStep, 0.25),
+        rotationStep: nonNegativeFiniteNumber(policy?.rotationStep, 5),
+        rotationLargeStep: nonNegativeFiniteNumber(policy?.rotationLargeStep, 15),
+        minScale,
+        maxScale,
+        handles: {
+            visible: editing && policy?.handles?.visible !== false,
+            resize: editing && policy?.handles?.resize !== false,
+            rotate: editing && policy?.handles?.rotate !== false,
+        },
+        coordinatePrecision: configured.coordinatePrecision,
+        snap: editing
+            ? normalizeSnapPolicy(policy?.snap)
+            : normalizeSnapPolicy(),
+        guides: editing
+            ? normalizeGuidePolicy(policy?.guides)
+            : normalizeGuidePolicy(),
+    };
+}
+export function clampPointToRect(point, rect) {
+    return {
+        x: Math.min(rect.x + rect.width, Math.max(rect.x, point.x)),
+        y: Math.min(rect.y + rect.height, Math.max(rect.y, point.y)),
+    };
+}
+export function roundPoint(point, precision) {
+    const safePrecision = Number.isFinite(precision) && precision > 0 ? Math.floor(precision) : 0;
+    const factor = 10 ** safePrecision;
+    return {
+        x: Math.round(point.x * factor) / factor,
+        y: Math.round(point.y * factor) / factor,
+    };
+}
+export function normalizeEditPosition(point, rect, policy) {
+    const bounded = policy.bounds === 'viewBox'
+        ? clampPointToRect(point, rect)
+        : point;
+    return roundPoint(bounded, policy.coordinatePrecision);
+}
+export function normalizeSpatialTransform(transform, policy) {
+    const rawScaleX = finiteNumber(transform?.scaleX, 1);
+    const rawScaleY = finiteNumber(transform?.scaleY, 1);
+    return {
+        scaleX: Math.min(policy.maxScale, Math.max(policy.minScale, rawScaleX)),
+        scaleY: Math.min(policy.maxScale, Math.max(policy.minScale, rawScaleY)),
+    };
+}
+function finitePoint(point) {
+    return Boolean(point
+        && typeof point === 'object'
+        && Number.isFinite(point.x)
+        && Number.isFinite(point.y));
+}
+function parsePolygonPoints(points) {
+    if (typeof points === 'string') {
+        return points
+            .trim()
+            .split(/\s+/)
+            .map((pair) => {
+            const [x, y] = pair.split(',').map(Number);
+            return { x, y };
+        })
+            .filter(finitePoint);
+    }
+    return points
+        .map((point) => (Array.isArray(point) ? { x: point[0], y: point[1] } : point))
+        .filter(finitePoint);
+}
+function boundsFromPoints(points) {
+    if (points.length === 0)
+        return null;
+    const xs = points.map((point) => point.x);
+    const ys = points.map((point) => point.y);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minY = Math.min(...ys);
+    const maxY = Math.max(...ys);
+    if (!Number.isFinite(minX) || !Number.isFinite(maxX) || !Number.isFinite(minY) || !Number.isFinite(maxY)) {
+        return null;
+    }
+    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+export function getSpatialItemLocalBounds(item) {
+    if (item.localBounds
+        && Number.isFinite(item.localBounds.x)
+        && Number.isFinite(item.localBounds.y)
+        && Number.isFinite(item.localBounds.width)
+        && Number.isFinite(item.localBounds.height)
+        && item.localBounds.width > 0
+        && item.localBounds.height > 0) {
+        return item.localBounds;
+    }
+    const shape = item.shape;
+    if (shape.type === 'rect') {
+        return { x: -shape.width / 2, y: -shape.height / 2, width: shape.width, height: shape.height };
+    }
+    if (shape.type === 'circle') {
+        return { x: -shape.radius, y: -shape.radius, width: shape.radius * 2, height: shape.radius * 2 };
+    }
+    if (shape.type === 'ellipse') {
+        return { x: -shape.radiusX, y: -shape.radiusY, width: shape.radiusX * 2, height: shape.radiusY * 2 };
+    }
+    if (shape.type === 'polygon') {
+        return boundsFromPoints(parsePolygonPoints(shape.points));
+    }
+    return null;
+}
+function validLocalBounds(bounds) {
+    return Boolean(bounds
+        && Number.isFinite(bounds.x)
+        && Number.isFinite(bounds.y)
+        && Number.isFinite(bounds.width)
+        && Number.isFinite(bounds.height)
+        && bounds.width > 0
+        && bounds.height > 0);
+}
+export function getSpatialZoneMapBounds(zone) {
+    if (validLocalBounds(zone.localBounds))
+        return zone.localBounds;
+    const shape = zone.shape;
+    if (shape.type === 'rect') {
+        return { x: shape.x, y: shape.y, width: shape.width, height: shape.height };
+    }
+    if (shape.type === 'circle') {
+        return { x: shape.cx - shape.radius, y: shape.cy - shape.radius, width: shape.radius * 2, height: shape.radius * 2 };
+    }
+    if (shape.type === 'ellipse') {
+        return { x: shape.cx - shape.radiusX, y: shape.cy - shape.radiusY, width: shape.radiusX * 2, height: shape.radiusY * 2 };
+    }
+    if (shape.type === 'polygon') {
+        return boundsFromPoints(parsePolygonPoints(shape.points));
+    }
+    return null;
+}
+export function getSpatialZonePosition(zone) {
+    return finitePoint(zone.position) ? zone.position : { x: 0, y: 0 };
+}
+export function normalizeZonePosition(zone, position, rect, policy) {
+    if (policy.bounds !== 'viewBox')
+        return roundPoint(position, policy.coordinatePrecision);
+    const bounds = getSpatialZoneTransformedBounds({ ...zone, position }, policy);
+    if (!bounds)
+        return roundPoint(position, policy.coordinatePrecision);
+    const minX = position.x + rect.x - bounds.x;
+    const maxX = position.x + rect.x + rect.width - (bounds.x + bounds.width);
+    const minY = position.y + rect.y - bounds.y;
+    const maxY = position.y + rect.y + rect.height - (bounds.y + bounds.height);
+    const bounded = {
+        x: Math.min(Math.max(minX, maxX), Math.max(Math.min(minX, maxX), position.x)),
+        y: Math.min(Math.max(minY, maxY), Math.max(Math.min(minY, maxY), position.y)),
+    };
+    return roundPoint(bounded, policy.coordinatePrecision);
+}
+function rotatePoint(point, degrees) {
+    const radians = degrees * Math.PI / 180;
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    return {
+        x: point.x * cos - point.y * sin,
+        y: point.x * sin + point.y * cos,
+    };
+}
+export function mapPointToItemLocal(item, point, policy) {
+    const transform = normalizeSpatialTransform(item.transform, policy);
+    const translated = {
+        x: point.x - item.position.x,
+        y: point.y - item.position.y,
+    };
+    const unrotated = rotatePoint(translated, -(item.rotation ?? 0));
+    return {
+        x: unrotated.x / transform.scaleX,
+        y: unrotated.y / transform.scaleY,
+    };
+}
+export function itemLocalPointToMap(item, point, transform) {
+    const scaled = { x: point.x * transform.scaleX, y: point.y * transform.scaleY };
+    const rotated = rotatePoint(scaled, item.rotation ?? 0);
+    return {
+        x: item.position.x + rotated.x,
+        y: item.position.y + rotated.y,
+    };
+}
+export function mapPointToZoneLocal(zone, point, policy) {
+    const position = getSpatialZonePosition(zone);
+    const transform = normalizeSpatialTransform(zone.transform, policy);
+    const translated = {
+        x: point.x - position.x,
+        y: point.y - position.y,
+    };
+    const unrotated = rotatePoint(translated, -(zone.rotation ?? 0));
+    return {
+        x: unrotated.x / transform.scaleX,
+        y: unrotated.y / transform.scaleY,
+    };
+}
+export function zoneLocalPointToMap(zone, point, transform) {
+    const position = getSpatialZonePosition(zone);
+    const scaled = { x: point.x * transform.scaleX, y: point.y * transform.scaleY };
+    const rotated = rotatePoint(scaled, zone.rotation ?? 0);
+    return {
+        x: position.x + rotated.x,
+        y: position.y + rotated.y,
+    };
+}
+function itemLocalDirectionToMap(item, vector) {
+    return rotatePoint(vector, item.rotation ?? 0);
+}
+function zoneLocalDirectionToMap(zone, vector) {
+    return rotatePoint(vector, zone.rotation ?? 0);
+}
+function handleLocalPoint(bounds, handle) {
+    const minX = bounds.x;
+    const maxX = bounds.x + bounds.width;
+    const midX = bounds.x + bounds.width / 2;
+    const minY = bounds.y;
+    const maxY = bounds.y + bounds.height;
+    const midY = bounds.y + bounds.height / 2;
+    return {
+        n: { x: midX, y: minY },
+        ne: { x: maxX, y: minY },
+        e: { x: maxX, y: midY },
+        se: { x: maxX, y: maxY },
+        s: { x: midX, y: maxY },
+        sw: { x: minX, y: maxY },
+        w: { x: minX, y: midY },
+        nw: { x: minX, y: minY },
+    }[handle];
+}
+function oppositeHandle(handle) {
+    return {
+        n: 's',
+        ne: 'sw',
+        e: 'w',
+        se: 'nw',
+        s: 'n',
+        sw: 'ne',
+        w: 'e',
+        nw: 'se',
+    }[handle];
+}
+export function getSpatialItemWorldHandlePoints(item, policy) {
+    const bounds = getSpatialItemLocalBounds(item);
+    if (!bounds)
+        return null;
+    const transform = normalizeSpatialTransform(item.transform, policy);
+    const points = {
+        n: itemLocalPointToMap(item, handleLocalPoint(bounds, 'n'), transform),
+        ne: itemLocalPointToMap(item, handleLocalPoint(bounds, 'ne'), transform),
+        e: itemLocalPointToMap(item, handleLocalPoint(bounds, 'e'), transform),
+        se: itemLocalPointToMap(item, handleLocalPoint(bounds, 'se'), transform),
+        s: itemLocalPointToMap(item, handleLocalPoint(bounds, 's'), transform),
+        sw: itemLocalPointToMap(item, handleLocalPoint(bounds, 'sw'), transform),
+        w: itemLocalPointToMap(item, handleLocalPoint(bounds, 'w'), transform),
+        nw: itemLocalPointToMap(item, handleLocalPoint(bounds, 'nw'), transform),
+        rotate: { x: 0, y: 0 },
+    };
+    const top = points.n;
+    const outward = itemLocalDirectionToMap(item, { x: 0, y: -1 });
+    const rotateGap = Math.max(28, Math.min(56, bounds.height * 0.35));
+    points.rotate = {
+        x: top.x + outward.x * rotateGap,
+        y: top.y + outward.y * rotateGap,
+    };
+    return points;
+}
+export function getSpatialZoneWorldHandlePoints(zone, policy) {
+    const bounds = getSpatialZoneMapBounds(zone);
+    if (!bounds)
+        return null;
+    const transform = normalizeSpatialTransform(zone.transform, policy);
+    const points = {
+        n: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 'n'), transform),
+        ne: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 'ne'), transform),
+        e: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 'e'), transform),
+        se: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 'se'), transform),
+        s: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 's'), transform),
+        sw: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 'sw'), transform),
+        w: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 'w'), transform),
+        nw: zoneLocalPointToMap(zone, handleLocalPoint(bounds, 'nw'), transform),
+        rotate: { x: 0, y: 0 },
+    };
+    const top = points.n;
+    const outward = zoneLocalDirectionToMap(zone, { x: 0, y: -1 });
+    const rotateGap = Math.max(28, Math.min(56, bounds.height * 0.35));
+    points.rotate = {
+        x: top.x + outward.x * rotateGap,
+        y: top.y + outward.y * rotateGap,
+    };
+    return points;
+}
+export function getSpatialZonePolygonPoints(zone) {
+    if (zone.shape.type !== 'polygon')
+        return null;
+    const points = parsePolygonPoints(zone.shape.points);
+    return points.length >= 3 ? points : null;
+}
+export function getSpatialZonePolygonHandles(zone, policy) {
+    const points = getSpatialZonePolygonPoints(zone);
+    if (!points)
+        return null;
+    const transform = normalizeSpatialTransform(zone.transform, policy);
+    const vertices = points.map((point, index) => ({
+        index,
+        point: zoneLocalPointToMap(zone, point, transform),
+    }));
+    const segments = points.map((point, index) => {
+        const next = points[(index + 1) % points.length];
+        return {
+            index,
+            point: zoneLocalPointToMap(zone, {
+                x: (point.x + next.x) / 2,
+                y: (point.y + next.y) / 2,
+            }, transform),
+        };
+    });
+    return { vertices, segments };
+}
+function normalizePolygonWorldPoint(zone, point, rect, policy) {
+    const bounded = policy.bounds === 'viewBox' ? clampPointToRect(point, rect) : point;
+    return roundPoint(mapPointToZoneLocal(zone, bounded, policy), policy.coordinatePrecision);
+}
+export function moveSpatialZonePolygonVertex(zone, args) {
+    const points = getSpatialZonePolygonPoints(zone);
+    if (!points || args.vertexIndex < 0 || args.vertexIndex >= points.length)
+        return zone;
+    const nextPoints = points.map((point, index) => (index === args.vertexIndex
+        ? normalizePolygonWorldPoint(zone, args.worldPoint, args.rect, args.policy)
+        : point));
+    return {
+        ...zone,
+        shape: {
+            type: 'polygon',
+            points: nextPoints,
+        },
+    };
+}
+export function insertSpatialZonePolygonVertex(zone, args) {
+    const points = getSpatialZonePolygonPoints(zone);
+    if (!points || args.segmentIndex < 0 || args.segmentIndex >= points.length)
+        return zone;
+    const nextPoint = normalizePolygonWorldPoint(zone, args.worldPoint, args.rect, args.policy);
+    const nextPoints = [
+        ...points.slice(0, args.segmentIndex + 1),
+        nextPoint,
+        ...points.slice(args.segmentIndex + 1),
+    ];
+    return {
+        ...zone,
+        shape: {
+            type: 'polygon',
+            points: nextPoints,
+        },
+    };
+}
+export function deleteSpatialZonePolygonVertex(zone, args) {
+    const points = getSpatialZonePolygonPoints(zone);
+    if (!points || points.length <= 3 || args.vertexIndex < 0 || args.vertexIndex >= points.length)
+        return zone;
+    return {
+        ...zone,
+        shape: {
+            type: 'polygon',
+            points: points.filter((_, index) => index !== args.vertexIndex),
+        },
+    };
+}
+export function getSpatialZoneTransformedBounds(zone, policy) {
+    const bounds = getSpatialZoneMapBounds(zone);
+    if (!bounds)
+        return null;
+    const transform = normalizeSpatialTransform(zone.transform, policy);
+    const corners = [
+        handleLocalPoint(bounds, 'nw'),
+        handleLocalPoint(bounds, 'ne'),
+        handleLocalPoint(bounds, 'se'),
+        handleLocalPoint(bounds, 'sw'),
+    ].map((point) => zoneLocalPointToMap(zone, point, transform));
+    const xs = corners.map((point) => point.x);
+    const ys = corners.map((point) => point.y);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minY = Math.min(...ys);
+    const maxY = Math.max(...ys);
+    return {
+        x: minX,
+        y: minY,
+        width: maxX - minX,
+        height: maxY - minY,
+    };
+}
+export function resizeSpatialItem(item, args) {
+    const bounds = getSpatialItemLocalBounds(item);
+    if (!bounds)
+        return item;
+    const current = normalizeSpatialTransform(item.transform, args.policy);
+    const anchor = handleLocalPoint(bounds, oppositeHandle(args.handle));
+    const active = handleLocalPoint(bounds, args.handle);
+    const widthDenominator = active.x - anchor.x;
+    const heightDenominator = active.y - anchor.y;
+    const scaledLocalPoint = {
+        x: args.localPoint.x * current.scaleX,
+        y: args.localPoint.y * current.scaleY,
+    };
+    const scaledAnchor = {
+        x: anchor.x * current.scaleX,
+        y: anchor.y * current.scaleY,
+    };
+    let nextScaleX = current.scaleX;
+    let nextScaleY = current.scaleY;
+    if (widthDenominator !== 0) {
+        nextScaleX = Math.abs((scaledLocalPoint.x - scaledAnchor.x) / widthDenominator);
+    }
+    if (heightDenominator !== 0) {
+        nextScaleY = Math.abs((scaledLocalPoint.y - scaledAnchor.y) / heightDenominator);
+    }
+    if (args.preserveAspectRatio) {
+        const dominant = Math.abs(nextScaleX - current.scaleX) >= Math.abs(nextScaleY - current.scaleY)
+            ? nextScaleX
+            : nextScaleY;
+        if (widthDenominator !== 0)
+            nextScaleX = dominant;
+        if (heightDenominator !== 0)
+            nextScaleY = dominant;
+    }
+    const transform = normalizeSpatialTransform({ scaleX: nextScaleX, scaleY: nextScaleY }, args.policy);
+    const anchorBefore = itemLocalPointToMap(item, anchor, current);
+    const rotatedAnchorAfter = rotatePoint({ x: anchor.x * transform.scaleX, y: anchor.y * transform.scaleY }, item.rotation ?? 0);
+    return {
+        ...item,
+        position: {
+            x: anchorBefore.x - rotatedAnchorAfter.x,
+            y: anchorBefore.y - rotatedAnchorAfter.y,
+        },
+        transform,
+    };
+}
+export function resizeSpatialZone(zone, args) {
+    const bounds = getSpatialZoneMapBounds(zone);
+    if (!bounds)
+        return zone;
+    const current = normalizeSpatialTransform(zone.transform, args.policy);
+    const anchor = handleLocalPoint(bounds, oppositeHandle(args.handle));
+    const active = handleLocalPoint(bounds, args.handle);
+    const widthDenominator = active.x - anchor.x;
+    const heightDenominator = active.y - anchor.y;
+    const scaledLocalPoint = {
+        x: args.localPoint.x * current.scaleX,
+        y: args.localPoint.y * current.scaleY,
+    };
+    const scaledAnchor = {
+        x: anchor.x * current.scaleX,
+        y: anchor.y * current.scaleY,
+    };
+    let nextScaleX = current.scaleX;
+    let nextScaleY = current.scaleY;
+    if (widthDenominator !== 0) {
+        nextScaleX = Math.abs((scaledLocalPoint.x - scaledAnchor.x) / widthDenominator);
+    }
+    if (heightDenominator !== 0) {
+        nextScaleY = Math.abs((scaledLocalPoint.y - scaledAnchor.y) / heightDenominator);
+    }
+    if (args.preserveAspectRatio) {
+        const dominant = Math.abs(nextScaleX - current.scaleX) >= Math.abs(nextScaleY - current.scaleY)
+            ? nextScaleX
+            : nextScaleY;
+        if (widthDenominator !== 0)
+            nextScaleX = dominant;
+        if (heightDenominator !== 0)
+            nextScaleY = dominant;
+    }
+    const transform = normalizeSpatialTransform({ scaleX: nextScaleX, scaleY: nextScaleY }, args.policy);
+    const anchorBefore = zoneLocalPointToMap(zone, anchor, current);
+    const rotatedAnchorAfter = rotatePoint({ x: anchor.x * transform.scaleX, y: anchor.y * transform.scaleY }, zone.rotation ?? 0);
+    return {
+        ...zone,
+        position: {
+            x: anchorBefore.x - rotatedAnchorAfter.x,
+            y: anchorBefore.y - rotatedAnchorAfter.y,
+        },
+        transform,
+    };
+}
+export function normalizeSpatialRotation(rotation) {
+    if (!Number.isFinite(rotation))
+        return 0;
+    let normalized = rotation % 360;
+    if (normalized >= 180)
+        normalized -= 360;
+    if (normalized < -180)
+        normalized += 360;
+    return normalized;
+}
+export function rotateSpatialItem(item, rotation, policy) {
+    const step = policy.rotationStep;
+    const snapped = step > 0 ? Math.round(rotation / step) * step : rotation;
+    return {
+        ...item,
+        rotation: normalizeSpatialRotation(snapped),
+    };
+}
+function sameSpatialTransform(a, b, policy) {
+    const left = normalizeSpatialTransform(a, policy);
+    const right = normalizeSpatialTransform(b, policy);
+    return left.scaleX === right.scaleX && left.scaleY === right.scaleY;
+}
+function nearestGridValue(value, size, offset) {
+    return offset + Math.round((value - offset) / size) * size;
+}
+function keyboardGridValue(origin, delta, size, offset) {
+    const direction = delta < 0 ? -1 : 1;
+    const steps = Math.max(1, Math.round(Math.abs(delta) / size));
+    const originRatio = (origin - offset) / size;
+    const originStop = direction > 0
+        ? Math.floor(originRatio)
+        : Math.ceil(originRatio);
+    return offset + (originStop + direction * steps) * size;
+}
+function uniqueSources(guides) {
+    const seen = new Set();
+    const sources = [];
+    for (const guide of guides) {
+        if (!seen.has(guide.source)) {
+            seen.add(guide.source);
+            sources.push(guide.source);
+        }
+    }
+    return sources;
+}
+function candidateWins(candidate, current) {
+    if (!current)
+        return true;
+    if (candidate.distance < current.distance)
+        return true;
+    return candidate.distance === current.distance && candidate.source === 'item-center';
+}
+function axisValue(point, axis) {
+    return axis === 'x' ? point.x : point.y;
+}
+function axisPoint(point, axis, value) {
+    return axis === 'x'
+        ? { x: value, y: point.y }
+        : { x: point.x, y: value };
+}
+export function resolveSpatialEditPoint(args) {
+    const boundedRaw = args.policy.bounds === 'viewBox'
+        ? clampPointToRect(args.rawPoint, args.rect)
+        : args.rawPoint;
+    let point = boundedRaw;
+    const guidesByAxis = {};
+    if (args.policy.snap.enabled) {
+        if (args.policy.snap.grid.enabled) {
+            for (const axis of ['x', 'y']) {
+                const value = axisValue(point, axis);
+                const size = args.policy.snap.grid.size[axis];
+                const offset = args.policy.snap.grid.offset[axis];
+                const keyboardIntent = args.intent?.kind === 'keyboard' ? args.intent : undefined;
+                const intentDelta = keyboardIntent ? keyboardIntent.delta[axis] : 0;
+                let usesKeyboardGridStep = false;
+                let position = nearestGridValue(value, size, offset);
+                if (keyboardIntent && intentDelta !== 0) {
+                    usesKeyboardGridStep = true;
+                    position = keyboardGridValue(keyboardIntent.origin[axis], intentDelta, size, offset);
+                }
+                const distance = usesKeyboardGridStep ? 0 : Math.abs(position - value);
+                if (usesKeyboardGridStep || distance <= args.policy.snap.grid.threshold) {
+                    guidesByAxis[axis] = {
+                        axis,
+                        source: 'grid',
+                        value: position,
+                        distance,
+                    };
+                }
+            }
+        }
+        if (args.policy.snap.itemCenters.enabled) {
+            for (const candidateItem of args.items ?? []) {
+                if (args.currentItemId !== undefined
+                    && String(candidateItem.id) === String(args.currentItemId)) {
+                    continue;
+                }
+                if (!Number.isFinite(candidateItem.position?.x) || !Number.isFinite(candidateItem.position?.y)) {
+                    continue;
+                }
+                for (const axis of ['x', 'y']) {
+                    const position = candidateItem.position[axis];
+                    const keyboardIntent = args.intent?.kind === 'keyboard' ? args.intent : undefined;
+                    const intentDelta = keyboardIntent ? keyboardIntent.delta[axis] : 0;
+                    const gridGuide = intentDelta !== 0 && guidesByAxis[axis]?.source === 'grid'
+                        ? guidesByAxis[axis]
+                        : undefined;
+                    if (keyboardIntent && intentDelta !== 0 && !gridGuide) {
+                        const origin = keyboardIntent.origin[axis];
+                        if ((intentDelta > 0 && position <= origin)
+                            || (intentDelta < 0 && position >= origin)) {
+                            continue;
+                        }
+                    }
+                    const comparisonValue = gridGuide ? gridGuide.value : axisValue(point, axis);
+                    const distance = Math.abs(position - comparisonValue);
+                    if (distance > args.policy.snap.itemCenters.threshold)
+                        continue;
+                    const candidate = {
+                        axis,
+                        source: 'item-center',
+                        value: position,
+                        distance,
+                        targetId: candidateItem.id,
+                    };
+                    if (candidateWins(candidate, guidesByAxis[axis])) {
+                        guidesByAxis[axis] = candidate;
+                    }
+                }
+            }
+        }
+        const axisGuides = ['x', 'y']
+            .map((axis) => guidesByAxis[axis])
+            .filter((guide) => Boolean(guide));
+        for (const guide of axisGuides) {
+            point = axisPoint(point, guide.axis, guide.value);
+        }
+    }
+    const snapGuides = ['x', 'y']
+        .map((axis) => guidesByAxis[axis])
+        .filter((guide) => Boolean(guide))
+        .map(({ distance: _distance, ...guide }) => guide);
+    const snapped = snapGuides.length > 0;
+    const boundedSnapped = args.policy.bounds === 'viewBox'
+        ? clampPointToRect(point, args.rect)
+        : point;
+    const roundedPoint = roundPoint(boundedSnapped, args.policy.coordinatePrecision);
+    return {
+        point: roundedPoint,
+        rawPoint: args.rawPoint,
+        snapped,
+        guides: snapGuides,
+        sources: uniqueSources(snapGuides),
+    };
+}
+export function isMovableSpatialItem(item) {
+    if (item.disabled)
+        return false;
+    return Number.isFinite(item.position?.x) && Number.isFinite(item.position?.y);
+}
+export function moveSpatialItem(item, position) {
+    return {
+        ...item,
+        position: { x: position.x, y: position.y },
+    };
+}
+export function moveSpatialZone(zone, position, rect, policy) {
+    return {
+        ...zone,
+        position: normalizeZonePosition(zone, position, rect, policy),
+    };
+}
+export function samePoint(a, b) {
+    return a.x === b.x && a.y === b.y;
+}
+export function hasSpatialItemChangedByType(args) {
+    const previousPosition = args.rect
+        ? normalizeEditPosition(args.previousItem.position, args.rect, args.policy)
+        : args.previousItem.position;
+    const nextPosition = args.rect
+        ? normalizeEditPosition(args.nextItem.position, args.rect, args.policy)
+        : args.nextItem.position;
+    if (args.changeType === 'move') {
+        return !samePoint(previousPosition, nextPosition);
+    }
+    if (args.changeType === 'resize') {
+        return !sameSpatialTransform(args.previousItem.transform, args.nextItem.transform, args.policy)
+            || !samePoint(previousPosition, nextPosition);
+    }
+    if (args.changeType === 'rotate') {
+        return normalizeSpatialRotation(args.previousItem.rotation ?? 0) !== normalizeSpatialRotation(args.nextItem.rotation ?? 0);
+    }
+    return args.previousItem !== args.nextItem;
+}
+export function hasSpatialZoneChangedByType(args) {
+    const previousPosition = getSpatialZonePosition(args.previousZone);
+    const nextPosition = getSpatialZonePosition(args.nextZone);
+    if (args.changeType === 'move') {
+        return !samePoint(previousPosition, nextPosition);
+    }
+    if (args.changeType === 'resize') {
+        return !sameSpatialTransform(args.previousZone.transform, args.nextZone.transform, args.policy)
+            || !samePoint(previousPosition, nextPosition);
+    }
+    if (args.changeType === 'rotate') {
+        return normalizeSpatialRotation(args.previousZone.rotation ?? 0) !== normalizeSpatialRotation(args.nextZone.rotation ?? 0);
+    }
+    if (args.changeType === 'shape') {
+        const previousPoints = getSpatialZonePolygonPoints(args.previousZone);
+        const nextPoints = getSpatialZonePolygonPoints(args.nextZone);
+        if (!previousPoints || !nextPoints) {
+            return previousPoints !== nextPoints;
+        }
+        if (previousPoints.length !== nextPoints.length) {
+            return true;
+        }
+        return previousPoints.some((point, index) => !samePoint(point, nextPoints[index]));
+    }
+    return args.previousZone !== args.nextZone;
+}
+export function buildSpatialItemChangeContext(args) {
+    const zone = args.nextItem.zoneId
+        ? args.zones.find((candidate) => candidate.id === args.nextItem.zoneId)
+        : undefined;
+    const previousPosition = args.previousItem?.position;
+    const position = args.nextItem.position;
+    const previousTransform = args.previousItem
+        ? normalizeSpatialTransform(args.previousItem.transform, args.policy)
+        : undefined;
+    const transform = normalizeSpatialTransform(args.nextItem.transform, args.policy);
+    const previousRotation = args.previousItem?.rotation ?? 0;
+    const rotation = args.nextItem.rotation ?? 0;
+    const previousLocalBounds = args.previousItem
+        ? getSpatialItemLocalBounds(args.previousItem) ?? undefined
+        : undefined;
+    const localBounds = getSpatialItemLocalBounds(args.nextItem) ?? undefined;
+    return {
+        kind: 'item-change',
+        changeType: args.changeType,
+        mode: args.mode,
+        itemId: args.nextItem.id,
+        zoneId: args.nextItem.zoneId,
+        previousItem: args.previousItem,
+        nextItem: args.nextItem,
+        item: args.nextItem,
+        ...(previousPosition ? { previousPosition } : {}),
+        position,
+        ...(previousPosition ? {
+            delta: {
+                x: position.x - previousPosition.x,
+                y: position.y - previousPosition.y,
+            },
+        } : {}),
+        previousTransform,
+        transform,
+        previousRotation,
+        rotation,
+        previousLocalBounds,
+        localBounds,
+        zone,
+    };
+}
+export function buildSpatialZoneChangeContext(args) {
+    const previousPosition = args.previousZone ? getSpatialZonePosition(args.previousZone) : undefined;
+    const position = getSpatialZonePosition(args.nextZone);
+    const previousTransform = args.previousZone
+        ? normalizeSpatialTransform(args.previousZone.transform, args.policy)
+        : undefined;
+    const transform = normalizeSpatialTransform(args.nextZone.transform, args.policy);
+    const previousRotation = args.previousZone?.rotation ?? 0;
+    const rotation = args.nextZone.rotation ?? 0;
+    const previousLocalBounds = args.previousZone
+        ? getSpatialZoneMapBounds(args.previousZone) ?? undefined
+        : undefined;
+    const localBounds = getSpatialZoneMapBounds(args.nextZone) ?? undefined;
+    const previousPoints = args.previousZone
+        ? getSpatialZonePolygonPoints(args.previousZone) ?? undefined
+        : undefined;
+    const points = getSpatialZonePolygonPoints(args.nextZone) ?? undefined;
+    return {
+        kind: 'zone-change',
+        changeType: args.changeType,
+        mode: args.mode,
+        zoneId: args.nextZone.id,
+        previousZone: args.previousZone,
+        nextZone: args.nextZone,
+        zone: args.nextZone,
+        ...(previousPosition ? { previousPosition } : {}),
+        position,
+        ...(previousPosition ? {
+            delta: {
+                x: position.x - previousPosition.x,
+                y: position.y - previousPosition.y,
+            },
+        } : {}),
+        previousTransform,
+        transform,
+        previousRotation,
+        rotation,
+        previousLocalBounds,
+        localBounds,
+        ...(args.changeType === 'shape' ? {
+            ...(args.previousZone ? { previousShape: args.previousZone.shape } : {}),
+            shape: args.nextZone.shape,
+            ...(previousPoints ? { previousPoints } : {}),
+            ...(points ? { points } : {}),
+            ...(typeof args.vertexIndex === 'number' ? { vertexIndex: args.vertexIndex } : {}),
+            ...(typeof args.segmentIndex === 'number' ? { segmentIndex: args.segmentIndex } : {}),
+            ...(args.shapeAction ? { shapeAction: args.shapeAction } : {}),
+        } : {}),
+    };
+}
+export function buildItemChangeContext(args) {
+    return buildSpatialItemChangeContext({
+        ...args,
+        changeType: 'move',
+        policy: args.policy ?? getEditPolicy(args.mode),
+    });
+}
+//# sourceMappingURL=spatial-map-editing.js.map