ducjs 2.2.3 → 2.4.0

package/dist/restore/restoreElements.js

@@ -3,7 +3,7 @@ isValidColor, isValidDucHead, isValidEnumValue, isValidFunction, isValidImageSca
 import { getPrecisionValueFromRaw, getPrecisionValueFromScoped, getScaledZoomValueForScope, getScopedBezierPointFromDucPoint, getScopedZoomValue, NEUTRAL_SCOPE, ScaleFactors, } from "../technical/scopes";
 import { isElbowArrow, isLinearElement, isTextElement, } from "../types";
 import { arrayToMap, bumpVersion, DEFAULT_ELEMENT_PROPS, DEFAULT_ELLIPSE_ELEMENT, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FREEDRAW_ELEMENT, detectLineHeight, FONT_FAMILY, getContainerElement, getDefaultLocalState, getDefaultTableData, getNormalizedDimensions, getNormalizedPoints, getNormalizedZoom, getSizeFromPoints, getUpdatedTimestamp, isFiniteNumber, isInvisiblySmallElement, LINE_CONFIRM_THRESHOLD, mergeOverlappingPoints, migratePoints, normalizeFixedPoint, normalizeLink, randomId, refreshTextDimensions, validateClosedPath, } from "../utils";
-import { AXIS, BLOCK_ATTACHMENT, COLUMN_TYPE, DATUM_BRACKET_STYLE, DIMENSION_FIT_RULE, DIMENSION_TEXT_PLACEMENT, DIMENSION_TYPE, GDT_SYMBOL, LEADER_CONTENT_TYPE, LINE_SPACING_TYPE, MARK_ELLIPSE_CENTER, MATERIAL_CONDITION, PARAMETRIC_SOURCE_TYPE, STACKED_TEXT_ALIGN, TABLE_CELL_ALIGNMENT, TABLE_FLOW_DIRECTION, TEXT_FLOW_DIRECTION, TOLERANCE_DISPLAY, TOLERANCE_ZONE_TYPE, VERTICAL_ALIGN, VIEWPORT_SHADE_PLOT, } from "../flatbuffers/duc";
+import { AXIS, BLOCK_ATTACHMENT, COLUMN_TYPE, DATUM_BRACKET_STYLE, DIMENSION_FIT_RULE, DIMENSION_TEXT_PLACEMENT, DIMENSION_TYPE, GDT_SYMBOL, LEADER_CONTENT_TYPE, LINE_SPACING_TYPE, MARK_ELLIPSE_CENTER, MATERIAL_CONDITION, STACKED_TEXT_ALIGN, TABLE_CELL_ALIGNMENT, TABLE_FLOW_DIRECTION, TEXT_FLOW_DIRECTION, TOLERANCE_DISPLAY, TOLERANCE_ZONE_TYPE, VERTICAL_ALIGN, VIEWPORT_SHADE_PLOT, } from "../flatbuffers/duc";
 import tinycolor from "tinycolor2";
 const restoreElementWithProperties = (element, extra, localState, globalState) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
