ducjs 1.0.0

package/dist/utils/math/random.d.ts

@@ -0,0 +1,4 @@
+export declare function randomSeed(): number;
+export declare const randomInteger: () => number;
+export declare const reseed: (seed: number) => void;
+export declare const randomId: () => string;

package/dist/utils/math/random.js

@@ -0,0 +1,25 @@
+import { nanoid } from "nanoid";
+export function randomSeed() {
+    return Math.floor(Math.random() * Math.pow(2, 31));
+}
+class Random {
+    constructor(seed) {
+        this.seed = seed;
+    }
+    next() {
+        if (this.seed) {
+            return ((Math.pow(2, 31) - 1) & (this.seed = Math.imul(48271, this.seed))) / Math.pow(2, 31);
+        }
+        else {
+            return Math.random();
+        }
+    }
+}
+let random = new Random(Date.now());
+let testIdBase = 0;
+export const randomInteger = () => Math.floor(random.next() * Math.pow(2, 31));
+export const reseed = (seed) => {
+    random = new Random(seed);
+    testIdBase = 0;
+};
+export const randomId = () => nanoid();

package/dist/utils/normalize.d.ts

@@ -0,0 +1,14 @@
+import type { NormalizedZoomValue, ScopedValue } from "ducjs/types";
+import { DucElement, FixedPoint } from "ducjs/types/elements";
+export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
+export declare const getNormalizedGridSize: (gridStep: number) => number;
+export declare const getNormalizedGridStep: (gridStep: number) => number;
+export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;
+export declare const getNormalizedDimensions: (element: Pick<DucElement, "width" | "height" | "x" | "y">) => {
+    width: ScopedValue;
+    height: ScopedValue;
+    x: ScopedValue;
+    y: ScopedValue;
+};
+export declare const normalizeEOL: (str: string) => string;
+export declare const normalizeText: (text: string) => string;

package/dist/utils/normalize.js

@@ -0,0 +1,49 @@
+import { MAX_ZOOM, MIN_ZOOM } from "ducjs/utils/constants";
+import { clamp } from "ducjs/utils/math";
+export const getNormalizedZoom = (zoom) => {
+    return clamp(zoom, MIN_ZOOM, MAX_ZOOM);
+};
+export const getNormalizedGridSize = (gridStep) => {
+    return clamp(Math.round(gridStep), 1, 100);
+};
+export const getNormalizedGridStep = (gridStep) => {
+    return clamp(Math.round(gridStep), 1, 100);
+};
+export const normalizeFixedPoint = (fixedPoint) => {
+    // Do not allow a precise 0.5 for fixed point ratio
+    // to avoid jumping arrow heading due to floating point imprecision
+    if (fixedPoint && (fixedPoint.x === 0.5 || fixedPoint.y === 0.5)) {
+        return {
+            x: fixedPoint.x === 0.5 ? 0.5001 : fixedPoint.x,
+            y: fixedPoint.y === 0.5 ? 0.5001 : fixedPoint.y,
+        };
+    }
+    return fixedPoint;
+};
+export const getNormalizedDimensions = (element) => {
+    const ret = {
+        width: element.width.scoped,
+        height: element.height.scoped,
+        x: element.x.scoped,
+        y: element.y.scoped,
+    };
+    if (element.width.scoped < 0) {
+        const nextWidth = Math.abs(element.width.scoped);
+        ret.width = nextWidth;
+        ret.x = element.x.scoped - nextWidth;
+    }
+    if (element.height.scoped < 0) {
+        const nextHeight = Math.abs(element.height.scoped);
+        ret.height = nextHeight;
+        ret.y = element.y.scoped - nextHeight;
+    }
+    return ret;
+};
+export const normalizeEOL = (str) => {
+    return str.replace(/\r?\n|\r/g, "\n");
+};
+export const normalizeText = (text) => {
+    return (normalizeEOL(text)
+        // replace tabs with spaces so they render and measure correctly
+        .replace(/\t/g, "        "));
+};

package/dist/utils/shape.d.ts

