ducjs 1.0.0

package/dist/legacy/v1/utils/bounds.js

@@ -0,0 +1,415 @@
+import { getCubicBezierBoundingBox, getQuadraticBezierBoundingBox, rescaleLines, rescalePoints } from "ducjs/legacy/v1/utils/math";
+import { rotate } from "ducjs/legacy/v1/utils/math";
+import { isFreeDrawElement, isLinearElement, isTextElement, isArrowElement } from "ducjs/legacy/v1/types/elements/typeChecks";
+import { getBoundTextElementPosition, getLinearElementAbsoluteCoords } from "ducjs/legacy/v1/utils/elements/linearElement";
+export const getElementAbsoluteCoords = (element, elementsMap, currentScope, includeBoundText = false, returnUnrotatedBoundsOnly = true) => {
+    if (isFreeDrawElement(element)) {
+        return getFreeDrawElementAbsoluteCoords(element);
+    }
+    else if (isLinearElement(element)) {
+        return getLinearElementAbsoluteCoords(element, elementsMap, includeBoundText, currentScope, returnUnrotatedBoundsOnly);
+    }
+    else if (isTextElement(element)) {
+        const container = elementsMap
+            ? getContainerElement(element, elementsMap)
+            : null;
+        if (isArrowElement(container)) {
+            const coords = getBoundTextElementPosition(container, element, elementsMap, currentScope);
+            if (coords === null) {
+                return [
+                    element.x.scoped,
+                    element.y.scoped,
+                    element.x.scoped + element.width.scoped,
+                    element.y.scoped + element.height.scoped,
+                    element.x.scoped + element.width.scoped / 2,
+                    element.y.scoped + element.height.scoped / 2,
+                ];
+            }
+            return [
+                coords.x,
+                coords.y,
+                coords.x + element.width.scoped,
+                coords.y + element.height.scoped,
+                coords.x + element.width.scoped / 2,
+                coords.y + element.height.scoped / 2,
+            ];
+        }
+    }
+    return [
+        element.x.scoped,
+        element.y.scoped,
+        element.x.scoped + element.width.scoped,
+        element.y.scoped + element.height.scoped,
+        element.x.scoped + element.width.scoped / 2,
+        element.y.scoped + element.height.scoped / 2,
+    ];
+};
+/**
+ * Calculates bounds from a list of points (basic implementation)
+ */
+export const calculatePointsBounds = (points) => {
+    if (points.length === 0) {
+        return {
+            minX: 0,
+            minY: 0,
+            maxX: 0,
+            maxY: 0,
+        };
+    }
+    return points.reduce((limits, { x, y }) => ({
+        minX: Math.min(limits.minX, x.scoped),
+        minY: Math.min(limits.minY, y.scoped),
+        maxX: Math.max(limits.maxX, x.scoped),
+        maxY: Math.max(limits.maxY, y.scoped),
+    }), {
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity,
+    });
+};
+/**
+ * Calculates bounds from a list of geometric points (for bounds.ts compatibility)
+ */
+export const calculateGeometricPointsBounds = (points) => {
+    if (points.length === 0) {
+        return {
+            minX: 0,
+            minY: 0,
+            maxX: 0,
+            maxY: 0,
+        };
+    }
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const { x, y } of points) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    }
+    return {
+        minX: minX,
+        minY: minY,
+        maxX: maxX,
+        maxY: maxY,
+    };
+};
+/**
+ * Processes Bezier curves from lines and updates bounds
+ */
+export const processBezierCurveBounds = (points, lines, initialBounds) => {
+    if (!lines || lines.length === 0) {
+        return initialBounds;
+    }
+    let { minX, minY, maxX, maxY } = initialBounds;
+    for (const line of lines) {
+        const startIndex = line[0].index;
+        const endIndex = line[1].index;
+        const startHandle = line[0].handle;
+        const endHandle = line[1].handle;
+        // Get the start and end points
+        const startPoint = points[startIndex];
+        const endPoint = points[endIndex];
+        if (!startPoint || !endPoint)
+            continue;
+        if (startHandle && endHandle) {
+            // Cubic Bezier curve segment (both handles present)
+            const p0 = { x: startPoint.x.scoped, y: startPoint.y.scoped };
+            const p1 = { x: startHandle.x.scoped, y: startHandle.y.scoped };
+            const p2 = { x: endHandle.x.scoped, y: endHandle.y.scoped };
+            const p3 = { x: endPoint.x.scoped, y: endPoint.y.scoped };
+            const bbox = getCubicBezierBoundingBox(p0, p1, p2, p3);
+            minX = Math.min(minX, bbox.minX);
+            minY = Math.min(minY, bbox.minY);
+            maxX = Math.max(maxX, bbox.maxX);
+            maxY = Math.max(maxY, bbox.maxY);
+        }
+        else if (startHandle || endHandle) {
+            // Quadratic Bezier curve segment (one handle present)
+            const controlHandle = startHandle || endHandle;
+            const p0 = { x: startPoint.x.scoped, y: startPoint.y.scoped };
+            const p1 = { x: controlHandle.x.scoped, y: controlHandle.y.scoped };
+            const p2 = { x: endPoint.x.scoped, y: endPoint.y.scoped };
+            const bbox = getQuadraticBezierBoundingBox(p0, p1, p2);
+            minX = Math.min(minX, bbox.minX);
+            minY = Math.min(minY, bbox.minY);
+            maxX = Math.max(maxX, bbox.maxX);
+            maxY = Math.max(maxY, bbox.maxY);
+        }
+        // For straight line segments, the points already cover the bounds
+    }
+    return { minX, minY, maxX, maxY };
+};
+/**
+ * Processes Bezier curves with rotation and absolute positioning
+ * Used for linear elements that need to account for rotation and absolute coordinates
+ */
+export const processRotatedAbsoluteBezierBounds = (points, lines, elementX, elementY, centerX, centerY, angle) => {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    if (!lines || lines.length === 0) {
+        return { minX, minY, maxX, maxY };
+    }
+    for (const line of lines) {
+        const startIndex = line[0].index;
+        const endIndex = line[1].index;
+        const startHandle = line[0].handle;
+        const endHandle = line[1].handle;
+        const startPoint = points[startIndex];
+        const endPoint = points[endIndex];
+        if (!startPoint || !endPoint)
+            continue;
+        // Convert to absolute coordinates
+        const absoluteStartPoint = {
+            x: elementX + startPoint.x.scoped,
+            y: elementY + startPoint.y.scoped,
+        };
+        const absoluteEndPoint = {
+            x: elementX + endPoint.x.scoped,
+            y: elementY + endPoint.y.scoped,
+        };
+        if (startHandle && endHandle) {
+            // Cubic Bezier curve segment
+            const absoluteStartHandle = {
+                x: elementX + startHandle.x.scoped,
+                y: elementY + startHandle.y.scoped,
+            };
+            const absoluteEndHandle = {
+                x: elementX + endHandle.x.scoped,
+                y: elementY + endHandle.y.scoped,
+            };
+            const p0 = rotate(absoluteStartPoint.x, absoluteStartPoint.y, centerX, centerY, angle);
+            const p1 = rotate(absoluteStartHandle.x, absoluteStartHandle.y, centerX, centerY, angle);
+            const p2 = rotate(absoluteEndHandle.x, absoluteEndHandle.y, centerX, centerY, angle);
+            const p3 = rotate(absoluteEndPoint.x, absoluteEndPoint.y, centerX, centerY, angle);
+            const bbox = getCubicBezierBoundingBox(p0, p1, p2, p3);
+            minX = Math.min(minX, bbox.minX);
+            minY = Math.min(minY, bbox.minY);
+            maxX = Math.max(maxX, bbox.maxX);
+            maxY = Math.max(maxY, bbox.maxY);
+        }
+        else if (startHandle || endHandle) {
+            // Quadratic Bezier curve segment
+            const controlHandle = startHandle || endHandle;
+            const absoluteControlHandle = {
+                x: elementX + controlHandle.x.scoped,
+                y: elementY + controlHandle.y.scoped,
+            };
+            const p0 = rotate(absoluteStartPoint.x, absoluteStartPoint.y, centerX, centerY, angle);
+            const p1 = rotate(absoluteControlHandle.x, absoluteControlHandle.y, centerX, centerY, angle);
+            const p2 = rotate(absoluteEndPoint.x, absoluteEndPoint.y, centerX, centerY, angle);
+            const bbox = getQuadraticBezierBoundingBox(p0, p1, p2);
+            minX = Math.min(minX, bbox.minX);
+            minY = Math.min(minY, bbox.minY);
+            maxX = Math.max(maxX, bbox.maxX);
+            maxY = Math.max(maxY, bbox.maxY);
+        }
+        else {
+            // Straight line segment - rotate the endpoints
+            const p0 = rotate(absoluteStartPoint.x, absoluteStartPoint.y, centerX, centerY, angle);
+            const p1 = rotate(absoluteEndPoint.x, absoluteEndPoint.y, centerX, centerY, angle);
+            minX = Math.min(minX, p0.x, p1.x);
+            minY = Math.min(minY, p0.y, p1.y);
+            maxX = Math.max(maxX, p0.x, p1.x);
+            maxY = Math.max(maxY, p0.y, p1.y);
+        }
+    }
+    return { minX, minY, maxX, maxY };
+};
+/**
+ * Processes Bezier curves without rotation (for relative coordinate systems)
+ * Used by getElementPointsCoords
+ */
+export const processRelativeBezierBounds = (points, lines, initialBounds) => {
+    let { minX, minY, maxX, maxY } = initialBounds;
+    if (!lines || lines.length === 0) {
+        return { minX, minY, maxX, maxY };
+    }
+    for (const line of lines) {
+        const p1_idx = line[0].index;
+        const p2_idx = line[1].index;
+        if (p1_idx < 0 || p1_idx >= points.length || p2_idx < 0 || p2_idx >= points.length) {
+            continue;
+        }
+        const p1 = points[p1_idx];
+        const p2 = points[p2_idx];
+        if (line[0].handle || line[1].handle) {
+            const p0 = { x: p1.x.scoped, y: p1.y.scoped };
+            const p3 = { x: p2.x.scoped, y: p2.y.scoped };
+            const h1 = line[0].handle;
+            const h2 = line[1].handle;
+            try {
+                if (h1 && h2) {
+                    const cp1 = { x: h1.x.scoped, y: h1.y.scoped };
+                    const cp2 = { x: h2.x.scoped, y: h2.y.scoped };
+                    const bbox = getCubicBezierBoundingBox(p0, cp1, cp2, p3);
+                    minX = Math.min(minX, bbox.minX);
+                    minY = Math.min(minY, bbox.minY);
+                    maxX = Math.max(maxX, bbox.maxX);
+                    maxY = Math.max(maxY, bbox.maxY);
+                }
+                else if (h1) {
+                    const cp1 = { x: h1.x.scoped, y: h1.y.scoped };
+                    const bbox = getQuadraticBezierBoundingBox(p0, cp1, p3);
+                    minX = Math.min(minX, bbox.minX);
+                    minY = Math.min(minY, bbox.minY);
+                    maxX = Math.max(maxX, bbox.maxX);
+                    maxY = Math.max(maxY, bbox.maxY);
+                }
+                else if (h2) {
+                    const cp2 = { x: h2.x.scoped, y: h2.y.scoped };
+                    const bbox = getQuadraticBezierBoundingBox(p0, cp2, p3);
+                    minX = Math.min(minX, bbox.minX);
+                    minY = Math.min(minY, bbox.minY);
+                    maxX = Math.max(maxX, bbox.maxX);
+                    maxY = Math.max(maxY, bbox.maxY);
+                }
+            }
+            catch (e) {
+                // ignore failed curve bound calculations
+            }
+        }
+    }
+    return { minX, minY, maxX, maxY };
+};
+/**
+ * Calculates bounds considering both points and Bezier curves defined by lines
+ */
+export const calculateShapeBounds = (points, lines) => {
+    // Start with the bounds from the actual points
+    const pointBounds = calculatePointsBounds(points);
+    // Consider Bezier curves defined by lines with handles
+    return processBezierCurveBounds(points, lines, pointBounds);
+};
+/**
+ * Extended bounds calculation that includes center coordinates
+ */
+export const calculatePointsBoundsWithCenter = (points) => {
+    const bounds = calculatePointsBounds(points);
+    return Object.assign(Object.assign({}, bounds), { cx: ((bounds.maxX + bounds.minX) / 2), cy: ((bounds.maxY + bounds.minY) / 2) });
+};
+export const getElementPointsCoords = (element, points) => {
+    var _a, _b, _c;
+    if (points.length === 0) {
+        return [
+            element.x.scoped,
+            element.y.scoped,
+            element.x.scoped,
+            element.y.scoped,
+        ];
+    }
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    // First, include all the actual points (these are always on the path)
+    for (const point of points) {
+        minX = Math.min(minX, point.x.scoped);
+        minY = Math.min(minY, point.y.scoped);
+        maxX = Math.max(maxX, point.x.scoped);
+        maxY = Math.max(maxY, point.y.scoped);
+    }
+    const lines = element.lines || [];
+    // Use the shared utility for relative Bezier bounds calculation
+    const bezierBounds = processRelativeBezierBounds(points, lines, { minX, minY, maxX, maxY });
+    minX = bezierBounds.minX;
+    minY = bezierBounds.minY;
+    maxX = bezierBounds.maxX;
+    maxY = bezierBounds.maxY;
+    // Account for stroke width
+    const strokeWidth = ((_c = (_b = (_a = element.stroke) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.width) === null || _c === void 0 ? void 0 : _c.scoped) || 0;
+    const strokeOffset = strokeWidth / 2;
+    minX -= strokeOffset;
+    minY -= strokeOffset;
+    maxX += strokeOffset;
+    maxY += strokeOffset;
+    return [
+        (minX + element.x.scoped),
+        (minY + element.y.scoped),
+        (maxX + element.x.scoped),
+        (maxY + element.y.scoped),
+    ];
+};
+export const getContainerElement = (element, elementsMap) => {
+    if (!element) {
+        return null;
+    }
+    if (element.containerId) {
+        return (elementsMap.get(element.containerId) ||
+            null);
+    }
+    return null;
+};
+export const getBoundsFromPoints = (points) => {
+    const bounds = calculateGeometricPointsBounds(points);
+    return [bounds.minX, bounds.minY, bounds.maxX, bounds.maxY];
+};
+export const getFreeDrawElementAbsoluteCoords = (element) => {
+    const [minX, minY, maxX, maxY] = getBoundsFromPoints(element.points.map((p) => ({ x: p.x.scoped, y: p.y.scoped })));
+    const x1 = minX + element.x.scoped;
+    const y1 = minY + element.y.scoped;
+    const x2 = maxX + element.x.scoped;
+    const y2 = maxY + element.y.scoped;
+    return [
+        x1,
+        y1,
+        x2,
+        y2,
+        (x1 + x2) / 2,
+        (y1 + y2) / 2,
+    ];
+};
+export const getBoundTextElementId = (container) => {
+    var _a, _b, _c;
+    return ((_a = container === null || container === void 0 ? void 0 : container.boundElements) === null || _a === void 0 ? void 0 : _a.length)
+        ? ((_c = (_b = container === null || container === void 0 ? void 0 : container.boundElements) === null || _b === void 0 ? void 0 : _b.find((ele) => ele.type === "text")) === null || _c === void 0 ? void 0 : _c.id) || null
+        : null;
+};
+export const getBoundTextElement = (element, elementsMap) => {
+    if (!element) {
+        return null;
+    }
+    const boundTextElementId = getBoundTextElementId(element);
+    if (boundTextElementId) {
+        return (elementsMap.get(boundTextElementId) ||
+            null);
+    }
+    return null;
+};
+export const getResizedElementAbsoluteCoords = (element, nextWidth, nextHeight, normalizePoints, currentScope) => {
+    if (!(isLinearElement(element) || isFreeDrawElement(element))) {
+        return [
+            element.x.scoped,
+            element.y.scoped,
+            (element.x.scoped + nextWidth),
+            (element.y.scoped + nextHeight),
+        ];
+    }
+    const pointsAfterYRescale = rescalePoints("y", nextHeight, element.points, normalizePoints, element.scope, currentScope);
+    const points = rescalePoints("x", nextWidth, pointsAfterYRescale, normalizePoints, element.scope, currentScope);
+    if (isFreeDrawElement(element)) {
+        const bounds = getBoundsFromPoints(points.map((p) => ({ x: p.x.scoped, y: p.y.scoped })));
+        const [minX, minY, maxX, maxY] = bounds;
+        return [
+            (minX + element.x.scoped),
+            (minY + element.y.scoped),
+            (maxX + element.x.scoped),
+            (maxY + element.y.scoped),
+        ];
+    }
+    else {
+        // Linear element
+        const linesAfterYRescale = element.lines
+            ? rescaleLines("y", nextHeight, element.lines, element.points, normalizePoints, element.scope, currentScope)
+            : [];
+        const rescaledLines = element.lines
+            ? rescaleLines("x", nextWidth, linesAfterYRescale, element.points, normalizePoints, element.scope, currentScope)
+            : [];
+        return getElementPointsCoords(Object.assign(Object.assign({}, element), { points, lines: rescaledLines }), points);
+    }
+};