@@ -80,7 +80,7 @@ const restoreElementWithProperties = (element, extra, localState, globalState) =
     return Object.assign(Object.assign(Object.assign(Object.assign({}, _element), base), normalized), { type: _element.type });
 };
 const restoreElement = (element, currentScope, restoredBlocks, localState, globalState) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
     // Migration: convert deprecated 'diamond' to 'polygon' with 4 sides
     if (element.type === "diamond") {
         const migrated = Object.assign(Object.assign({}, element), { type: "polygon", sides: 4 });
@@ -90,6 +90,10 @@ const restoreElement = (element, currentScope, restoredBlocks, localState, globa
         case "text": {
             let fontSize = element.fontSize;
             let fontFamily = element.fontFamily;
+            // Restore condition: if font family is "10", change to DEFAULT_FONT_FAMILY
+            if (fontFamily === "10") {
+                fontFamily = DEFAULT_FONT_FAMILY;
+            }
             if ("font" in element) {
                 try {
                     const fontParts = String(element.font).split(" ");
@@ -343,7 +347,10 @@ const restoreElement = (element, currentScope, restoredBlocks, localState, globa
         }
         // Other elements
         case "pdf":
-            return restoreElementWithProperties(element, { fileId: isValidString(element.fileId) || null }, localState);
+            return restoreElementWithProperties(element, {
+                fileId: isValidString(element.fileId) || null,
+                gridConfig: restoreDocumentGridConfig(element.gridConfig),
+            }, localState);
         case "mermaid":
             return restoreElementWithProperties(element, {
                 source: isValidString(element.source),
@@ -381,7 +388,7 @@ const restoreElement = (element, currentScope, restoredBlocks, localState, globa
             const docElement = element;
             return restoreElementWithProperties(element, Object.assign(Object.assign({}, restoreDocStyleProperties(docElement, currentScope)), { text: isValidString(docElement.text), dynamic: restoreTextDynamicParts(docElement.dynamic), flowDirection: (Object.values(TEXT_FLOW_DIRECTION)).includes(docElement.flowDirection)
                     ? docElement.flowDirection
-                    : TEXT_FLOW_DIRECTION.TOP_TO_BOTTOM, columns: restoreTextColumns(docElement.columns, currentScope), autoResize: isValidBooleanValue(docElement.autoResize, true) }), localState);
+                    : TEXT_FLOW_DIRECTION.TOP_TO_BOTTOM, columns: restoreTextColumns(docElement.columns, currentScope), autoResize: isValidBooleanValue(docElement.autoResize, true), fileId: isValidString(docElement.fileId) || null, gridConfig: restoreDocumentGridConfig(docElement.gridConfig) }), localState);
         }
         case "xray": {
             const xrayElement = element;
@@ -393,22 +400,13 @@ const restoreElement = (element, currentScope, restoredBlocks, localState, globa
                 color: isValidColor(xrayElement.color, "#FF00FF"),
             }, localState, globalState);
         }
-        case "parametric": {
-            const parametricElement = element;
-            let source;
-            if (((_s = parametricElement.source) === null || _s === void 0 ? void 0 : _s.type) === PARAMETRIC_SOURCE_TYPE.FILE) {
-                source = {
-                    type: PARAMETRIC_SOURCE_TYPE.FILE,
-                    fileId: isValidString((_t = parametricElement.source) === null || _t === void 0 ? void 0 : _t.fileId),
-                };
-            }
-            else {
-                source = {
-                    type: PARAMETRIC_SOURCE_TYPE.CODE,
-                    code: isValidString((_u = parametricElement.source) === null || _u === void 0 ? void 0 : _u.code),
-                };
-            }
-            return restoreElementWithProperties(parametricElement, { source }, localState, globalState);
+        case "model": {
+            const modelElement = element;
+            return restoreElementWithProperties(modelElement, {
+                source: isValidString(modelElement.source),
+                fileIds: modelElement.fileIds || [],
+                svgPath: modelElement.svgPath || null,
+            }, localState, globalState);
         }
         case "featurecontrolframe": {
             const fcfElement = element;
@@ -417,15 +415,15 @@ const restoreElement = (element, currentScope, restoredBlocks, localState, globa
                 // Restore style properties
                 textStyle: restoreTextStyle(fcfElement.textStyle, currentScope),
                 layout: {
-                    padding: restorePrecisionValue((_v = fcfElement.layout) === null || _v === void 0 ? void 0 : _v.padding, elementScope, currentScope, 2),
-                    segmentSpacing: restorePrecisionValue((_w = fcfElement.layout) === null || _w === void 0 ? void 0 : _w.segmentSpacing, elementScope, currentScope, 2),
-                    rowSpacing: restorePrecisionValue((_x = fcfElement.layout) === null || _x === void 0 ? void 0 : _x.rowSpacing, elementScope, currentScope, 2),
+                    padding: restorePrecisionValue((_s = fcfElement.layout) === null || _s === void 0 ? void 0 : _s.padding, elementScope, currentScope, 2),
+                    segmentSpacing: restorePrecisionValue((_t = fcfElement.layout) === null || _t === void 0 ? void 0 : _t.segmentSpacing, elementScope, currentScope, 2),
+                    rowSpacing: restorePrecisionValue((_u = fcfElement.layout) === null || _u === void 0 ? void 0 : _u.rowSpacing, elementScope, currentScope, 2),
                 },
                 symbols: {
-                    scale: (_z = (_y = fcfElement.symbols) === null || _y === void 0 ? void 0 : _y.scale) !== null && _z !== void 0 ? _z : 1,
+                    scale: (_w = (_v = fcfElement.symbols) === null || _v === void 0 ? void 0 : _v.scale) !== null && _w !== void 0 ? _w : 1,
                 },
                 datumStyle: {
-                    bracketStyle: isValidEnumValue((_0 = fcfElement.datumStyle) === null || _0 === void 0 ? void 0 : _0.bracketStyle, DATUM_BRACKET_STYLE, DATUM_BRACKET_STYLE.SQUARE),
+                    bracketStyle: isValidEnumValue((_x = fcfElement.datumStyle) === null || _x === void 0 ? void 0 : _x.bracketStyle, DATUM_BRACKET_STYLE, DATUM_BRACKET_STYLE.SQUARE),
                 },
                 // Restore data properties
                 rows: restoreFcfRows(fcfElement.rows),
@@ -973,6 +971,28 @@ const restoreTextColumns = (columns, currentScope) => {
         autoHeight: isValidBooleanValue(columns.autoHeight, true),
     };
 };
+const restoreDocumentGridConfig = (gridConfig) => {
+    if (!gridConfig || typeof gridConfig !== "object") {
+        return {
+            columns: 1,
+            gapX: 0,
+            gapY: 0,
+            alignItems: "start",
+            firstPageAlone: false,
+            scale: 1,
+        };
+    }
+    return {
+        columns: typeof gridConfig.columns === "number" ? gridConfig.columns : 1,
+        gapX: typeof gridConfig.gapX === "number" ? gridConfig.gapX : 0,
+        gapY: typeof gridConfig.gapY === "number" ? gridConfig.gapY : 0,
+        alignItems: (typeof gridConfig.alignItems === "string" && ["start", "center", "end"].includes(gridConfig.alignItems))
+            ? gridConfig.alignItems
+            : "start",
+        firstPageAlone: typeof gridConfig.firstPageAlone === "boolean" ? gridConfig.firstPageAlone : false,
+        scale: typeof gridConfig.scale === "number" ? gridConfig.scale : 1,
+    };
+};
 const getFontFamilyByName = (fontFamilyName) => {
     if (Object.keys(FONT_FAMILY).includes(fontFamilyName)) {
         return FONT_FAMILY[fontFamilyName];
@@ -1258,10 +1278,15 @@ const restoreFcfDatumDefinition = (def, elementScope, currentScope, restoredBloc
 const restoreTextStyle = (style, currentScope) => {
     var _a, _b, _c;
     const defaultLineHeight = 1.15;
+    // Restore condition: if font family is "10", change to DEFAULT_FONT_FAMILY
+    let fontFamily = style === null || style === void 0 ? void 0 : style.fontFamily;
+    if (fontFamily === "10") {
+        fontFamily = DEFAULT_FONT_FAMILY;
+    }
     return {
         // Text-specific styles
         isLtr: isValidBoolean(style === null || style === void 0 ? void 0 : style.isLtr, true),
-        fontFamily: getFontFamilyByName(style === null || style === void 0 ? void 0 : style.fontFamily),
+        fontFamily: getFontFamilyByName(fontFamily),
         bigFontFamily: isValidString(style === null || style === void 0 ? void 0 : style.bigFontFamily, "sans-serif"),
         textAlign: isValidTextAlignValue(style === null || style === void 0 ? void 0 : style.textAlign),
         verticalAlign: isValidVerticalAlignValue(style === null || style === void 0 ? void 0 : style.verticalAlign),

package/dist/serialize.js

@@ -740,6 +740,25 @@ function writeColumnLayout(b, c, usv) {
     Duc.ColumnLayout.addAutoHeight(b, c.autoHeight);
     return Duc.ColumnLayout.endColumnLayout(b);
 }
+function writeDocumentGridConfig(b, config, usv) {
+    Duc.DocumentGridConfig.startDocumentGridConfig(b);
+    Duc.DocumentGridConfig.addColumns(b, config.columns);
+    Duc.DocumentGridConfig.addGapX(b, config.gapX);
+    Duc.DocumentGridConfig.addGapY(b, config.gapY);
+    const alignItems = (() => {
+        if (config.alignItems === 'start')
+            return Duc.DOCUMENT_GRID_ALIGN_ITEMS.START;
+        if (config.alignItems === 'center')
+            return Duc.DOCUMENT_GRID_ALIGN_ITEMS.CENTER;
+        if (config.alignItems === 'end')
+            return Duc.DOCUMENT_GRID_ALIGN_ITEMS.END;
+        return Duc.DOCUMENT_GRID_ALIGN_ITEMS.START;
+    })();
+    Duc.DocumentGridConfig.addAlignItems(b, alignItems);
+    Duc.DocumentGridConfig.addFirstPageAlone(b, config.firstPageAlone);
+    Duc.DocumentGridConfig.addScale(b, config.scale);
+    return Duc.DocumentGridConfig.endDocumentGridConfig(b);
+}
 function writeText(b, e, usv) {
     var _a;
     const base = writeElementBase(b, e, usv);
@@ -836,8 +855,14 @@ function writeBlockInstance(b, i, usv) {
             Duc.DucBlockDuplicationArray.startDucBlockDuplicationArray(b);
             Duc.DucBlockDuplicationArray.addRows(b, i.duplicationArray.rows);
             Duc.DucBlockDuplicationArray.addCols(b, i.duplicationArray.cols);
-            Duc.DucBlockDuplicationArray.addRowSpacing(b, getPrecisionValue(i.duplicationArray.rowSpacing, usv));
-            Duc.DucBlockDuplicationArray.addColSpacing(b, getPrecisionValue(i.duplicationArray.colSpacing, usv));
+            const rSpacing = typeof i.duplicationArray.rowSpacing === 'number'
+                ? i.duplicationArray.rowSpacing
+                : getPrecisionValue(i.duplicationArray.rowSpacing, usv);
+            const cSpacing = typeof i.duplicationArray.colSpacing === 'number'
+                ? i.duplicationArray.colSpacing
+                : getPrecisionValue(i.duplicationArray.colSpacing, usv);
+            Duc.DucBlockDuplicationArray.addRowSpacing(b, rSpacing);
+            Duc.DucBlockDuplicationArray.addColSpacing(b, cSpacing);
             return Duc.DucBlockDuplicationArray.endDucBlockDuplicationArray(b);
         })()
         : undefined;
@@ -1378,6 +1403,8 @@ function writeDoc(b, e, usv) {
         Duc.ColumnLayout.addAutoHeight(b, col.autoHeight);
         return Duc.ColumnLayout.endColumnLayout(b);
     })();
+    const fileId = e.fileId ? b.createString(e.fileId) : undefined;
+    const gridConfig = writeDocumentGridConfig(b, e.gridConfig, usv);
     Duc.DucDocElement.startDucDocElement(b);
     Duc.DucDocElement.addBase(b, base);
     Duc.DucDocElement.addStyle(b, style);
@@ -1386,36 +1413,23 @@ function writeDoc(b, e, usv) {
     Duc.DucDocElement.addFlowDirection(b, e.flowDirection);
     Duc.DucDocElement.addColumns(b, columns);
     Duc.DucDocElement.addAutoResize(b, e.autoResize);
+    if (fileId)
+        Duc.DucDocElement.addFileId(b, fileId);
+    Duc.DucDocElement.addGridConfig(b, gridConfig);
     return Duc.DucDocElement.endDucDocElement(b);
 }
 /**
- * Parametric, PDF, Mermaid, Embeddable
+ * PDF, Mermaid, Embeddable
  */
-function writeParametricSource(b, s, usv) {
-    Duc.ParametricSource.startParametricSource(b);
-    Duc.ParametricSource.addType(b, s.type);
-    if (s.type === Duc.PARAMETRIC_SOURCE_TYPE.CODE) {
-        Duc.ParametricSource.addCode(b, b.createString(s.code));
-    }
-    else {
-        Duc.ParametricSource.addFileId(b, b.createString(s.fileId));
-    }
-    return Duc.ParametricSource.endParametricSource(b);
-}
-function writeParametric(b, e, usv) {
-    const base = writeElementBase(b, e, usv);
-    const src = writeParametricSource(b, e.source, usv);
-    Duc.DucParametricElement.startDucParametricElement(b);
-    Duc.DucParametricElement.addBase(b, base);
-    Duc.DucParametricElement.addSource(b, src);
-    return Duc.DucParametricElement.endDucParametricElement(b);
-}
 function writePdf(b, e, usv) {
     const base = writeElementBase(b, e, usv);
-    const fileId = b.createString(e.fileId);
+    const fileId = e.fileId ? b.createString(e.fileId) : undefined;
+    const gridConfig = writeDocumentGridConfig(b, e.gridConfig, usv);
     Duc.DucPdfElement.startDucPdfElement(b);
     Duc.DucPdfElement.addBase(b, base);
-    Duc.DucPdfElement.addFileId(b, fileId);
+    if (fileId)
+        Duc.DucPdfElement.addFileId(b, fileId);
+    Duc.DucPdfElement.addGridConfig(b, gridConfig);
     return Duc.DucPdfElement.endDucPdfElement(b);
 }
 function writeMermaid(b, e, usv) {
@@ -1432,6 +1446,21 @@ function writeMermaid(b, e, usv) {
         Duc.DucMermaidElement.addSvgPath(b, svg);
     return Duc.DucMermaidElement.endDucMermaidElement(b);
 }
+function writeModel(b, e, usv) {
+    var _a;
+    const base = writeElementBase(b, e, usv);
+    const src = b.createString(e.source);
+    const svg = e.svgPath ? b.createString(e.svgPath) : undefined;
+    const fileIds = ((_a = e.fileIds) === null || _a === void 0 ? void 0 : _a.length) ? Duc.DucModelElement.createFileIdsVector(b, e.fileIds.map((id) => b.createString(id))) : undefined;
+    Duc.DucModelElement.startDucModelElement(b);
+    Duc.DucModelElement.addBase(b, base);
+    Duc.DucModelElement.addSource(b, src);
+    if (svg)
+        Duc.DucModelElement.addSvgPath(b, svg);
+    if (fileIds)
+        Duc.DucModelElement.addFileIds(b, fileIds);
+    return Duc.DucModelElement.endDucModelElement(b);
+}
 function writeEmbeddable(b, e, usv) {
     const base = writeElementBase(b, e, usv);
     Duc.DucEmbeddableElement.startDucEmbeddableElement(b);
@@ -1633,9 +1662,9 @@ function writeElementWrapper(b, e, usv) {
             type = Duc.Element.DucDocElement;
             elem = writeDoc(b, e, usv);
             break;
-        case "parametric":
-            type = Duc.Element.DucParametricElement;
-            elem = writeParametric(b, e, usv);
+        case "model":
+            type = Duc.Element.DucModelElement;
+            elem = writeModel(b, e, usv);
             break;
         case "embeddable":
             type = Duc.Element.DucEmbeddableElement;

package/dist/types/elements/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./typeChecks";
 import { DucView, PrecisionValue, Scope } from "..";
-import { BEZIER_MIRRORING, BLENDING, BLOCK_ATTACHMENT, BOOLEAN_OPERATION, COLUMN_TYPE, DATUM_BRACKET_STYLE, DATUM_TARGET_TYPE, DIMENSION_FIT_RULE, DIMENSION_TEXT_PLACEMENT, DIMENSION_TYPE, ELEMENT_CONTENT_PREFERENCE, FEATURE_MODIFIER, GDT_SYMBOL, HATCH_STYLE, IMAGE_STATUS, LINE_HEAD, LINE_SPACING_TYPE, MARK_ELLIPSE_CENTER, MATERIAL_CONDITION, PARAMETRIC_SOURCE_TYPE, STACKED_TEXT_ALIGN, STROKE_CAP, STROKE_JOIN, STROKE_PLACEMENT, STROKE_PREFERENCE, STROKE_SIDE_PREFERENCE, TABLE_CELL_ALIGNMENT, TABLE_FLOW_DIRECTION, TEXT_ALIGN, TEXT_FIELD_SOURCE_PROPERTY, TEXT_FIELD_SOURCE_TYPE, TEXT_FLOW_DIRECTION, TOLERANCE_DISPLAY, TOLERANCE_TYPE, TOLERANCE_ZONE_TYPE, VERTICAL_ALIGN, VIEWPORT_SHADE_PLOT } from "../../flatbuffers/duc";
+import { BEZIER_MIRRORING, BLENDING, BLOCK_ATTACHMENT, BOOLEAN_OPERATION, COLUMN_TYPE, DATUM_BRACKET_STYLE, DATUM_TARGET_TYPE, DIMENSION_FIT_RULE, DIMENSION_TEXT_PLACEMENT, DIMENSION_TYPE, ELEMENT_CONTENT_PREFERENCE, FEATURE_MODIFIER, GDT_SYMBOL, HATCH_STYLE, IMAGE_STATUS, LINE_HEAD, LINE_SPACING_TYPE, MARK_ELLIPSE_CENTER, MATERIAL_CONDITION, STACKED_TEXT_ALIGN, STROKE_CAP, STROKE_JOIN, STROKE_PLACEMENT, STROKE_PREFERENCE, STROKE_SIDE_PREFERENCE, TABLE_CELL_ALIGNMENT, TABLE_FLOW_DIRECTION, TEXT_ALIGN, TEXT_FIELD_SOURCE_PROPERTY, TEXT_FIELD_SOURCE_TYPE, TEXT_FLOW_DIRECTION, TOLERANCE_DISPLAY, TOLERANCE_TYPE, TOLERANCE_ZONE_TYPE, VERTICAL_ALIGN, VIEWPORT_SHADE_PLOT } from "../../flatbuffers/duc";
 import { Standard, StandardUnits } from "../../technical/standards";
 import { FONT_FAMILY, FREEDRAW_EASINGS } from "../../utils/constants";
 import { Axis, GeometricPoint, Percentage, Radian, ScaleFactor } from "../geometryTypes";
@@ -134,7 +134,7 @@ export type DucGenericElement = DucSelectionElement | DucRectangleElement;
  * no computed data. The list of all DucElements should be shareable
  * between peers and contain no state local to the peer.
  */
-export type DucElement = DucGenericElement | DucTextElement | DucLinearElement | DucFreeDrawElement | DucArrowElement | DucImageElement | DucFrameElement | DucEmbeddableElement | DucTableElement | DucDocElement | DucEllipseElement | DucPolygonElement | DucParametricElement | DucFeatureControlFrameElement | DucLeaderElement | DucDimensionElement | DucViewportElement | DucPlotElement | DucXRayElement | DucPdfElement | DucMermaidElement;
+export type DucElement = DucGenericElement | DucTextElement | DucLinearElement | DucFreeDrawElement | DucArrowElement | DucImageElement | DucFrameElement | DucEmbeddableElement | DucTableElement | DucDocElement | DucEllipseElement | DucPolygonElement | DucModelElement | DucFeatureControlFrameElement | DucLeaderElement | DucDimensionElement | DucViewportElement | DucPlotElement | DucXRayElement | DucPdfElement | DucMermaidElement;
 export type DucElementTypes = DucElement["type"];
 export type NonDeleted<TElement extends DucElement> = TElement & {
     isDeleted: boolean;
@@ -316,9 +316,22 @@ export type DucEllipseElement = _DucElementBase & {
 export type DucEmbeddableElement = _DucElementBase & {
     type: "embeddable";
 };
+/**
+ * Configuration for PDF grid layout
+ */
+export type DocumentGridConfig = {
+    columns: number;
+    gapX: number;
+    gapY: number;
+    alignItems: 'start' | 'center' | 'end';
+    firstPageAlone: boolean;
+    scale: number;
+};
 export type DucPdfElement = _DucElementBase & {
     type: "pdf";
     fileId: ExternalFileId | null;
+    /** Configuration for rendering the document in a grid layout */
+    gridConfig: DocumentGridConfig;
 };
 export type DucMermaidElement = _DucElementBase & {
     type: "mermaid";
@@ -458,9 +471,8 @@ export type DucImageElement = _DucElementBase & {
 export type InitializedDucImageElement = MarkNonNullable<DucImageElement, "fileId">;
 export type FontFamilyKeys = keyof typeof FONT_FAMILY;
 export type FontFamilyValues = typeof FONT_FAMILY[FontFamilyKeys];
-export type FontString = string & {
-    _brand: "fontString";
-};
+/** Font family identifier — any valid CSS font-family string (Google Font name, system font, etc.) */
+export type FontString = string;
 export type TextAlign = ValueOf<typeof TEXT_ALIGN>;
 export type VerticalAlign = ValueOf<typeof VERTICAL_ALIGN>;
 export type LineSpacingType = ValueOf<typeof LINE_SPACING_TYPE>;
@@ -474,7 +486,7 @@ export type DucTextStyle = {
     /**
     * The primary font family to use for the text
     */
-    fontFamily: FontFamilyValues;
+    fontFamily: FontString;
     /**
      * Fallback font family for broader compatibility across all systems and languages
      * Useful for emojis, non-latin characters, etc.
@@ -1357,10 +1369,8 @@ export type TextColumn = {
 export type DucDocElement = _DucElementBase & DucDocStyle & {
     type: "doc";
     /**
-     * The content of the document, stored as a Markdown string.
-     * This approach allows a rich text editor (like Tiptap) to manage the complex
-     * inline formatting (bold, italic, colors, hyperlinks, etc.) while keeping the
-     * core data structure simple and clean.
+     * The content of the document, stored as a code string.
+     * This approach allows to use a rich text editor that can compile to PDF using Typst code
      *
      * It can also contain wildcards like `{@fieldname}` for dynamic data insertion.
      * Example: "This is **bold text** and this is a {color:red}red word{/color}."
@@ -1369,6 +1379,9 @@ export type DucDocElement = _DucElementBase & DucDocStyle & {
      * Example: "This document was last saved on {{SaveDate}} by {{Author}}."
      */
     text: string;
+    fileId: ExternalFileId | null;
+    /** Configuration for rendering the document in a grid layout */
+    gridConfig: DocumentGridConfig;
     /**
      * An array of metadata objects that define the behavior of the placeholders
      * found in the `text` property. If this is empty, the text is treated
@@ -1401,27 +1414,15 @@ export type DucDocElement = _DucElementBase & DucDocStyle & {
     autoResize: boolean;
 };
 /**
- * Defines the source of the 3D geometry for a Parametric Element.
- * The geometry is either generated from live code or loaded from an external file.
- */
-export type ParametricElementSource = {
-    /** The geometry is defined by executable Replicad code. */
-    type: PARAMETRIC_SOURCE_TYPE.CODE;
-    /** The JavaScript code that generates the Replicad model. */
-    code: string;
-} | {
-    /** The geometry is loaded from a static 3D file. */
-    type: PARAMETRIC_SOURCE_TYPE.FILE;
-    /** A reference to the imported file in the DucExternalFiles collection. */
-    fileId: ExternalFileId;
-};
-/**
- * An element that embeds a 3D model on the 2D canvas, defined either by
- * parametric Replicad code or by an imported 3D file (e.g., STEP, STL).
+ * An element that embeds a 3D model on the 2D canvas, defined by build123d python code.
  * It includes its own 3D view and display controls.
  */
-export type DucParametricElement = _DucElementBase & {
-    type: "parametric";
-    /** Defines the source of the 3D geometry (either from code or a file). */
-    source: ParametricElementSource;
+export type DucModelElement = _DucElementBase & {
+    type: "model";
+    /** Defines the source of the model using build123d python code */
+    source: string;
+    /** The last known SVG path representation of the 3D model for quick rendering on the canvas */
+    svgPath: string | null;
+    /** Possibly connected external files, such as STEP, STL or other reference models */
+    fileIds: ExternalFileId[];
 };

package/dist/types/elements/typeChecks.d.ts

@@ -1,9 +1,12 @@
 import type { ElementOrToolType } from "..";
 import type { MarkNonNullable } from "../utility-types";
 import { Bounds, LineSegment, TuplePoint } from "../geometryTypes";
-import type { DucArrowElement, DucBindableElement, DucElbowArrowElement, DucElement, DucElementType, DucEmbeddableElement, DucFlowchartNodeElement, DucFrameElement, DucFrameLikeElement, DucFreeDrawElement, DucImageElement, DucLinearElement, DucPlotElement, DucTableElement, DucPointBinding, DucTextContainer, DucTextElement, DucTextElementWithContainer, FixedPointBinding, InitializedDucImageElement, DucNonSelectionElement, DucEllipseElement, DucPolygonElement, NonDeleted, DucIframeLikeElement } from "./";
+import type { DucArrowElement, DucBindableElement, DucDocElement, DucElbowArrowElement, DucElement, DucElementType, DucEmbeddableElement, DucFlowchartNodeElement, DucFrameElement, DucFrameLikeElement, DucFreeDrawElement, DucImageElement, DucLinearElement, DucPdfElement, DucPlotElement, DucTableElement, DucPointBinding, DucTextContainer, DucTextElement, DucTextElementWithContainer, FixedPointBinding, InitializedDucImageElement, DucNonSelectionElement, DucEllipseElement, DucPolygonElement, NonDeleted, DucIframeLikeElement } from "./";
 export declare const isInitializedImageElement: (element: DucElement | null) => element is InitializedDucImageElement;
 export declare const isImageElement: (element: DucElement | null) => element is DucImageElement;
+export declare const isPdfElement: (element: DucElement | null) => element is DucPdfElement;
+export type DucPdfLikeElement = DucPdfElement | DucDocElement;
+export declare const isPdfLikeElement: (element: DucElement | null) => element is DucPdfLikeElement;
 export declare const isEmbeddableElement: (element: DucElement | null | undefined) => element is DucEmbeddableElement;
 export declare const isTableElement: (element: DucElement | null) => element is DucTableElement;
 export declare const isIframeLikeElement: (element: DucElement | null) => element is DucIframeLikeElement;

package/dist/types/elements/typeChecks.js

@@ -5,6 +5,12 @@ export const isInitializedImageElement = (element) => {
 export const isImageElement = (element) => {
     return !!element && element.type === "image";
 };
+export const isPdfElement = (element) => {
+    return !!element && element.type === "pdf";
+};
+export const isPdfLikeElement = (element) => {
+    return !!element && (element.type === "pdf" || element.type === "doc");
+};
 export const isEmbeddableElement = (element) => {
     return !!element && element.type === "embeddable";
 };
@@ -133,7 +139,7 @@ export const isDucElement = (element) => {
         case "leader":
         case "doc":
         case "selection":
-        case "parametric":
+        case "model":
         case "featurecontrolframe":
         case "viewport":
         case "plot":

package/dist/types/index.d.ts

@@ -1,14 +1,14 @@
 export * from "./elements";
 export * from "./geometryTypes";
-export * from "./utility-types";
 export * from "./typeChecks";
+export * from "./utility-types";
 import { OBJECT_SNAP_MODE, PRUNING_LEVEL } from "../flatbuffers/duc";
 import { SupportedMeasures } from "../technical/scopes";
 import { Standard } from "../technical/standards";
+import type { GRID_DISPLAY_TYPE, GRID_TYPE, SNAP_MARKER_SHAPE, SNAP_MODE, SNAP_OVERRIDE_BEHAVIOR } from "../utils/constants";
 import { DucBindableElement, DucBlock, DucBlockCollection, DucBlockInstance, DucElement, DucElementType, DucGroup, DucIframeLikeElement, DucLayer, DucLinearElement, DucPoint, DucRegion, DucTextElement, ElementBackground, ElementStroke, ExternalFileId, FontFamilyValues, LineHead, NonDeleted, TextAlign } from "./elements";
 import { GeometricPoint, Percentage, Radian, ScaleFactor } from "./geometryTypes";
 import { MakeBrand, MarkOptional, MaybePromise, ValueOf } from "./utility-types";
-import type { GRID_DISPLAY_TYPE, GRID_TYPE, SNAP_MARKER_SHAPE, SNAP_MODE, SNAP_OVERRIDE_BEHAVIOR } from "../utils/constants";
 /**
  * Root data structure for the stored data state
  */
@@ -112,7 +112,7 @@ export type SuggestedPointBinding = [
     "start" | "end" | "both",
     NonDeleted<DucBindableElement>
 ];
-export type ToolType = "selection" | "rectangle" | "polygon" | "ellipse" | "line" | "freedraw" | "text" | "image" | "eraser" | "hand" | "frame" | "plot" | "embeddable" | "ruler" | "lasso" | "laser" | "table";
+export type ToolType = "selection" | "rectangle" | "polygon" | "ellipse" | "line" | "freedraw" | "text" | "image" | "eraser" | "hand" | "frame" | "plot" | "embeddable" | "ruler" | "lasso" | "laser" | "table" | "doc" | "pdf";
 export type ElementOrToolType = DucElementType | ToolType | "custom";
 /**
  * Defines the global, persistent settings for the drawing. These are fundamental

package/dist/types/index.js

@@ -1,4 +1,4 @@
 export * from "./elements";
 export * from "./geometryTypes";
-export * from "./utility-types";
 export * from "./typeChecks";
+export * from "./utility-types";

package/dist/utils/constants.d.ts

@@ -89,24 +89,28 @@ 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.
+ * Font family identifiers. Values are the actual CSS font-family names
+ * so they can be passed directly to Google Fonts / Canvas2D.
  *
- * 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
+ * For backward compatibility with old files that stored numeric IDs,
+ * use `LEGACY_FONT_ID_TO_NAME` to resolve them.
  */
 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;
+    readonly Virgil: "Virgil";
+    readonly Helvetica: "Helvetica";
+    readonly Cascadia: "Cascadia";
+    readonly Excalifont: "Excalifont";
+    readonly Nunito: "Nunito";
+    readonly "Lilita One": "Lilita One";
+    readonly "Comic Shanns": "Comic Shanns";
+    readonly "Liberation Sans": "Liberation Sans";
+    readonly "Roboto Mono": "Roboto Mono";
 };
+/**
+ * Reverse mapping from legacy numeric font IDs to font family names.
+ * Used when loading old .duc files that encoded fontFamily as a number.
+ */
+export declare const LEGACY_FONT_ID_TO_NAME: Record<number, string>;
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
 export declare const DEFAULT_VERSION = "{version}";
 export declare const MIN_FONT_SIZE = 1;

package/dist/utils/constants.js

@@ -87,24 +87,37 @@ export const DEFAULT_PROPORTIONAL_RADIUS = 0.25;
 // Fixed radius for the ADAPTIVE_RADIUS algorithm. In pixels.
 export 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.
+ * Font family identifiers. Values are the actual CSS font-family names
+ * so they can be passed directly to Google Fonts / Canvas2D.
  *
- * 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
+ * For backward compatibility with old files that stored numeric IDs,
+ * use `LEGACY_FONT_ID_TO_NAME` to resolve them.
  */
 export const FONT_FAMILY = {
-    Virgil: 1,
-    Helvetica: 2,
-    Cascadia: 3,
-    // leave 4 unused as it was historically used for Assistant (which we don't use anymore) or custom font (Obsidian)
-    Excalifont: 5,
-    Nunito: 6,
-    "Lilita One": 7,
-    "Comic Shanns": 8,
-    "Liberation Sans": 9,
-    "Roboto Mono": 10,
+    Virgil: "Virgil",
+    Helvetica: "Helvetica",
+    Cascadia: "Cascadia",
+    Excalifont: "Excalifont",
+    Nunito: "Nunito",
+    "Lilita One": "Lilita One",
+    "Comic Shanns": "Comic Shanns",
+    "Liberation Sans": "Liberation Sans",
+    "Roboto Mono": "Roboto Mono",
+};
+/**
+ * Reverse mapping from legacy numeric font IDs to font family names.
+ * Used when loading old .duc files that encoded fontFamily as a number.
+ */
+export const LEGACY_FONT_ID_TO_NAME = {
+    1: "Virgil",
+    2: "Helvetica",
+    3: "Cascadia",
+    5: "Excalifont",
+    6: "Nunito",
+    7: "Lilita One",
+    8: "Comic Shanns",
+    9: "Liberation Sans",
+    10: "Roboto Mono",
 };
 export const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
 export const DEFAULT_VERSION = "{version}";

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

@@ -1,2 +1,8 @@
 import { DucFreeDrawElement } from "../../types/elements";
 export declare function getFreeDrawSvgPath(element: DucFreeDrawElement): string;
+/**
+ * Returns the raw outline polygon points from perfect-freehand.
+ * Each point is [x, y]. The result forms a closed polygon that
+ * represents the visual shape of the freedraw stroke.
+ */
+export declare function getFreeDrawStrokePoints(element: DucFreeDrawElement): number[][];

package/dist/utils/elements/freedrawElement.js

@@ -22,16 +22,8 @@ function getSvgPathFromStroke(points) {
         .join(" ")
         .replace(TO_FIXED_PRECISION, "$1");
 }
-export function getFreeDrawSvgPath(element) {
-    // If input points are empty (should they ever be?) return a dot
-    if (element.points.length === 0) {
-        return "";
-    }
-    const inputPoints = element.simulatePressure
-        ? element.points.map(({ x, y }, i) => [x.scoped, y.scoped, element.pressures[i]])
-        : element.points.map(({ x, y }) => [x.scoped, y.scoped]);
-    // Consider changing the options for simulated pressure vs real pressure
-    const options = {
+function buildStrokeOptions(element) {
+    return {
         size: element.size.scoped,
         simulatePressure: element.simulatePressure,
         thinning: element.thinning,
@@ -40,7 +32,32 @@ export function getFreeDrawSvgPath(element) {
         easing: element.easing,
         start: element.start || undefined,
         end: element.end || undefined,
-        last: !!element.lastCommittedPoint, // LastCommittedPoint is added on pointerup
+        last: !!element.lastCommittedPoint,
     };
+}
+function buildInputPoints(element) {
+    return element.simulatePressure
+        ? element.points.map(({ x, y }, i) => [x.scoped, y.scoped, element.pressures[i]])
+        : element.points.map(({ x, y }) => [x.scoped, y.scoped]);
+}
+export function getFreeDrawSvgPath(element) {
+    if (element.points.length === 0) {
+        return "";
+    }
+    const inputPoints = buildInputPoints(element);
+    const options = buildStrokeOptions(element);
     return getSvgPathFromStroke(getStroke(inputPoints, options));
 }
+/**
+ * Returns the raw outline polygon points from perfect-freehand.
+ * Each point is [x, y]. The result forms a closed polygon that
+ * represents the visual shape of the freedraw stroke.
+ */
+export function getFreeDrawStrokePoints(element) {
+    if (element.points.length === 0) {
+        return [];
+    }
+    const inputPoints = buildInputPoints(element);
+    const options = buildStrokeOptions(element);
+    return getStroke(inputPoints, options);
+}