ducjs 2.3.0 → 3.0.0

package/dist/utils/elements/newElement.js

@@ -9,13 +9,13 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { getUpdatedTimestamp, getZoom } from "..";
-import { BLOCK_ATTACHMENT, COLUMN_TYPE, DATUM_BRACKET_STYLE, IMAGE_STATUS, LINE_SPACING_TYPE, STACKED_TEXT_ALIGN, TEXT_FLOW_DIRECTION, VERTICAL_ALIGN, VIEWPORT_SHADE_PLOT } from "../../flatbuffers/duc";
+import { getUpdatedTimestamp } from "..";
+import { IMAGE_STATUS, LINE_SPACING_TYPE, } from "../../enums";
 import { getPrecisionValueFromRaw } from "../../technical/scopes";
 import { DEFAULT_ELEMENT_PROPS, DEFAULT_ELLIPSE_ELEMENT, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FREEDRAW_ELEMENT, DEFAULT_POLYGON_SIDES, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN } from "../constants";
 import { randomId, randomInteger } from "../math/random";
 import { normalizeText } from "../normalize";
-import { getDefaultStackProperties, getDefaultTableData, getDefaultTextStyle } from "./";
+import { getDefaultStackProperties } from "./";
 import { getFontString, getTextElementPositionOffsets, measureText, } from "./textElement";
 export const newElementWith = (element, updates, 
 /** pass `true` to always regenerate */
@@ -39,7 +39,7 @@ force = false) => {
 };
 const _newElementBase = (type, currentScope, _a) => {
     var _b, _c;
-    var { x, y, scope = currentScope, zIndex, index = DEFAULT_ELEMENT_PROPS.index, label, isVisible = DEFAULT_ELEMENT_PROPS.isVisible, isPlot = DEFAULT_ELEMENT_PROPS.isPlot, isAnnotative = DEFAULT_ELEMENT_PROPS.isAnnotative, stroke = [DEFAULT_ELEMENT_PROPS.stroke], background = [DEFAULT_ELEMENT_PROPS.background], opacity = DEFAULT_ELEMENT_PROPS.opacity, width = DEFAULT_ELEMENT_PROPS.width, height = DEFAULT_ELEMENT_PROPS.height, angle = DEFAULT_ELEMENT_PROPS.angle, groupIds = DEFAULT_ELEMENT_PROPS.groupIds, blockIds = [], instanceId = null, regionIds = [], frameId = DEFAULT_ELEMENT_PROPS.frameId, layerId = null, roundness = DEFAULT_ELEMENT_PROPS.roundness, boundElements = DEFAULT_ELEMENT_PROPS.boundElements, link = DEFAULT_ELEMENT_PROPS.link, locked = DEFAULT_ELEMENT_PROPS.locked, description = null } = _a, rest = __rest(_a, ["x", "y", "scope", "zIndex", "index", "label", "isVisible", "isPlot", "isAnnotative", "stroke", "background", "opacity", "width", "height", "angle", "groupIds", "blockIds", "instanceId", "regionIds", "frameId", "layerId", "roundness", "boundElements", "link", "locked", "description"]);
+    var { x, y, scope = currentScope, zIndex, index = DEFAULT_ELEMENT_PROPS.index, label, isVisible = DEFAULT_ELEMENT_PROPS.isVisible, isPlot = DEFAULT_ELEMENT_PROPS.isPlot, stroke = [DEFAULT_ELEMENT_PROPS.stroke], background = [DEFAULT_ELEMENT_PROPS.background], opacity = DEFAULT_ELEMENT_PROPS.opacity, width = DEFAULT_ELEMENT_PROPS.width, height = DEFAULT_ELEMENT_PROPS.height, angle = DEFAULT_ELEMENT_PROPS.angle, groupIds = DEFAULT_ELEMENT_PROPS.groupIds, blockIds = [], instanceId = null, regionIds = [], frameId = DEFAULT_ELEMENT_PROPS.frameId, layerId = null, roundness = DEFAULT_ELEMENT_PROPS.roundness, boundElements = DEFAULT_ELEMENT_PROPS.boundElements, link = DEFAULT_ELEMENT_PROPS.link, locked = DEFAULT_ELEMENT_PROPS.locked, description = null } = _a, rest = __rest(_a, ["x", "y", "scope", "zIndex", "index", "label", "isVisible", "isPlot", "stroke", "background", "opacity", "width", "height", "angle", "groupIds", "blockIds", "instanceId", "regionIds", "frameId", "layerId", "roundness", "boundElements", "link", "locked", "description"]);
     // assign type to guard against excess properties
     const element = {
         id: rest.id || randomId(),
@@ -73,7 +73,6 @@ const _newElementBase = (type, currentScope, _a) => {
         description,
         customData: rest.customData,
         isPlot,
-        isAnnotative,
         regionIds,
         layerId,
     };
@@ -83,8 +82,8 @@ export const newElement = (currentScope, opts) => _newElementBase(opts.type, cur
 export const newEmbeddableElement = (currentScope, opts) => {
     return Object.assign(Object.assign({}, opts), _newElementBase(opts.type, currentScope, opts));
 };
-export const newFrameElement = (currentScope, opts) => (Object.assign(Object.assign(Object.assign(Object.assign({}, getDefaultStackProperties()), { clip: false, labelVisible: true, standardOverride: null }), _newElementBase("frame", currentScope, opts)), { type: "frame" }));
-export const newPlotElement = (currentScope, opts) => (Object.assign(Object.assign(Object.assign(Object.assign({}, getDefaultStackProperties()), { clip: false, labelVisible: true, standardOverride: null, layout: {
+export const newFrameElement = (currentScope, opts) => (Object.assign(Object.assign(Object.assign(Object.assign({}, getDefaultStackProperties()), { clip: false, labelVisible: true }), _newElementBase("frame", currentScope, opts)), { type: "frame" }));
+export const newPlotElement = (currentScope, opts) => (Object.assign(Object.assign(Object.assign(Object.assign({}, getDefaultStackProperties()), { clip: false, labelVisible: true, layout: {
         margins: {
             top: getPrecisionValueFromRaw(0, currentScope, currentScope),
             right: getPrecisionValueFromRaw(0, currentScope, currentScope),
@@ -92,20 +91,6 @@ export const newPlotElement = (currentScope, opts) => (Object.assign(Object.assi
             left: getPrecisionValueFromRaw(0, currentScope, currentScope),
         }
     } }), _newElementBase("plot", currentScope, opts)), { type: "plot" }));
-export const newViewportElement = (currentScope, opts) => {
-    var _a, _b, _c;
-    return (Object.assign(Object.assign(Object.assign(Object.assign({}, getDefaultStackProperties()), { points: [], lines: [], pathOverrides: [], lastCommittedPoint: null, startBinding: null, endBinding: null, standardOverride: null, view: {
-            scrollX: getPrecisionValueFromRaw(0, currentScope, currentScope),
-            scrollY: getPrecisionValueFromRaw(0, currentScope, currentScope),
-            zoom: getZoom((_a = opts.zoom) !== null && _a !== void 0 ? _a : 1, (_b = opts.mainScope) !== null && _b !== void 0 ? _b : currentScope, (_c = opts.scopeExponentThreshold) !== null && _c !== void 0 ? _c : 2),
-            twistAngle: 0,
-            centerPoint: {
-                x: getPrecisionValueFromRaw(0, currentScope, currentScope),
-                y: getPrecisionValueFromRaw(0, currentScope, currentScope),
-            },
-            scope: currentScope,
-        }, scale: 1, shadePlot: VIEWPORT_SHADE_PLOT.AS_DISPLAYED, frozenGroupIds: [], scaleIndicatorVisible: true }), _newElementBase("viewport", currentScope, opts)), { type: "viewport" }));
-};
 export const newEllipseElement = (currentScope, opts) => {
     return Object.assign(Object.assign({}, _newElementBase(opts.type, currentScope, opts)), { ratio: opts.ratio || DEFAULT_ELLIPSE_ELEMENT.ratio, startAngle: opts.startAngle || DEFAULT_ELLIPSE_ELEMENT.startAngle, endAngle: opts.endAngle || DEFAULT_ELLIPSE_ELEMENT.endAngle, showAuxCrosshair: opts.showAuxCrosshair || DEFAULT_ELLIPSE_ELEMENT.showAuxCrosshair });
 };
@@ -123,15 +108,24 @@ export const newTextElement = (currentScope, opts) => {
     const textAlign = opts.textAlign || DEFAULT_TEXT_ALIGN;
     const verticalAlign = opts.verticalAlign || DEFAULT_VERTICAL_ALIGN;
     const offsets = getTextElementPositionOffsets({ textAlign, verticalAlign }, metrics);
+    // Minimum dimensions: at least 1px wide, at least one line high (NaN-safe)
+    const rawMinLineHeight = fontSize.value * lineHeight;
+    const minLineHeight = (Number.isFinite(rawMinLineHeight) && rawMinLineHeight > 0)
+        ? rawMinLineHeight
+        : DEFAULT_FONT_SIZE * lineHeight;
+    const finalWidth = (Number.isFinite(metrics.width) && metrics.width > 0) ? metrics.width : 1;
+    const finalHeight = (Number.isFinite(metrics.height) && metrics.height > 0)
+        ? Math.max(metrics.height, minLineHeight)
+        : minLineHeight;
     const x = getPrecisionValueFromRaw(opts.x.value - offsets.x, scope, currentScope);
     const y = getPrecisionValueFromRaw(opts.y.value - offsets.y, scope, currentScope);
     return Object.assign(Object.assign({}, _newElementBase("text", currentScope, Object.assign(Object.assign({}, opts), { x, y }))), { type: "text", text,
         fontSize,
         fontFamily,
         textAlign,
-        verticalAlign, width: getPrecisionValueFromRaw(metrics.width, scope, currentScope), height: getPrecisionValueFromRaw(metrics.height, scope, currentScope), containerId: opts.containerId || null, originalText: (_b = opts.originalText) !== null && _b !== void 0 ? _b : text, autoResize: (_c = opts.autoResize) !== null && _c !== void 0 ? _c : true, lineHeight, 
+        verticalAlign, width: getPrecisionValueFromRaw(finalWidth, scope, currentScope), height: getPrecisionValueFromRaw(finalHeight, scope, currentScope), containerId: opts.containerId || null, originalText: (_b = opts.originalText) !== null && _b !== void 0 ? _b : text, autoResize: (_c = opts.autoResize) !== null && _c !== void 0 ? _c : true, lineHeight, 
         // DucTextStyle properties
-        isLtr: (_d = opts.isLtr) !== null && _d !== void 0 ? _d : true, bigFontFamily: opts.bigFontFamily || "sans-serif", lineSpacing: opts.lineSpacing || { type: LINE_SPACING_TYPE.MULTIPLE, value: lineHeight }, obliqueAngle: opts.obliqueAngle || 0, paperTextHeight: opts.paperTextHeight, widthFactor: opts.widthFactor || 1, isUpsideDown: (_e = opts.isUpsideDown) !== null && _e !== void 0 ? _e : false, isBackwards: (_f = opts.isBackwards) !== null && _f !== void 0 ? _f : false, dynamic: opts.dynamic || [] });
+        isLtr: (_d = opts.isLtr) !== null && _d !== void 0 ? _d : true, bigFontFamily: opts.bigFontFamily || "sans-serif", lineSpacing: opts.lineSpacing || { type: LINE_SPACING_TYPE.MULTIPLE, value: lineHeight }, obliqueAngle: opts.obliqueAngle || 0, widthFactor: opts.widthFactor || 1, isUpsideDown: (_e = opts.isUpsideDown) !== null && _e !== void 0 ? _e : false, isBackwards: (_f = opts.isBackwards) !== null && _f !== void 0 ? _f : false });
 };
 export const newFreeDrawElement = (currentScope, opts) => {
     var _a, _b, _c, _d;
@@ -150,36 +144,22 @@ export const newImageElement = (currentScope, opts) => {
     var _a, _b, _c;
     return (Object.assign(Object.assign({}, _newElementBase("image", currentScope, opts)), { type: "image", status: (_a = opts.status) !== null && _a !== void 0 ? _a : IMAGE_STATUS.PENDING, fileId: (_b = opts.fileId) !== null && _b !== void 0 ? _b : null, scaleFlip: (_c = opts.scaleFlip) !== null && _c !== void 0 ? _c : [1, 1], crop: null, filter: null }));
 };
-export const newTableElement = (currentScope, opts) => (Object.assign(Object.assign(Object.assign({}, _newElementBase("table", currentScope, opts)), getDefaultTableData(currentScope)), { type: "table" }));
-export const newDocElement = (currentScope, opts) => {
-    var _a, _b, _c, _d;
-    return (Object.assign(Object.assign({}, _newElementBase("doc", currentScope, opts)), { type: "doc", text: opts.text || "", dynamic: opts.dynamic || [], flowDirection: opts.flowDirection || TEXT_FLOW_DIRECTION.TOP_TO_BOTTOM, columns: opts.columns || { type: COLUMN_TYPE.NO_COLUMNS, definitions: [], autoHeight: true }, autoResize: (_a = opts.autoResize) !== null && _a !== void 0 ? _a : true, fileId: null, gridConfig: { columns: 1, gapX: 0, gapY: 0, alignItems: 'start', firstPageAlone: false }, 
-        // DucDocStyle properties
-        isLtr: (_b = opts.isLtr) !== null && _b !== void 0 ? _b : true, fontFamily: opts.fontFamily || DEFAULT_FONT_FAMILY, bigFontFamily: opts.bigFontFamily || "sans-serif", textAlign: opts.textAlign || DEFAULT_TEXT_ALIGN, verticalAlign: opts.verticalAlign || DEFAULT_VERTICAL_ALIGN, lineHeight: opts.lineHeight || 1.2, lineSpacing: opts.lineSpacing || { type: LINE_SPACING_TYPE.MULTIPLE, value: 1.2 }, obliqueAngle: opts.obliqueAngle || 0, fontSize: opts.fontSize || getPrecisionValueFromRaw(DEFAULT_FONT_SIZE, currentScope, currentScope), paperTextHeight: opts.paperTextHeight, widthFactor: opts.widthFactor || 1, isUpsideDown: (_c = opts.isUpsideDown) !== null && _c !== void 0 ? _c : false, isBackwards: (_d = opts.isBackwards) !== null && _d !== void 0 ? _d : false, paragraph: opts.paragraph || { firstLineIndent: getPrecisionValueFromRaw(0, currentScope, currentScope), hangingIndent: getPrecisionValueFromRaw(0, currentScope, currentScope), leftIndent: getPrecisionValueFromRaw(0, currentScope, currentScope), rightIndent: getPrecisionValueFromRaw(0, currentScope, currentScope), spaceBefore: getPrecisionValueFromRaw(0, currentScope, currentScope), spaceAfter: getPrecisionValueFromRaw(0, currentScope, currentScope), tabStops: [] }, stackFormat: opts.stackFormat || { autoStack: false, stackChars: [], properties: { upperScale: 0.7, lowerScale: 0.7, alignment: STACKED_TEXT_ALIGN.CENTER } } }));
-};
-export const newPdfElement = (currentScope, opts) => (Object.assign(Object.assign({ fileId: null, gridConfig: { columns: 1, gapX: 0, gapY: 0, alignItems: 'start', firstPageAlone: false } }, _newElementBase("pdf", currentScope, opts)), { type: "pdf" }));
-export const newMermaidElement = (currentScope, opts) => (Object.assign(Object.assign({ source: "", theme: undefined, svgPath: null }, _newElementBase("mermaid", currentScope, opts)), { type: "mermaid" }));
-export const newXRayElement = (currentScope, opts) => (Object.assign(Object.assign({ origin: { x: getPrecisionValueFromRaw(0, currentScope, currentScope), y: getPrecisionValueFromRaw(0, currentScope, currentScope) }, direction: { x: getPrecisionValueFromRaw(1, currentScope, currentScope), y: getPrecisionValueFromRaw(0, currentScope, currentScope) }, startFromOrigin: false, color: '#FF00FF' }, _newElementBase("xray", currentScope, opts)), { type: "xray" }));
-export const newLeaderElement = (currentScope, opts) => {
-    var _a, _b;
-    return Object.assign(Object.assign({ points: [], lines: [], pathOverrides: [], lastCommittedPoint: null, startBinding: null, endBinding: null, headsOverride: undefined, dogleg: getPrecisionValueFromRaw(10, currentScope, currentScope), textStyle: opts.textStyle || getDefaultTextStyle(currentScope), textAttachment: opts.textAttachment || VERTICAL_ALIGN.TOP, blockAttachment: opts.blockAttachment || BLOCK_ATTACHMENT.CENTER_EXTENTS, leaderContent: (_a = opts.leaderContent) !== null && _a !== void 0 ? _a : null, contentAnchor: (_b = opts.contentAnchor) !== null && _b !== void 0 ? _b : {
-            x: 0,
-            y: 0,
-        } }, _newElementBase("leader", currentScope, opts)), { type: "leader" });
-};
-export const newDimensionElement = (currentScope, opts) => (Object.assign(Object.assign({}, _newElementBase("dimension", currentScope, opts)), { type: 'dimension' }));
-export const newFeatureControlFrameElement = (currentScope, opts) => {
-    return Object.assign(Object.assign({ rows: [], leaderElementId: null, textStyle: getDefaultTextStyle(currentScope), layout: {
-            padding: getPrecisionValueFromRaw(4, currentScope, currentScope),
-            segmentSpacing: getPrecisionValueFromRaw(4, currentScope, currentScope),
-            rowSpacing: getPrecisionValueFromRaw(2, currentScope, currentScope),
-        }, symbols: {
-            scale: 1,
-        }, datumStyle: {
-            bracketStyle: DATUM_BRACKET_STYLE.SQUARE
-        } }, _newElementBase("featurecontrolframe", currentScope, opts)), { type: "featurecontrolframe" });
+export const newTableElement = (currentScope, opts) => {
+    var _a;
+    return (Object.assign(Object.assign({}, _newElementBase("table", currentScope, opts)), { fileId: (_a = opts.fileId) !== null && _a !== void 0 ? _a : null, type: "table" }));
 };
-export const newParametricElement = (currentScope, opts) => (Object.assign(Object.assign({ source: "", svgPath: null, fileIds: [] }, _newElementBase("model", currentScope, opts)), { type: 'model' }));
+export const newDocElement = (currentScope, opts) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    return (Object.assign(Object.assign({}, _newElementBase("doc", currentScope, opts)), { type: "doc", text: opts.text || "", fileId: (_a = opts.fileId) !== null && _a !== void 0 ? _a : null, gridConfig: {
+            columns: (_c = (_b = opts.gridConfig) === null || _b === void 0 ? void 0 : _b.columns) !== null && _c !== void 0 ? _c : 1,
+            gapX: (_e = (_d = opts.gridConfig) === null || _d === void 0 ? void 0 : _d.gapX) !== null && _e !== void 0 ? _e : 0,
+            gapY: (_g = (_f = opts.gridConfig) === null || _f === void 0 ? void 0 : _f.gapY) !== null && _g !== void 0 ? _g : 0,
+            firstPageAlone: (_j = (_h = opts.gridConfig) === null || _h === void 0 ? void 0 : _h.firstPageAlone) !== null && _j !== void 0 ? _j : false,
+            scale: (_l = (_k = opts.gridConfig) === null || _k === void 0 ? void 0 : _k.scale) !== null && _l !== void 0 ? _l : 1,
+        } }));
+};
+export const newPdfElement = (currentScope, opts) => (Object.assign(Object.assign({ fileId: null, gridConfig: { columns: 1, gapX: 0, gapY: 0, firstPageAlone: false, scale: 1 } }, _newElementBase("pdf", currentScope, opts)), { type: "pdf" }));
+export const newModelElement = (currentScope, opts) => (Object.assign(Object.assign({ modelType: null, code: null, svgPath: null, fileIds: [], viewerState: null }, _newElementBase("model", currentScope, opts)), { type: 'model' }));
 // Simplified deep clone for the purpose of cloning DucElement.
 //
 // Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,

package/dist/utils/elements/textElement.d.ts

@@ -1,9 +1,9 @@
+import { SupportedMeasures } from "../../technical/scopes";
 import { DucLocalState, RawValue, Scope, ScopedValue } from "../../types";
 import { DucElement, DucElementType, DucTextContainer, DucTextElement, DucTextElementWithContainer, ElementsMap, FontFamilyValues, FontString, NonDeletedDucElement } from "../../types/elements";
 import { GeometricPoint } from "../../types/geometryTypes";
 import { ExtractSetType } from "../../types/utility-types";
 import { getBoundTextElementPosition } from "./linearElement";
-import { SupportedMeasures } from "../../technical/scopes";
 export declare const computeBoundTextPosition: (container: DucElement, boundTextElement: DucTextElementWithContainer, elementsMap: ElementsMap, currentScope: SupportedMeasures) => {
     x: ScopedValue;
     y: ScopedValue;
@@ -49,12 +49,12 @@ export declare const getMinTextElementWidth: (font: FontString, lineHeight: DucT
 /** retrieves text from text elements and concatenates to a single string */
 export declare const getTextFromElements: (elements: readonly DucElement[], separator?: string) => string;
 export declare const getFontFamilyString: ({ fontFamily, }: {
-    fontFamily: FontFamilyValues;
+    fontFamily: FontFamilyValues | string;
 }) => string;
 /** returns fontSize+fontFamily string for assignment to DOM elements */
 export declare const getFontString: ({ fontSize, fontFamily, }: {
     fontSize: DucTextElement["fontSize"];
-    fontFamily: FontFamilyValues;
+    fontFamily: FontFamilyValues | string;
 }) => FontString;
 /** computes element x/y offset based on textAlign/verticalAlign */
 export declare const getTextElementPositionOffsets: (opts: {

package/dist/utils/elements/textElement.js

@@ -1,11 +1,11 @@
-import { TEXT_ALIGN, VERTICAL_ALIGN } from "../../flatbuffers/duc";
+import { TEXT_ALIGN, VERTICAL_ALIGN } from "../../enums";
+import { getPrecisionValueFromRaw, getScopedBezierPointFromDucPoint } from "../../technical/scopes";
 import { isArrowElement, isBoundToContainer, isTextElement } from "../../types/elements/typeChecks";
 import { getContainerElement, getElementAbsoluteCoords, getResizedElementAbsoluteCoords } from "../bounds";
-import { ARROW_LABEL_FONT_SIZE_TO_MIN_WIDTH_RATIO, ARROW_LABEL_WIDTH_FRACTION, BOUND_TEXT_PADDING, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, FONT_FAMILY, WINDOWS_EMOJI_FALLBACK_FONT } from "../constants";
-import { getBoundTextElementPosition, getPointGlobalCoordinates, getPointsGlobalCoordinates, getSegmentMidPoint } from "./linearElement";
+import { ARROW_LABEL_FONT_SIZE_TO_MIN_WIDTH_RATIO, ARROW_LABEL_WIDTH_FRACTION, BOUND_TEXT_PADDING, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, LEGACY_FONT_ID_TO_NAME, WINDOWS_EMOJI_FALLBACK_FONT } from "../constants";
 import { adjustXYWithRotation } from "../math";
 import { normalizeText } from "../normalize";
-import { getPrecisionValueFromRaw, getScopedBezierPointFromDucPoint } from "../../technical/scopes";
+import { getBoundTextElementPosition, getPointGlobalCoordinates, getPointsGlobalCoordinates, getSegmentMidPoint } from "./linearElement";
 export const computeBoundTextPosition = (container, boundTextElement, elementsMap, currentScope) => {
     if (isArrowElement(container)) {
         const coords = getBoundTextElementPosition(container, boundTextElement, elementsMap, currentScope);
@@ -54,10 +54,19 @@ export const measureText = (text, font, lineHeight, currentScope) => {
         // lines would be stripped from computation
         .map((x) => x || " ")
         .join("\n");
-    const fontSize = getPrecisionValueFromRaw(parseFloat(font), currentScope, currentScope);
+    const parsedFontSize = parseFloat(font);
+    // Guard: if font string produced an unparseable size (NaN) or zero,
+    // fall back to DEFAULT_FONT_SIZE so measurements are never degenerate.
+    const safeFontSize = (Number.isFinite(parsedFontSize) && parsedFontSize > 0)
+        ? parsedFontSize
+        : DEFAULT_FONT_SIZE;
+    const fontSize = getPrecisionValueFromRaw(safeFontSize, currentScope, currentScope);
     const height = getTextHeight(text, fontSize, lineHeight);
     const width = getTextWidth(text, font);
-    return { width, height };
+    // Defensive: ensure we never return 0 or NaN dimensions
+    const safeWidth = (Number.isFinite(width) && width > 0) ? width : 1;
+    const safeHeight = (Number.isFinite(height) && height > 0) ? height : (safeFontSize * lineHeight);
+    return { width: safeWidth, height: safeHeight };
 };
 /**
  * We calculate the line height from the font size and the unitless line height,
@@ -104,15 +113,15 @@ const getLineWidth = (text, font, forceAdvanceWidth, isTestEnv) => {
         // fallback to advance width if the actual width is zero, i.e. on text editing start
         // or when actual width does not respect whitespace chars, i.e. spaces
         // otherwise actual width should always be bigger
-        return Math.max(actualWidth, advanceWidth);
+        return Math.ceil(Math.max(actualWidth, advanceWidth));
     }
     // since in test env the canvas measureText algo
     // doesn't measure text and instead just returns number of
     // characters hence we assume that each letteris 10px
     if (isTestEnv) {
-        return advanceWidth * 10;
+        return Math.ceil(advanceWidth * 10);
     }
-    return advanceWidth;
+    return Math.ceil(advanceWidth);
 };
 export const getTextWidth = (text, font, forceAdvanceWidth) => {
     const lines = splitIntoLines(text);
@@ -470,14 +479,20 @@ export const getTextFromElements = (elements, separator = "\n\n") => {
     return text;
 };
 export const getFontFamilyString = ({ fontFamily, }) => {
-    // Handle both number and string fontFamily values
-    const fontFamilyNum = typeof fontFamily === 'string' ? parseInt(fontFamily, 10) : fontFamily;
-    for (const [fontFamilyString, id] of Object.entries(FONT_FAMILY)) {
-        if (id === fontFamilyNum) {
-            return `${fontFamilyString}, ${WINDOWS_EMOJI_FALLBACK_FONT}`;
-        }
-    }
-    return WINDOWS_EMOJI_FALLBACK_FONT;
+    // Handle legacy numeric font IDs from old files
+    if (typeof fontFamily === "number") {
+        const name = LEGACY_FONT_ID_TO_NAME[fontFamily];
+        if (name)
+            return `${name}, ${WINDOWS_EMOJI_FALLBACK_FONT}`;
+        return WINDOWS_EMOJI_FALLBACK_FONT;
+    }
+    // Handle stringified numeric IDs (e.g. "10")
+    const parsed = Number(fontFamily);
+    if (!Number.isNaN(parsed) && LEGACY_FONT_ID_TO_NAME[parsed]) {
+        return `${LEGACY_FONT_ID_TO_NAME[parsed]}, ${WINDOWS_EMOJI_FALLBACK_FONT}`;
+    }
+    // New path: fontFamily is already a string name
+    return `${fontFamily}, ${WINDOWS_EMOJI_FALLBACK_FONT}`;
 };
 /** returns fontSize+fontFamily string for assignment to DOM elements */
 export const getFontString = ({ fontSize, fontFamily, }) => {
@@ -504,6 +519,18 @@ export const refreshTextDimensions = (textElement, container, elementsMap, curre
             : textElement.width.scoped);
     }
     const dimensions = getAdjustedDimensions(textElement, elementsMap, text, currentScope);
+    // Defensive minimums — ensure height is always at least one line.
+    // Use negated >= to also catch NaN (NaN < x is always false).
+    const rawMinLineHeight = textElement.fontSize.value * textElement.lineHeight;
+    const minLineHeight = (Number.isFinite(rawMinLineHeight) && rawMinLineHeight > 0)
+        ? rawMinLineHeight
+        : DEFAULT_FONT_SIZE * textElement.lineHeight;
+    if (!(dimensions.height >= minLineHeight)) {
+        dimensions.height = minLineHeight;
+    }
+    if (!(dimensions.width > 0)) {
+        dimensions.width = (textElement.autoResize ? 1 : textElement.width.value);
+    }
     return Object.assign({ text }, dimensions);
 };
 export const splitIntoLines = (text) => {

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

@@ -1,13 +1,14 @@
-export * from "./geometry";
-export * from "./bbox";
 export * from "./algebra";
+export * from "./bbox";
+export * from "./geometry";
 export * from "./random";
-import type { NullableGridSize, Zoom } from "../../types";
+import { SupportedMeasures } from "../../technical/scopes";
+import type { Zoom } from "../../types";
 import { Scope, ScopedValue } from "../../types";
 import type { DucElement, DucLine, DucLinearElement, DucLinearLikeElement, DucPoint, NonDeleted } from "../../types/elements";
 import type { Bounds, GeometricPoint, GeometricVector, Percentage, Radian } from "../../types/geometryTypes";
 import { Heading } from "../../types/geometryTypes";
-import { SupportedMeasures } from "../../technical/scopes";
+export type NullableGridSize = number | null;
 export declare const getRadianFromDegrees: (degrees: number) => Radian;
 export declare const getDegreesFromRadian: (radian: Radian) => number;
 export declare const getPercentageValueFromPercentage: (value: number) => Percentage;

package/dist/utils/math/index.js

@@ -1,10 +1,10 @@
-export * from "./geometry";
-export * from "./bbox";
 export * from "./algebra";
+export * from "./bbox";
+export * from "./geometry";
 export * from "./random";
+import { getPrecisionValueFromRaw, getPrecisionValueFromScoped, getScopedBezierPointFromDucPoint } from "../../technical/scopes";
 import { LINE_CONFIRM_THRESHOLD } from "../constants";
 import { pointFrom } from "./geometry";
-import { getPrecisionValueFromRaw, getPrecisionValueFromScoped, getScopedBezierPointFromDucPoint } from "../../technical/scopes";
 export const getRadianFromDegrees = (degrees) => {
     return degrees * (Math.PI / 180);
 };

package/dist/utils/shape.js

@@ -1,11 +1,11 @@
-import { BEZIER_MIRRORING } from "../flatbuffers/duc";
+import { BEZIER_MIRRORING } from "../enums";
+import { getPrecisionValueFromRaw, getPrecisionValueFromScoped } from "../technical/scopes";
 import { isArrowElement, isEllipseElement, isFreeDrawElement, isLinearElement, isPolygonElement } from "../types/elements/typeChecks";
 import { calculateShapeBounds } from "./bounds";
 import { getBaseElementProps } from "./elements";
 import { getNormalizedPoints, mergeOverlappingPoints } from "./elements/linearElement";
 import { newLinearElement } from "./elements/newElement";
 import { rotatePoint } from "./math";
-import { getPrecisionValueFromRaw, getPrecisionValueFromScoped } from "../technical/scopes";
 /**
  * Converts a shape (rectangle, polygon, ellipse) to a linear element
  */

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

@@ -1,4 +1,3 @@
-export * from "./grid";
 import { DucGlobalState, DucLocalState, Scope, Zoom } from "../../types";
 /**
  * Returns the zoom object with value, scoped, and scaled properties,

package/dist/utils/state/index.js

@@ -1,63 +1,9 @@
-export * from "./grid";
-import { PRUNING_LEVEL, TEXT_ALIGN } from "../../flatbuffers/duc";
-import { PREDEFINED_STANDARDS } from "../../technical";
+import { isFiniteNumber } from "..";
+import { PRUNING_LEVEL, TEXT_ALIGN } from "../../enums";
+import { isValidPrecisionScopeValue } from "../../restore/restoreDataState";
 import { getPrecisionValueFromRaw, getScaledZoomValueForScope, getScopedZoomValue, NEUTRAL_SCOPE, } from "../../technical/scopes";
 import { COLOR_PALETTE, DEFAULT_ELEMENT_PROPS, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, } from "../constants";
 import { getNormalizedZoom } from "../normalize";
-import { isFiniteNumber } from "..";
-import { isValidPrecisionScopeValue } from "../../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.
@@ -78,16 +24,8 @@ 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,
+        scopeExponentThreshold: 3,
         mainScope: NEUTRAL_SCOPE,
-        dashSpacingScale: 1,
-        isDashSpacingAffectedByViewportScale: false,
-        dimensionsAssociativeByDefault: false,
-        useAnnotativeScaling: false,
-        displayPrecision: {
-            linear: 2,
-            angular: 1,
-        },
         pruningLevel: PRUNING_LEVEL.BALANCED,
     };
 };
@@ -99,7 +37,6 @@ export const getDefaultLocalState = () => {
     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),
@@ -117,15 +54,12 @@ export const getDefaultLocalState = () => {
         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,
+        decimalPlaces: 2,
     };
 };

package/dist/utils/traverse.d.ts

@@ -20,3 +20,11 @@ import { Scope } from "../types";
  * @param detectedScope - Internally tracked scope for the current level
  */
 export declare const traverseAndUpdatePrecisionValues: (obj: any, targetScope: Scope, providedScope?: Scope, visited?: WeakSet<WeakKey>, detectedScope?: Scope) => any;
+/**
+ * Traverses an object and normalizes it for serialization in `targetScope`.
+ *
+ * - Converts all PrecisionValue fields so `scoped` is in `targetScope`
+ * - Rewrites PrecisionValue `value` from the computed `scoped` value
+ * - Rewrites `scope` / `mainScope` string fields to `targetScope`
+ */
+export declare const normalizeForSerializationScope: <T>(obj: T, targetScope: Scope, providedScope?: Scope) => T;

package/dist/utils/traverse.js

@@ -85,3 +85,40 @@ export const traverseAndUpdatePrecisionValues = (obj, targetScope, providedScope
     }
     return result;
 };
+/**
+ * Traverses an object and normalizes it for serialization in `targetScope`.
+ *
+ * - Converts all PrecisionValue fields so `scoped` is in `targetScope`
+ * - Rewrites PrecisionValue `value` from the computed `scoped` value
+ * - Rewrites `scope` / `mainScope` string fields to `targetScope`
+ */
+export const normalizeForSerializationScope = (obj, targetScope, providedScope) => {
+    const converted = traverseAndUpdatePrecisionValues(obj, targetScope, providedScope);
+    return rewriteScopeAndPrecisionValues(converted, targetScope);
+};
+const rewriteScopeAndPrecisionValues = (obj, targetScope, visited = new WeakSet()) => {
+    if (obj == null || typeof obj !== "object")
+        return obj;
+    if (isPrecisionValue(obj)) {
+        return Object.assign(Object.assign({}, obj), { value: obj.scoped });
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => rewriteScopeAndPrecisionValues(item, targetScope, visited));
+    }
+    if (visited.has(obj))
+        return obj;
+    visited.add(obj);
+    if (obj.constructor !== Object) {
+        return obj;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if ((key === "scope" || key === "mainScope") &&
+            typeof value === "string") {
+            result[key] = targetScope;
+            continue;
+        }
+        result[key] = rewriteScopeAndPrecisionValues(value, targetScope, visited);
+    }
+    return result;
+};

package/dist/version-control.d.ts

@@ -0,0 +1,61 @@
+import type { VersionGraph } from "./types";
+export interface RestoredVersion {
+    versionNumber: number;
+    schemaVersion: number;
+    data: Uint8Array;
+    fromCheckpoint: boolean;
+}
+export interface VersionEntry {
+    id: string;
+    versionNumber: number;
+    schemaVersion: number;
+    timestamp: number;
+    description?: string;
+    isManualSave: boolean;
+    userId?: string;
+    versionType: "checkpoint" | "delta";
+    sizeBytes: number;
+}
+/**
+ * Restore the full document state at a specific version number.
+ *
+ * If the version corresponds to a checkpoint, the raw data is returned directly.
+ * Otherwise, the nearest preceding checkpoint is loaded and deltas are replayed
+ * on top of it to reconstruct the state.
+ *
+ * All heavy lifting (SQLite access, decompression, delta replay) happens in
+ * Rust/WASM.
+ */
+export declare const restoreVersion: (ducBuffer: Uint8Array, versionNumber: number) => Promise<RestoredVersion>;
+/**
+ * Restore a specific checkpoint by its ID.
+ */
+export declare const restoreCheckpoint: (ducBuffer: Uint8Array, checkpointId: string) => Promise<RestoredVersion>;
+/**
+ * List all versions (checkpoints and deltas) in the .duc file,
+ * ordered by version number descending. Does not load data blobs.
+ */
+export declare const listVersions: (ducBuffer: Uint8Array) => Promise<VersionEntry[]>;
+/**
+ * Read the full version graph from the .duc file, including all
+ * checkpoints, deltas, chains, and metadata.
+ */
+export declare const readVersionGraph: (ducBuffer: Uint8Array) => Promise<VersionGraph | undefined>;
+/**
+ * Revert the document to a specific version, deleting all versions
+ * newer than the target. Returns the restored state at that version.
+ *
+ * **Warning**: This mutates the .duc buffer in-place (via the WASM
+ * SQLite connection). The returned `RestoredVersion.data` contains the
+ * full document state at the target version.
+ */
+export declare const revertToVersion: (ducBuffer: Uint8Array, targetVersion: number) => Promise<RestoredVersion>;
+/**
+ * Returns the current version-control schema version from Rust.
+ *
+ * This is the single source of truth for the schema version number,
+ * generated from `schema/duc.sql` (`PRAGMA user_version`) at build time.
+ * The version control system handles migration bookkeeping automatically
+ * on the next checkpoint or delta creation.
+ */
+export declare const getCurrentSchemaVersion: () => Promise<number>;