@@ -0,0 +1,15 @@
+import { Scope } from "ducjs/types";
+import { DucElement, DucLine, DucLinearElement, DucNonSelectionElement, DucPath, DucPoint } from "ducjs/types/elements";
+/**
+ * Converts a shape (rectangle, polygon, ellipse) to a linear element
+ */
+export declare const convertShapeToLinearElement: (currentScope: Scope, element: DucNonSelectionElement) => DucLinearElement | null;
+export declare const getCorrectedOrthodoxElementPoints: (element: DucElement, points: readonly DucPoint[], lines: readonly DucLine[], currentScope: Scope) => {
+    points: DucPoint[];
+    lines: DucLine[];
+};
+export declare const getElementRelativePoints: (element: DucElement, currentScope: Scope) => {
+    points: DucLinearElement["points"];
+    lines: DucLinearElement["lines"];
+    pathOverrides?: DucPath[];
+};

package/dist/utils/shape.js

@@ -0,0 +1,254 @@
+import { BEZIER_MIRRORING } from "ducjs/flatbuffers/duc";
+import { isArrowElement, isEllipseElement, isFreeDrawElement, isLinearElement, isPolygonElement } from "ducjs/types/elements/typeChecks";
+import { calculateShapeBounds } from "ducjs/utils/bounds";
+import { getBaseElementProps } from "ducjs/utils/elements";
+import { getNormalizedPoints, mergeOverlappingPoints } from "ducjs/utils/elements/linearElement";
+import { newLinearElement } from "ducjs/utils/elements/newElement";
+import { rotatePoint } from "ducjs/utils/math";
+import { getPrecisionValueFromRaw, getPrecisionValueFromScoped } from "ducjs/technical/scopes";
+/**
+ * Converts a shape (rectangle, polygon, ellipse) to a linear element
+ */
+export const convertShapeToLinearElement = (currentScope, element) => {
+    if (!element)
+        return null;
+    const { points, lines, pathOverrides } = getElementRelativePoints(element, currentScope);
+    // Create a new linear element based on the shape's points
+    const linearElement = newLinearElement(currentScope, Object.assign(Object.assign({}, getBaseElementProps(element)), { type: "line", points,
+        lines,
+        pathOverrides }));
+    const normalizedLinearElement = getNormalizedPoints(linearElement, currentScope);
+    return Object.assign(Object.assign({}, linearElement), normalizedLinearElement);
+};
+/**
+ * @returns vertices relative to element's top-left {x: 0, y: 0} position
+ * */
+const getNonLinearElementRelativePoints = (element, currentScope) => {
+    var _a;
+    if (isPolygonElement(element)) {
+        const numSides = element.sides;
+        const width = element.width.scoped;
+        const height = element.height.scoped;
+        const centerX = width / 2;
+        const centerY = height / 2;
+        const radiusX = width / 2;
+        const radiusY = height / 2;
+        const points = [];
+        const lines = [];
+        let pathOverrides = undefined;
+        // Generate polygon vertices inscribed in the ellipse
+        for (let i = 0; i < numSides; i++) {
+            // Calculate the base angle for this vertex
+            const baseAngle = (2 * Math.PI * i) / numSides - Math.PI / 2; // Start at top
+            // Calculate point on ellipse using the rotated angle
+            const x = centerX + radiusX * Math.cos(baseAngle);
+            const y = centerY + radiusY * Math.sin(baseAngle);
+            points.push({
+                x: getPrecisionValueFromScoped(x, element.scope, currentScope),
+                y: getPrecisionValueFromScoped(y, element.scope, currentScope),
+            });
+        }
+        // Create lines connecting consecutive vertices (closed polygon)
+        for (let i = 0; i < numSides; i++) {
+            const currentIndex = i;
+            const nextIndex = (i + 1) % numSides; // Wrap around to 0 for the last vertex
+            lines.push([
+                { index: currentIndex, handle: null },
+                { index: nextIndex, handle: null }
+            ]);
+        }
+        // Apply the correction for polygon points after generation
+        const corrected = getCorrectedOrthodoxElementPoints(element, points, lines, currentScope);
+        return { points: corrected.points, lines: corrected.lines, pathOverrides };
+    }
+    if (isEllipseElement(element)) {
+        const { width, ratio, startAngle, endAngle } = element;
+        const height = (_a = element.height) !== null && _a !== void 0 ? _a : width;
+        if (width.scoped <= 0 || height.scoped <= 0) {
+            return { points: [], lines: [] };
+        }
+        const rx = width.scoped / 2;
+        const ry = height.scoped / 2;
+        const cx = width.scoped / 2;
+        const cy = height.scoped / 2;
+        const epsilon = 1e-6;
+        const sweepAngle = endAngle - startAngle;
+        const isFullShape = Math.abs(sweepAngle) >= 2 * Math.PI - epsilon;
+        const allPoints = [];
+        const allLines = [];
+        let pathOverrides = undefined;
+        const createArc = (radiusX, radiusY, sAngle, eAngle) => {
+            const arcPoints = [];
+            const arcLines = [];
+            const sweep = eAngle - sAngle;
+            if (Math.abs(sweep) < epsilon) {
+                return { points: arcPoints, lines: arcLines };
+            }
+            const nSegments = Math.ceil(Math.abs(sweep) / (Math.PI / 2));
+            const segmentSweep = sweep / nSegments;
+            for (let i = 0; i < nSegments; i++) {
+                const angle0 = sAngle + i * segmentSweep;
+                const angle1 = sAngle + (i + 1) * segmentSweep;
+                const p0 = { x: cx + radiusX * Math.cos(angle0), y: cy + radiusY * Math.sin(angle0) };
+                if (i === 0) {
+                    arcPoints.push({
+                        x: getPrecisionValueFromScoped(p0.x, element.scope, currentScope),
+                        y: getPrecisionValueFromScoped(p0.y, element.scope, currentScope),
+                        mirroring: BEZIER_MIRRORING.ANGLE_LENGTH,
+                    });
+                }
+                const p3 = { x: cx + radiusX * Math.cos(angle1), y: cy + radiusY * Math.sin(angle1) };
+                arcPoints.push({
+                    x: getPrecisionValueFromScoped(p3.x, element.scope, currentScope),
+                    y: getPrecisionValueFromScoped(p3.y, element.scope, currentScope),
+                    mirroring: BEZIER_MIRRORING.ANGLE_LENGTH,
+                });
+                const k = (4 / 3) * Math.tan(segmentSweep / 4);
+                const t0 = { x: -radiusX * Math.sin(angle0), y: radiusY * Math.cos(angle0) };
+                const t1 = { x: -radiusX * Math.sin(angle1), y: radiusY * Math.cos(angle1) };
+                const cp1 = { x: p0.x + t0.x * k, y: p0.y + t0.y * k };
+                const cp2 = { x: p3.x - t1.x * k, y: p3.y - t1.y * k };
+                arcLines.push([
+                    {
+                        index: i,
+                        handle: {
+                            x: getPrecisionValueFromScoped(cp1.x, element.scope, currentScope),
+                            y: getPrecisionValueFromScoped(cp1.y, element.scope, currentScope),
+                        },
+                    },
+                    {
+                        index: i + 1,
+                        handle: {
+                            x: getPrecisionValueFromScoped(cp2.x, element.scope, currentScope),
+                            y: getPrecisionValueFromScoped(cp2.y, element.scope, currentScope),
+                        },
+                    },
+                ]);
+            }
+            return { points: arcPoints, lines: arcLines };
+        };
+        const addPathToElement = (pointsToAdd, linesToAdd) => {
+            const pointIndices = Array.from({ length: pointsToAdd.length }, (_, i) => allPoints.length + i);
+            const lineStartIdx = allLines.length;
+            allPoints.push(...pointsToAdd);
+            for (const line of linesToAdd) {
+                line[0].index = pointIndices[line[0].index];
+                line[1].index = pointIndices[line[1].index];
+                allLines.push(line);
+            }
+            const lineIndices = Array.from({ length: allLines.length - lineStartIdx }, (_, i) => lineStartIdx + i);
+            return { pointIndices, lineIndices };
+        };
+        const outerArcResult = createArc(rx, ry, startAngle, endAngle);
+        const { pointIndices: outerIndices } = addPathToElement(outerArcResult.points, outerArcResult.lines);
+        const hasHole = ratio > epsilon && ratio < 1 - epsilon;
+        if (hasHole) {
+            const rxInner = rx * (1 - ratio);
+            const ryInner = ry * (1 - ratio);
+            const innerArcResult = createArc(rxInner, ryInner, endAngle, startAngle);
+            if (innerArcResult.points.length > 0) {
+                const { pointIndices: innerIndices, lineIndices: innerLineIndices } = addPathToElement(innerArcResult.points, innerArcResult.lines);
+                if (isFullShape) {
+                    pathOverrides = [{
+                            lineIndices: innerLineIndices,
+                            background: element.background.length > 0 ? Object.assign(Object.assign({}, element.background[0]), { content: Object.assign(Object.assign({}, element.background[0].content), { visible: false }) }) : null,
+                            stroke: null,
+                        }];
+                }
+                else {
+                    const outerStartIdx = outerIndices[0];
+                    const outerEndIdx = outerIndices[outerIndices.length - 1];
+                    const innerStartIdx = innerIndices[0];
+                    const innerEndIdx = innerIndices[innerIndices.length - 1];
+                    allPoints[outerStartIdx].mirroring = BEZIER_MIRRORING.NONE;
+                    allPoints[outerEndIdx].mirroring = BEZIER_MIRRORING.NONE;
+                    allPoints[innerStartIdx].mirroring = BEZIER_MIRRORING.NONE;
+                    allPoints[innerEndIdx].mirroring = BEZIER_MIRRORING.NONE;
+                    allLines.push([{ index: outerEndIdx, handle: null }, { index: innerStartIdx, handle: null }]);
+                    allLines.push([{ index: innerEndIdx, handle: null }, { index: outerStartIdx, handle: null }]);
+                }
+            }
+        }
+        else if (!isFullShape) { // Pie slice (no hole)
+            const centerPoint = {
+                x: getPrecisionValueFromScoped(cx, element.scope, currentScope),
+                y: getPrecisionValueFromScoped(cy, element.scope, currentScope),
+                mirroring: BEZIER_MIRRORING.NONE,
+            };
+            const centerIndex = allPoints.length;
+            allPoints.push(centerPoint);
+            const outerStartIndex = outerIndices[0];
+            const outerEndIndex = outerIndices[outerIndices.length - 1];
+            allPoints[outerStartIndex].mirroring = BEZIER_MIRRORING.NONE;
+            allPoints[outerEndIndex].mirroring = BEZIER_MIRRORING.NONE;
+            allLines.push([{ index: outerEndIndex, handle: null }, { index: centerIndex, handle: null }]);
+            allLines.push([{ index: centerIndex, handle: null }, { index: outerStartIndex, handle: null }]);
+        }
+        // Merge any overlapping points that may have been introduced
+        const merged = mergeOverlappingPoints(allPoints, allLines);
+        const corrected = getCorrectedOrthodoxElementPoints(element, merged.points, merged.lines, currentScope);
+        return { points: corrected.points, lines: corrected.lines, pathOverrides };
+    }
+    // Default case: rectangle/square
+    const points = [
+        {
+            x: getPrecisionValueFromRaw(0, element.scope, currentScope),
+            y: getPrecisionValueFromRaw(0, element.scope, currentScope),
+        },
+        {
+            x: getPrecisionValueFromScoped(element.width.scoped, element.scope, currentScope),
+            y: getPrecisionValueFromRaw(0, element.scope, currentScope),
+        },
+        {
+            x: getPrecisionValueFromScoped(element.width.scoped, element.scope, currentScope),
+            y: getPrecisionValueFromScoped(element.height.scoped, element.scope, currentScope),
+        },
+        {
+            x: getPrecisionValueFromRaw(0, element.scope, currentScope),
+            y: getPrecisionValueFromScoped(element.height.scoped, element.scope, currentScope),
+        },
+    ];
+    // Create lines for rectangle: top, right, bottom, left
+    const lines = [
+        [{ index: 0, handle: null }, { index: 1, handle: null }],
+        [{ index: 1, handle: null }, { index: 2, handle: null }],
+        [{ index: 2, handle: null }, { index: 3, handle: null }],
+        [{ index: 3, handle: null }, { index: 0, handle: null }],
+    ];
+    return { points, lines };
+};
+export const getCorrectedOrthodoxElementPoints = (element, points, lines, currentScope) => {
+    const { minX, minY, maxX, maxY } = calculateShapeBounds(points, lines);
+    const polygonCenter = {
+        x: element.width.scoped / 2,
+        y: element.height.scoped / 2,
+    };
+    const bboxCenter = {
+        x: minX + (maxX - minX) / 2,
+        y: minY + (maxY - minY) / 2,
+    };
+    const offset = {
+        x: polygonCenter.x - bboxCenter.x,
+        y: polygonCenter.y - bboxCenter.y,
+    };
+    const rotatedOffset = rotatePoint(offset, { x: 0, y: 0 }, element.angle);
+    const correction = {
+        x: offset.x - rotatedOffset.x,
+        y: offset.y - rotatedOffset.y,
+    };
+    const correctedPoints = points.map((p) => (Object.assign(Object.assign({}, p), { x: getPrecisionValueFromScoped((p.x.scoped + correction.x), element.scope, currentScope), y: getPrecisionValueFromScoped((p.y.scoped + correction.y), element.scope, currentScope) })));
+    const correctedLines = lines.map((line) => [
+        Object.assign(Object.assign({}, line[0]), { handle: line[0].handle ? Object.assign(Object.assign({}, line[0].handle), { x: getPrecisionValueFromScoped(line[0].handle.x.scoped + correction.x, element.scope, currentScope), y: getPrecisionValueFromScoped(line[0].handle.y.scoped + correction.y, element.scope, currentScope) }) : null }),
+        Object.assign(Object.assign({}, line[1]), { handle: line[1].handle ? Object.assign(Object.assign({}, line[1].handle), { x: getPrecisionValueFromScoped(line[1].handle.x.scoped + correction.x, element.scope, currentScope), y: getPrecisionValueFromScoped(line[1].handle.y.scoped + correction.y, element.scope, currentScope) }) : null }),
+    ]);
+    return { points: correctedPoints, lines: correctedLines };
+};
+export const getElementRelativePoints = (element, currentScope) => {
+    if (isLinearElement(element)) {
+        return { points: element.points, lines: element.lines };
+    }
+    if (isFreeDrawElement(element) || isArrowElement(element)) {
+        return { points: element.points, lines: [] };
+    }
+    return getNonLinearElementRelativePoints(element, currentScope);
+};

