ducjs 1.0.0

package/dist/utils/bounds.js

@@ -0,0 +1,414 @@
+import { isArrowElement, isFreeDrawElement, isLinearElement, isTextElement } from "ducjs/types/elements/typeChecks";
+import { getBoundTextElementPosition, getLinearElementAbsoluteCoords } from "ducjs/utils/elements/linearElement";
+import { getCubicBezierBoundingBox, getQuadraticBezierBoundingBox, rescaleLines, rescalePoints, rotate } from "ducjs/utils/math";
+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);
+    }
+};

package/dist/utils/constants.d.ts

@@ -0,0 +1,288 @@
+import { GridSettings, RawValue, SnapSettings } from "ducjs/types";
+import { DucElement, DucEllipseElement, DucFreeDrawElement, DucTextElement, ElementBackground, ElementStroke, FontFamilyValues } from "ducjs/types/elements";
+import { MAX_ZOOM, MIN_ZOOM } from "ducjs/technical/scopes";
+export declare const COLOR_PALETTE: {
+    readonly transparent: "transparent";
+    readonly black: "#1e1e1e";
+    readonly white: "#ffffff";
+    readonly midGray: "#808080";
+    readonly night: "#0F0F0F";
+};
+export declare const TEXT_AUTOWRAP_THRESHOLD = 36;
+export declare const DRAGGING_THRESHOLD = 10;
+export declare const LINE_CONFIRM_THRESHOLD = 8;
+export declare const FIXED_BINDING_DISTANCE = 5;
+export declare const ELEMENT_SHIFT_TRANSLATE_AMOUNT = 5;
+export declare const ELEMENT_TRANSLATE_AMOUNT = 1;
+export declare const TEXT_TO_CENTER_SNAP_THRESHOLD = 30;
+export declare const SHIFT_LOCKING_ANGLE: number;
+export declare const DEFAULT_GRID_SIZE = 1;
+export declare const DEFAULT_GRID_STEP = 20;
+export declare const SVG_NS = "http://www.w3.org/2000/svg";
+export declare const IMAGE_MIME_TYPES: {
+    readonly svg: "image/svg+xml";
+    readonly png: "image/png";
+    readonly jpg: "image/jpeg";
+    readonly gif: "image/gif";
+    readonly webp: "image/webp";
+    readonly bmp: "image/bmp";
+    readonly ico: "image/x-icon";
+    readonly avif: "image/avif";
+    readonly jfif: "image/jfif";
+};
+export declare const MIME_TYPES: {
+    readonly svg: "image/svg+xml";
+    readonly png: "image/png";
+    readonly jpg: "image/jpeg";
+    readonly gif: "image/gif";
+    readonly webp: "image/webp";
+    readonly bmp: "image/bmp";
+    readonly ico: "image/x-icon";
+    readonly avif: "image/avif";
+    readonly jfif: "image/jfif";
+    readonly json: "application/json";
+    readonly duc: "application/vnd.duc-cad";
+    readonly ducfig: "application/vnd.duc-config";
+    readonly excalidrawlib: "application/vnd.excalidrawlib+json";
+    readonly "excalidraw.svg": "image/svg+xml";
+    readonly "excalidraw.png": "image/png";
+    readonly binary: "application/octet-stream";
+};
+export declare const EXPORT_IMAGE_TYPES: {
+    readonly png: "png";
+    readonly svg: "svg";
+    readonly clipboard: "clipboard";
+};
+export declare const EXPORT_DATA_TYPES: {
+    readonly duc: "duc";
+    readonly json: "json";
+    readonly excalidrawClipboard: "excalidraw/clipboard";
+    readonly excalidrawLibrary: "excalidrawlib";
+    readonly excalidrawClipboardWithAPI: "excalidraw-api/clipboard";
+};
+export declare const VERSIONS: {
+    readonly excalidraw: 2;
+    readonly excalidrawLibrary: 2;
+};
+export declare const DEFAULT_ZOOM_STEP = 0.1;
+export declare const MIN_ZOOM_STEP = 1e-7;
+export declare const MAX_ZOOM_STEP = 5;
+export { MAX_ZOOM, MIN_ZOOM };
+export declare const BOUND_TEXT_PADDING = 5;
+export declare const ARROW_LABEL_WIDTH_FRACTION = 0.7;
+export declare const ARROW_LABEL_FONT_SIZE_TO_MIN_WIDTH_RATIO = 11;
+export declare const NO_PEER_POINTS: number[];
+export declare const ELEMENT_READY_TO_ERASE_OPACITY = 0.2;
+export declare const HIDE_FRAME_NAME_ZOOM_THRESHOLD = 0.18;
+export declare const DEFAULT_PROPORTIONAL_RADIUS = 0.25;
+export declare const DEFAULT_ADAPTIVE_RADIUS = 32;
+/**
+ * // TODO: shouldn't be really `const`, likely neither have integers as values, due to value for the custom fonts, which should likely be some hash.
+ *
+ * Let's think this through and consider:
+ * - https://developer.mozilla.org/en-US/docs/Web/CSS/generic-family
+ * - https://drafts.csswg.org/css-fonts-4/#font-family-prop
+ * - https://learn.microsoft.com/en-us/typography/opentype/spec/ibmfc
+ */
+export declare const FONT_FAMILY: {
+    Virgil: number;
+    Helvetica: number;
+    Cascadia: number;
+    Excalifont: number;
+    Nunito: number;
+    "Lilita One": number;
+    "Comic Shanns": number;
+    "Liberation Sans": number;
+    "Roboto Mono": number;
+};
+export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
+export declare const DEFAULT_VERSION = "{version}";
+export declare const MIN_FONT_SIZE = 1;
+export declare const DEFAULT_FONT_SIZE = 20;
+export declare const DEFAULT_FONT_FAMILY: FontFamilyValues;
+export declare const DEFAULT_TEXT_ALIGN: DucTextElement["textAlign"];
+export declare const DEFAULT_VERTICAL_ALIGN: DucTextElement["verticalAlign"];
+export declare const DEFAULT_LINE_HEIGHT = 1;
+export declare const DEFAULT_POLYGON_SIDES = 5;
+export declare const LIBRARY_DISABLED_TYPES: Set<"iframe" | "embeddable" | "image">;
+/**
+ * not translated as this is used only in public, stateless API as default value
+ * where filename is optional and we can't retrieve name from app state
+ */
+export declare const DEFAULT_FILENAME = "Untitled";
+export declare const MIN_WIDTH_OR_HEIGHT = 1;
+export declare const EASINGS: readonly ["linear", "easeInQuad", "easeOutQuad", "easeInOutQuad", "easeInCubic", "easeOutCubic", "easeInOutCubic", "easeInQuart", "easeOutQuart", "easeInOutQuart", "easeInQuint", "easeOutQuint", "easeInOutQuint", "easeInSine", "easeOutSine", "easeInOutSine", "easeInExpo", "easeOutExpo", "easeInOutExpo"];
+export type FreeDrawEasingNames = typeof EASINGS[number];
+export declare const FREEDRAW_EASINGS: Record<FreeDrawEasingNames, (t: number) => number>;
+export declare const DEFAULT_FRAME_STYLE: {
+    stroke: ElementStroke[];
+    background: ElementBackground[];
+    roundness: DucElement["roundness"];
+    radius: number;
+    nameOffsetY: number;
+    nameColorLightTheme: string;
+    nameColorDarkTheme: string;
+    nameFontSize: number;
+    nameLineHeight: number;
+};
+export declare const DEFAULT_ELEMENT_PROPS: {
+    isVisible: DucElement["isVisible"];
+    isPlot: DucElement["isPlot"];
+    isAnnotative: DucElement["isAnnotative"];
+    stroke: ElementStroke;
+    background: ElementBackground;
+    roundness: DucElement["roundness"];
+    opacity: DucElement["opacity"];
+    locked: DucElement["locked"];
+    scope: DucElement["scope"];
+    index: DucElement["index"];
+    width: DucElement["width"];
+    height: DucElement["height"];
+    angle: DucElement["angle"];
+    groupIds: DucElement["groupIds"];
+    boundElements: DucElement["boundElements"];
+    link: DucElement["link"];
+    frameId: DucElement["frameId"];
+    description: DucElement["description"];
+};
+export declare const DEFAULT_IFRAME_LIKE_NO_STYLE: {
+    stroke: ElementStroke[];
+    background: ElementBackground[];
+};
+export declare const DEFAULT_LINEAR_ELEMENT_STROKE: ElementStroke;
+export declare const DEFAULT_FREEDRAW_ELEMENT: {
+    size: RawValue;
+    thinning: DucFreeDrawElement["thinning"];
+    smoothing: DucFreeDrawElement["smoothing"];
+    streamline: DucFreeDrawElement["streamline"];
+    easing: DucFreeDrawElement["easing"];
+};
+export declare const DEFAULT_ELLIPSE_ELEMENT: {
+    ratio: DucEllipseElement["ratio"];
+    startAngle: DucEllipseElement["startAngle"];
+    endAngle: DucEllipseElement["endAngle"];
+    showAuxCrosshair: DucEllipseElement["showAuxCrosshair"];
+};
+/**
+ * Grid display types
+ */
+export declare const GRID_DISPLAY_TYPE: {
+    readonly LINES: 10;
+    readonly DOTS: 11;
+    readonly CROSSES: 12;
+    readonly ADAPTIVE: 13;
+};
+/**
+ * Grid coordinate system types
+ */
+export declare const GRID_TYPE: {
+    readonly RECTANGULAR: 10;
+    readonly ISOMETRIC: 11;
+    readonly POLAR: 12;
+    readonly TRIANGULAR: 13;
+    readonly CUSTOM: 14;
+};
+/**
+ * Default grid configurations
+ */
+export declare const DEFAULT_GRID_SETTINGS: GridSettings;
+/**
+ * Predefined grid configurations
+ */
+export declare const PREDEFINED_GRIDS: {
+    readonly ARCHITECTURAL_IMPERIAL: "arch-imperial";
+    readonly ARCHITECTURAL_METRIC: "arch-metric";
+    readonly ENGINEERING_IMPERIAL: "eng-imperial";
+    readonly ENGINEERING_METRIC: "eng-metric";
+    readonly ISOMETRIC_30: "iso-30";
+    readonly POLAR_DEGREES: "polar-deg";
+    readonly FINE_DETAIL: "fine-detail";
+};
+/**
+ * Snap behavior modes
+ */
+export declare const SNAP_MODE: {
+    readonly RUNNING: 10;
+    readonly SINGLE: 11;
+};
+/**
+ * Snap override behaviors
+ */
+export declare const SNAP_OVERRIDE_BEHAVIOR: {
+    readonly DISABLE: 10;
+    readonly FORCE_GRID: 11;
+    readonly FORCE_OBJECT: 12;
+};
+/**
+ * Snap marker shapes
+ */
+export declare const SNAP_MARKER_SHAPE: {
+    readonly SQUARE: 10;
+    readonly CIRCLE: 11;
+    readonly TRIANGLE: 12;
+    readonly X: 13;
+};
+/**
+ * Default snap settings configuration
+ */
+export declare const DEFAULT_SNAP_SETTINGS: SnapSettings;
+export declare const PAPER_SIZE: {
+    readonly A0: "A0";
+    readonly A1: "A1";
+    readonly A2: "A2";
+    readonly A3: "A3";
+    readonly A4: "A4";
+    readonly A5: "A5";
+    readonly ANSI_A: "ANSI_A";
+    readonly ANSI_B: "ANSI_B";
+    readonly ANSI_C: "ANSI_C";
+    readonly ANSI_D: "ANSI_D";
+    readonly ANSI_E: "ANSI_E";
+    readonly ARCH_A: "ARCH_A";
+    readonly ARCH_B: "ARCH_B";
+    readonly ARCH_C: "ARCH_C";
+    readonly ARCH_D: "ARCH_D";
+    readonly ARCH_E: "ARCH_E";
+    readonly CUSTOM: "CUSTOM";
+};
+export declare const PREDEFINED_HATCH_PATTERNS: {
+    readonly SOLID: "SOLID";
+    readonly ANSI31: "ANSI31";
+    readonly ANSI32: "ANSI32";
+    readonly ANSI33: "ANSI33";
+    readonly ANSI34: "ANSI34";
+    readonly ANSI35: "ANSI35";
+    readonly ANSI36: "ANSI36";
+    readonly ANSI37: "ANSI37";
+    readonly ANSI38: "ANSI38";
+    readonly AR_B816: "AR-B816";
+    readonly AR_B816C: "AR-B816C";
+    readonly AR_CONC: "AR-CONC";
+    readonly AR_HBONE: "AR-HBONE";
+    readonly AR_SAND: "AR-SAND";
+    readonly AR_RSHKE: "AR-RSHKE";
+    readonly ACAD_ISO02W100: "ACAD_ISO02W100";
+    readonly ACAD_ISO03W100: "ACAD_ISO03W100";
+    readonly ACAD_ISO04W100: "ACAD_ISO04W100";
+    readonly ACAD_ISO06W100: "ACAD_ISO06W100";
+    readonly ACAD_ISO08W100: "ACAD_ISO08W100";
+    readonly ACAD_ISO11W100: "ACAD_ISO11W100";
+    readonly ACAD_ISO13W100: "ACAD_ISO13W100";
+    readonly BOX: "BOX";
+    readonly BRICK: "BRICK";
+    readonly CROSS: "CROSS";
+    readonly DASH: "DASH";
+    readonly DOTS: "DOTS";
+    readonly EARTH: "EARTH";
+    readonly GRASS: "GRASS";
+    readonly GRAVEL: "GRAVEL";
+    readonly HEX: "HEX";
+    readonly HONEY: "HONEY";
+    readonly INSUL: "INSUL";
+    readonly LINE: "LINE";
+    readonly NET: "NET";
+    readonly SQUARE: "SQUARE";
+    readonly STEEL: "STEEL";
+    readonly TRIANG: "TRIANG";
+    readonly ZIGZAG: "ZIGZAG";
+};