package/dist/utils/state/grid.d.ts

@@ -0,0 +1,7 @@
+import { GridSettings, Scope } from "ducjs/types";
+/**
+ * Factory functions for common grid types
+ */
+export declare const createRectangularGrid: (spacing: number, name: string, scope: Scope) => GridSettings;
+export declare const createIsometricGrid: (spacing: number, name: string, scope: Scope) => GridSettings;
+export declare const createPolarGrid: (radialSpacing: number, divisions: number, name: string, scope: Scope) => GridSettings;

package/dist/utils/state/grid.js

@@ -0,0 +1,25 @@
+import { GRID_TYPE, GRID_DISPLAY_TYPE } from "ducjs/flatbuffers/duc";
+import { getPrecisionValueFromRaw } from "ducjs/technical";
+import { DEFAULT_GRID_SETTINGS } from "ducjs/utils/constants";
+/**
+ * Factory functions for common grid types
+ */
+export const createRectangularGrid = (spacing, name, scope) => (Object.assign(Object.assign({}, DEFAULT_GRID_SETTINGS), { 
+    // id: `rect-${spacing}`,
+    // name,
+    xSpacing: getPrecisionValueFromRaw(spacing, scope, scope), ySpacing: getPrecisionValueFromRaw(spacing, scope, scope) }));
+export const createIsometricGrid = (spacing, name, scope) => (Object.assign(Object.assign({}, DEFAULT_GRID_SETTINGS), { 
+    // id: `iso-${spacing}`,
+    // name,
+    type: GRID_TYPE.ISOMETRIC, xSpacing: getPrecisionValueFromRaw(spacing, scope, scope), ySpacing: getPrecisionValueFromRaw(spacing, scope, scope), isometricSettings: {
+        leftAngle: Math.PI / 6, // 30 degrees
+        rightAngle: Math.PI / 6, // 30 degrees
+    } }));
+export const createPolarGrid = (radialSpacing, divisions, name, scope) => (Object.assign(Object.assign({}, DEFAULT_GRID_SETTINGS), { 
+    // id: `polar-${radialSpacing}-${divisions}`,
+    // name,
+    type: GRID_TYPE.POLAR, displayType: GRID_DISPLAY_TYPE.LINES, xSpacing: getPrecisionValueFromRaw(radialSpacing, scope, scope), ySpacing: getPrecisionValueFromRaw(radialSpacing, scope, scope), polarSettings: {
+        radialDivisions: divisions,
+        radialSpacing: getPrecisionValueFromRaw(radialSpacing, scope, scope),
+        showLabels: false
+    } }));

package/dist/utils/state/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./grid";
+import { DucGlobalState, DucLocalState, Scope, Zoom } from "ducjs/types";
+/**
+ * Returns the zoom object with value, scoped, and scaled properties,
+ * using importedState, restoredGlobalState, and defaults.
+ */
+export declare const getZoom: (value: number, mainScope: Scope, scopeExponentThreshold: number) => Zoom;
+export declare const getDefaultGlobalState: () => DucGlobalState;
+export declare const getDefaultLocalState: () => Omit<DucLocalState, "offsetTop" | "offsetLeft" | "width" | "height">;

package/dist/utils/state/index.js

@@ -0,0 +1,131 @@
+export * from "./grid";
+import { PRUNING_LEVEL, TEXT_ALIGN } from "ducjs/flatbuffers/duc";
+import { PREDEFINED_STANDARDS } from "ducjs/technical";
+import { getPrecisionValueFromRaw, getScaledZoomValueForScope, getScopedZoomValue, NEUTRAL_SCOPE, } from "ducjs/technical/scopes";
+import { COLOR_PALETTE, DEFAULT_ELEMENT_PROPS, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, } from "ducjs/utils/constants";
+import { getNormalizedZoom } from "ducjs/utils/normalize";
+import { isFiniteNumber } from "ducjs/utils";
+import { isValidPrecisionScopeValue } from "ducjs/restore/restoreDataState";
+// appState
+// export const updateActiveTool = (
+//   appState: Pick<DucLocalState, "activeTool">,
+//   data: ((
+//     | {
+//       type: ToolType;
+//     }
+//     | { type: "custom"; customType: string }
+//   ) & { locked?: boolean; fromSelection?: boolean }) & {
+//     lastActiveToolBeforeEraser?: ActiveTool | null;
+//   },
+// ): DucLocalState["activeTool"] => {
+//   if (data.type === "custom") {
+//     return {
+//       ...appState.activeTool,
+//       type: "custom",
+//       customType: data.customType,
+//       locked: data.locked ?? appState.activeTool.locked,
+//     };
+//   }
+//   return {
+//     ...appState.activeTool,
+//     lastActiveTool:
+//       data.lastActiveToolBeforeEraser === undefined
+//         ? appState.activeTool.lastActiveTool
+//         : data.lastActiveToolBeforeEraser,
+//     type: data.type,
+//     customType: null,
+//     locked: data.locked ?? appState.activeTool.locked,
+//     fromSelection: data.fromSelection ?? false,
+//   };
+// };
+// activeTool: {
+//   type: "selection",
+//   customType: null,
+//   locked: DEFAULT_ELEMENT_PROPS.locked,
+//   fromSelection: false,
+//   lastActiveTool: null,
+// },
+// duconfig
+// displayAllPointDistances: false,
+// displayDistanceOnDrawing: true,
+// displayAllPointInfoSelected: false,
+// displayAllPointCoordinates: false,
+// displayRootAxis: false,
+// showHyperlinkPopup: false,
+// antiAliasing: ANTI_ALIASING.ANALYTIC,
+// vSync: true,
+// zoomStep: 0,
+// scaleRatioLocked: false,
+// theme: THEME.LIGHT,
+// debugRendering: false,
+/**
+ * Returns the zoom object with value, scoped, and scaled properties,
+ * using importedState, restoredGlobalState, and defaults.
+ */
+export const getZoom = (value, mainScope, scopeExponentThreshold) => {
+    const zoomValue = getNormalizedZoom(isFiniteNumber(value)
+        ? value
+        : 1);
+    const scope = isValidPrecisionScopeValue(value, mainScope, scopeExponentThreshold);
+    const scopedZoom = getScopedZoomValue(value, scope);
+    return {
+        value: zoomValue,
+        scoped: scopedZoom,
+        scaled: getScaledZoomValueForScope(scopedZoom, scope),
+    };
+};
+export const getDefaultGlobalState = () => {
+    return {
+        name: null,
+        viewBackgroundColor: typeof window !== "undefined" ? (window.matchMedia("(prefers-color-scheme: dark)").matches ? COLOR_PALETTE.night : COLOR_PALETTE.white) : COLOR_PALETTE.white,
+        scopeExponentThreshold: 2,
+        mainScope: NEUTRAL_SCOPE,
+        dashSpacingScale: 1,
+        isDashSpacingAffectedByViewportScale: false,
+        dimensionsAssociativeByDefault: false,
+        useAnnotativeScaling: false,
+        displayPrecision: {
+            linear: 2,
+            angular: 1,
+        },
+        pruningLevel: PRUNING_LEVEL.BALANCED,
+    };
+};
+export const getDefaultLocalState = () => {
+    const scrollX = typeof window !== "undefined" ? window.innerWidth / 2 : 0;
+    const scrollY = typeof window !== "undefined" ? window.innerHeight / 2 : 0;
+    const zoom = getNormalizedZoom(1);
+    const scope = NEUTRAL_SCOPE;
+    const scopedZoom = getScopedZoomValue(zoom, scope);
+    return {
+        scope,
+        activeStandardId: PREDEFINED_STANDARDS.DUC,
+        isBindingEnabled: true,
+        scrollX: getPrecisionValueFromRaw(scrollX, NEUTRAL_SCOPE, scope),
+        scrollY: getPrecisionValueFromRaw(scrollY, NEUTRAL_SCOPE, scope),
+        zoom: {
+            value: zoom,
+            scoped: scopedZoom,
+            scaled: getScaledZoomValueForScope(scopedZoom, scope),
+        },
+        currentItemBackground: DEFAULT_ELEMENT_PROPS.background,
+        currentItemStroke: DEFAULT_ELEMENT_PROPS.stroke,
+        currentItemStartLineHead: null,
+        currentItemEndLineHead: null,
+        currentItemFontFamily: DEFAULT_FONT_FAMILY,
+        currentItemTextAlign: TEXT_ALIGN.LEFT,
+        currentItemFontSize: getPrecisionValueFromRaw(DEFAULT_FONT_SIZE, scope, scope),
+        currentItemOpacity: DEFAULT_ELEMENT_PROPS.opacity,
+        currentItemRoundness: getPrecisionValueFromRaw(0, scope, scope),
+        activeGridSettings: [],
+        activeSnapSettings: "",
+        penMode: false,
+        viewModeEnabled: false,
+        objectsSnapModeEnabled: true,
+        gridModeEnabled: false,
+        outlineModeEnabled: false,
+        manualSaveMode: false,
+        gridSize: 10,
+        gridStep: 10,
+    };
+};

package/dist/utils/url.d.ts

@@ -0,0 +1,8 @@
+export declare const sanitizeHTMLAttribute: (html: string) => string;
+export declare const normalizeLink: (link: string) => string;
+export declare const isLocalLink: (link: string | null) => boolean;
+/**
+ * Returns URL sanitized and safe for usage in places such as
+ * iframe's src attribute or <a> href attributes.
+ */
+export declare const toValidURL: (link: string) => string;

package/dist/utils/url.js

@@ -0,0 +1,33 @@
+import { sanitizeUrl } from "@braintree/sanitize-url";
+export const sanitizeHTMLAttribute = (html) => {
+    return html.replace(/"/g, """);
+};
+export const normalizeLink = (link) => {
+    link = link.trim();
+    if (!link) {
+        return link;
+    }
+    return sanitizeUrl(sanitizeHTMLAttribute(link));
+};
+export const isLocalLink = (link) => {
+    return !!((link === null || link === void 0 ? void 0 : link.includes(location.origin)) || (link === null || link === void 0 ? void 0 : link.startsWith("/")));
+};
+/**
+ * Returns URL sanitized and safe for usage in places such as
+ * iframe's src attribute or <a> href attributes.
+ */
+export const toValidURL = (link) => {
+    link = normalizeLink(link);
+    // make relative links into fully-qualified urls
+    if (link.startsWith("/")) {
+        return `${location.origin}${link}`;
+    }
+    try {
+        new URL(link);
+    }
+    catch (_a) {
+        // if link does not parse as URL, assume invalid and return blank page
+        return "about:blank";
+    }
+    return link;
+};

package/dist/utils/version.d.ts

@@ -0,0 +1 @@
+export { DUC_SCHEMA_VERSION as DUC_VERSION } from "ducjs/serialize";

package/dist/utils/version.js

@@ -0,0 +1 @@
+export { DUC_SCHEMA_VERSION as DUC_VERSION } from "ducjs/serialize";