ducjs 2.3.0 → 3.0.0

package/dist/utils/constants.js

@@ -1,4 +1,4 @@
-import { ELEMENT_CONTENT_PREFERENCE, OBJECT_SNAP_MODE, STROKE_JOIN, STROKE_PLACEMENT, STROKE_PREFERENCE, TEXT_ALIGN, VERTICAL_ALIGN } from "../flatbuffers/duc";
+import { ELEMENT_CONTENT_PREFERENCE, STROKE_JOIN, STROKE_PLACEMENT, STROKE_PREFERENCE, TEXT_ALIGN, VERTICAL_ALIGN } from "../enums";
 import { MAX_ZOOM, MIN_ZOOM, NEUTRAL_SCOPE } from "../technical/scopes";
 export const COLOR_PALETTE = {
     transparent: "transparent",
@@ -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}";
@@ -230,7 +243,6 @@ export const DEFAULT_ELEMENT_PROPS = {
     },
     isVisible: true,
     isPlot: true,
-    isAnnotative: false,
     roundness: { value: 0, scoped: 0 },
     opacity: 1,
     locked: false,
@@ -263,201 +275,6 @@ export const DEFAULT_ELLIPSE_ELEMENT = {
     endAngle: Math.PI * 2,
     showAuxCrosshair: false,
 };
-/**
- * Grid display types
- */
-export const GRID_DISPLAY_TYPE = {
-    LINES: 10,
-    DOTS: 11,
-    CROSSES: 12,
-    ADAPTIVE: 13, // Changes based on zoom level
-};
-/**
- * Grid coordinate system types
- */
-export const GRID_TYPE = {
-    RECTANGULAR: 10,
-    ISOMETRIC: 11,
-    POLAR: 12,
-    TRIANGULAR: 13,
-    CUSTOM: 14,
-};
-/**
- * Default grid configurations
- */
-export const DEFAULT_GRID_SETTINGS = {
-    readonly: true,
-    isAdaptive: true,
-    type: GRID_TYPE.RECTANGULAR,
-    displayType: GRID_DISPLAY_TYPE.LINES,
-    xSpacing: { value: 10, scoped: 10 },
-    ySpacing: { value: 10, scoped: 10 },
-    subdivisions: 5,
-    origin: { x: 0, y: 0 },
-    rotation: 0,
-    followUCS: true,
-    majorStyle: {
-        color: "#CCCCCC",
-        opacity: 0.5,
-        dashPattern: [1, 1],
-    },
-    minorStyle: {
-        color: "#EEEEEE",
-        opacity: 0.3,
-        dashPattern: [0.5, 0.5],
-    },
-    showMinor: true,
-    minZoom: 0.1,
-    maxZoom: 100,
-    autoHide: true,
-    enableSnapping: true,
-};
-/**
- * Predefined grid configurations
- */
-export const PREDEFINED_GRIDS = {
-    ARCHITECTURAL_IMPERIAL: "arch-imperial",
-    ARCHITECTURAL_METRIC: "arch-metric",
-    ENGINEERING_IMPERIAL: "eng-imperial",
-    ENGINEERING_METRIC: "eng-metric",
-    ISOMETRIC_30: "iso-30",
-    POLAR_DEGREES: "polar-deg",
-    FINE_DETAIL: "fine-detail",
-};
-/**
- * Snap behavior modes
- */
-export const SNAP_MODE = {
-    RUNNING: 10,
-    SINGLE: 11,
-};
-/**
- * Snap override behaviors
- */
-export const SNAP_OVERRIDE_BEHAVIOR = {
-    DISABLE: 10,
-    FORCE_GRID: 11,
-    FORCE_OBJECT: 12,
-};
-/**
- * Snap marker shapes
- */
-export const SNAP_MARKER_SHAPE = {
-    SQUARE: 10,
-    CIRCLE: 11,
-    TRIANGLE: 12,
-    X: 13,
-};
-/**
- * Default snap settings configuration
- */
-export const DEFAULT_SNAP_SETTINGS = {
-    readonly: true,
-    twistAngle: 0,
-    snapTolerance: 10,
-    objectSnapAperture: 8,
-    isOrthoModeOn: false,
-    polarTracking: {
-        enabled: false,
-        angles: [
-            0,
-            Math.PI / 4,
-            Math.PI / 2,
-            3 * Math.PI / 4,
-            Math.PI,
-            5 * Math.PI / 4,
-            3 * Math.PI / 2,
-            7 * Math.PI / 4
-        ],
-        trackFromLastPoint: true,
-        showPolarCoordinates: true,
-    },
-    isObjectSnapOn: true,
-    activeObjectSnapModes: [
-        OBJECT_SNAP_MODE.ENDPOINT,
-        OBJECT_SNAP_MODE.MIDPOINT,
-        OBJECT_SNAP_MODE.CENTER,
-        OBJECT_SNAP_MODE.INTERSECTION,
-    ],
-    snapPriority: [
-        OBJECT_SNAP_MODE.ENDPOINT,
-        OBJECT_SNAP_MODE.INTERSECTION,
-        OBJECT_SNAP_MODE.MIDPOINT,
-        OBJECT_SNAP_MODE.CENTER,
-        OBJECT_SNAP_MODE.QUADRANT,
-        OBJECT_SNAP_MODE.TANGENT,
-        OBJECT_SNAP_MODE.PERPENDICULAR,
-        OBJECT_SNAP_MODE.NEAREST,
-    ],
-    showTrackingLines: true,
-    trackingLineStyle: {
-        color: "#00FF00",
-        opacity: 0.7,
-        dashPattern: [2, 2],
-    },
-    dynamicSnap: {
-        enabledDuringDrag: true,
-        enabledDuringRotation: true,
-        enabledDuringScale: true,
-    },
-    temporaryOverrides: [
-        { key: "Shift", behavior: SNAP_OVERRIDE_BEHAVIOR.DISABLE },
-        { key: "F9", behavior: SNAP_OVERRIDE_BEHAVIOR.FORCE_GRID },
-    ],
-    magneticStrength: 50,
-    snapMode: SNAP_MODE.RUNNING,
-    snapMarkers: {
-        enabled: true,
-        size: 8,
-        duration: 2000,
-        styles: {
-            [OBJECT_SNAP_MODE.NONE]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#FFFFFF" },
-            [OBJECT_SNAP_MODE.ENDPOINT]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#FF0000" },
-            [OBJECT_SNAP_MODE.MIDPOINT]: { shape: SNAP_MARKER_SHAPE.TRIANGLE, color: "#00FF00" },
-            [OBJECT_SNAP_MODE.INTERSECTION]: { shape: SNAP_MARKER_SHAPE.X, color: "#FF00FF" },
-            [OBJECT_SNAP_MODE.EXTENSION]: { shape: SNAP_MARKER_SHAPE.CIRCLE, color: "#FFA500" },
-            [OBJECT_SNAP_MODE.PERPENDICULAR]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#800080" },
-            [OBJECT_SNAP_MODE.TANGENT]: { shape: SNAP_MARKER_SHAPE.CIRCLE, color: "#008080" },
-            [OBJECT_SNAP_MODE.NEAREST]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#808080" },
-            [OBJECT_SNAP_MODE.NODE]: { shape: SNAP_MARKER_SHAPE.CIRCLE, color: "#FFB6C1" },
-            [OBJECT_SNAP_MODE.INSERT]: { shape: SNAP_MARKER_SHAPE.TRIANGLE, color: "#90EE90" },
-            [OBJECT_SNAP_MODE.PARALLEL]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#F0E68C" },
-            [OBJECT_SNAP_MODE.APPARENT]: { shape: SNAP_MARKER_SHAPE.X, color: "#DDA0DD" },
-            [OBJECT_SNAP_MODE.FROM]: { shape: SNAP_MARKER_SHAPE.CIRCLE, color: "#20B2AA" },
-            [OBJECT_SNAP_MODE.POINT_FILTER]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#F4A460" },
-            [OBJECT_SNAP_MODE.TEMPORARY]: { shape: SNAP_MARKER_SHAPE.CIRCLE, color: "#32CD32" },
-            [OBJECT_SNAP_MODE.BETWEEN_TWO_POINTS]: { shape: SNAP_MARKER_SHAPE.TRIANGLE, color: "#FF6347" },
-            [OBJECT_SNAP_MODE.POINT_ON_CURVE]: { shape: SNAP_MARKER_SHAPE.CIRCLE, color: "#4169E1" },
-            [OBJECT_SNAP_MODE.GEOMETRIC]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#DC143C" },
-            [OBJECT_SNAP_MODE.CENTER]: { shape: SNAP_MARKER_SHAPE.CIRCLE, color: "#0000FF" },
-            [OBJECT_SNAP_MODE.QUADRANT]: { shape: SNAP_MARKER_SHAPE.SQUARE, color: "#FFFF00" },
-        },
-    },
-    constructionSnapEnabled: true,
-    snapToGridIntersections: false,
-};
-export const PAPER_SIZE = {
-    // ISO A Series
-    A0: "A0",
-    A1: "A1",
-    A2: "A2",
-    A3: "A3",
-    A4: "A4",
-    A5: "A5",
-    // ANSI Series
-    ANSI_A: "ANSI_A", // 8.5 x 11
-    ANSI_B: "ANSI_B", // 11 x 17
-    ANSI_C: "ANSI_C", // 17 x 22
-    ANSI_D: "ANSI_D", // 22 x 34
-    ANSI_E: "ANSI_E", // 34 x 44
-    // Architectural
-    ARCH_A: "ARCH_A", // 9 x 12
-    ARCH_B: "ARCH_B", // 12 x 18
-    ARCH_C: "ARCH_C", // 18 x 24
-    ARCH_D: "ARCH_D", // 24 x 36
-    ARCH_E: "ARCH_E", // 36 x 48
-    CUSTOM: "CUSTOM",
-};
 export const PREDEFINED_HATCH_PATTERNS = {
     // Solid Fill
     SOLID: "SOLID",

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);
+}

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

@@ -1,9 +1,8 @@
-export * from "./newElement";
+export * from "./frameElement";
 export * from "./freedrawElement";
 export * from "./linearElement";
+export * from "./newElement";
 export * from "./textElement";
-export * from "./frameElement";
-export * from "./viewportElement";
 import { Scope } from "../../types";
 import { _DucStackBase, DucElement, DucNonSelectionElement, DucTableElement, DucTextStyle, ElementConstructorOpts, NonDeleted } from "../../types/elements";
 import { GeometricPoint, TuplePoint } from "../../types/geometryTypes";
@@ -25,17 +24,7 @@ export declare const getDefaultStackProperties: () => _DucStackBase;
  * which are added during element creation.
  */
 export declare const getDefaultTableData: (currentScope: Scope) => {
-    columnOrder: DucTableElement["columnOrder"];
-    rowOrder: DucTableElement["rowOrder"];
-    columns: DucTableElement["columns"];
-    rows: DucTableElement["rows"];
-    cells: DucTableElement["cells"];
-    flowDirection: DucTableElement["flowDirection"];
-    headerRowStyle: DucTableElement["headerRowStyle"];
-    dataRowStyle: DucTableElement["dataRowStyle"];
-    dataColumnStyle: DucTableElement["dataColumnStyle"];
-    headerRowCount: DucTableElement["headerRowCount"];
-    autoSize: DucTableElement["autoSize"];
+    fileId: DucTableElement["fileId"];
 };
 export declare const getBaseElementProps: (element: DucNonSelectionElement) => ElementConstructorOpts;
 export declare function convertPointToTuple(point: GeometricPoint): TuplePoint;

package/dist/utils/elements/index.js

@@ -1,15 +1,14 @@
-export * from "./newElement";
+export * from "./frameElement";
 export * from "./freedrawElement";
 export * from "./linearElement";
+export * from "./newElement";
 export * from "./textElement";
-export * from "./frameElement";
-export * from "./viewportElement";
-import { LINE_SPACING_TYPE, TABLE_CELL_ALIGNMENT, TABLE_FLOW_DIRECTION } from "../../flatbuffers/duc";
-import { isFreeDrawElement, isLinearElement } from "../../types/elements/typeChecks";
 import { getUpdatedTimestamp } from "..";
-import { DEFAULT_ELEMENT_PROPS, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, FONT_FAMILY } from "../constants";
-import { randomInteger } from "../math/random";
+import { LINE_SPACING_TYPE } from "../../enums";
 import { getPrecisionValueFromRaw } from "../../technical/scopes";
+import { isFreeDrawElement, isLinearElement } from "../../types/elements/typeChecks";
+import { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN } from "../constants";
+import { randomInteger } from "../math/random";
 /**
  * Returns a default DucTextStyle object for the given scope.
  */
@@ -24,7 +23,6 @@ export function getDefaultTextStyle(currentScope) {
         lineSpacing: { type: LINE_SPACING_TYPE.MULTIPLE, value: 1.2 },
         obliqueAngle: 0,
         fontSize: getPrecisionValueFromRaw(DEFAULT_FONT_SIZE, currentScope, currentScope),
-        paperTextHeight: undefined,
         widthFactor: 1,
         isUpsideDown: false,
         isBackwards: false,
@@ -50,7 +48,6 @@ export const getDefaultStackProperties = () => {
         isVisible: true,
         isPlot: true,
         opacity: 1,
-        labelingColor: "transparent",
     };
 };
 /**
@@ -59,96 +56,8 @@ export const getDefaultStackProperties = () => {
  * which are added during element creation.
  */
 export const getDefaultTableData = (currentScope) => {
-    // Default structure
-    const columnCount = 3;
-    const headerRowCount = 1;
-    const dataRowCount = 3; // header + 3 data rows
-    const totalRows = headerRowCount + dataRowCount;
-    const columnIds = Array.from({ length: columnCount }, (_, i) => `col${i + 1}`);
-    const rowIds = Array.from({ length: totalRows }, (_, i) => `row${i + 1}`);
-    // Spacing and sizing
-    const hMargin = getPrecisionValueFromRaw(8, currentScope, currentScope);
-    const vMargin = getPrecisionValueFromRaw(6, currentScope, currentScope);
-    const defaultFontSize = getPrecisionValueFromRaw(DEFAULT_FONT_SIZE, currentScope, currentScope);
-    // Slightly taller header row for visual hierarchy
-    const dataRowHeight = (defaultFontSize.value * 1.2) + (vMargin.value * 2);
-    const headerRowHeight = (defaultFontSize.value * 1.4) + (vMargin.value * 2);
-    // A practical starting column width
-    const defaultColumnWidth = getPrecisionValueFromRaw(140, currentScope, currentScope);
-    // Base/default styling for cells
-    const baseCellStyle = {
-        stroke: [DEFAULT_ELEMENT_PROPS.stroke],
-        background: [DEFAULT_ELEMENT_PROPS.background],
-        roundness: DEFAULT_ELEMENT_PROPS.roundness,
-        opacity: DEFAULT_ELEMENT_PROPS.opacity,
-        textStyle: {
-            isLtr: true,
-            fontFamily: FONT_FAMILY.Virgil,
-            bigFontFamily: "sans-serif",
-            textAlign: DEFAULT_TEXT_ALIGN,
-            verticalAlign: DEFAULT_VERTICAL_ALIGN,
-            lineHeight: 1.2,
-            lineSpacing: { type: LINE_SPACING_TYPE.MULTIPLE, value: 1.2 },
-            obliqueAngle: 0,
-            fontSize: defaultFontSize,
-            paperTextHeight: undefined,
-            widthFactor: 1,
-            isUpsideDown: false,
-            isBackwards: false,
-        },
-        margins: {
-            top: vMargin,
-            right: hMargin,
-            bottom: vMargin,
-            left: hMargin,
-        },
-        // Left + middle is a great general-purpose default for tables
-        alignment: TABLE_CELL_ALIGNMENT.MIDDLE_LEFT,
-    };
-    // Create default columns
-    const columns = Object.fromEntries(columnIds.map((id) => [id, { id, width: defaultColumnWidth }]));
-    // Create default rows (taller header row)
-    const rows = Object.fromEntries(rowIds.map((id, idx) => [
-        id,
-        {
-            id,
-            height: idx < headerRowCount
-                ? getPrecisionValueFromRaw(headerRowHeight, currentScope, currentScope)
-                : getPrecisionValueFromRaw(dataRowHeight, currentScope, currentScope)
-        },
-    ]));
-    // Create default cells
-    const cells = Object.create(null);
-    // Friendly header labels via Markdown (bold)
-    const headerLabels = ["Column A", "Column B", "Column C"];
-    rowIds.forEach((rowId, rIdx) => {
-        columnIds.forEach((colId, cIdx) => {
-            var _a;
-            const cellId = `${rowId}:${colId}`;
-            const isHeaderRow = rIdx < headerRowCount;
-            cells[cellId] = {
-                rowId,
-                columnId: colId,
-                data: isHeaderRow ? `**${(_a = headerLabels[cIdx]) !== null && _a !== void 0 ? _a : `Column ${cIdx + 1}`}**` : "",
-                locked: false,
-            };
-        });
-    });
     return {
-        // Data Structure
-        columnOrder: columnIds,
-        rowOrder: rowIds,
-        columns,
-        rows,
-        cells,
-        // Style & Behavior
-        flowDirection: TABLE_FLOW_DIRECTION.DOWN,
-        headerRowStyle: baseCellStyle,
-        dataRowStyle: baseCellStyle,
-        dataColumnStyle: baseCellStyle,
-        headerRowCount,
-        // Let rows grow to fit content; keep columns fixed unless user opts in
-        autoSize: { columns: false, rows: true },
+        fileId: null,
     };
 };
 export const getBaseElementProps = (element) => {
@@ -159,7 +68,6 @@ export const getBaseElementProps = (element) => {
         label: element.label,
         isVisible: element.isVisible,
         isPlot: element.isPlot,
-        isAnnotative: element.isAnnotative,
         layerId: element.layerId,
         regionIds: element.regionIds,
         blockIds: element.blockIds,

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

@@ -1,13 +1,13 @@
-import { HANDLE_TYPE } from "../../flatbuffers/duc";
 import type { PrecisionValue, RawValue, Scope } from "../../types";
 import type { DucLine, DucLinearElement, DucLinearLikeElement, DucPoint, DucTextElementWithContainer, ElementsMap, NonDeleted } from "../../types/elements";
 import { Bounds, GeometricPoint } from "../../types/geometryTypes";
 import type { ValueOf } from "../../types/utility-types";
 import { ElementAbsoluteCoords } from "../bounds";
+import { HANDLE_TYPE } from "../../enums";
 export type HandleType = ValueOf<typeof HANDLE_TYPE> | null;
 export type HandleInfo = {
     pointIndex: number;
-    handleType: HandleInfo;
+    handleType: HandleType;
     lineIndex: number;
     handle: DucPoint;
 };

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

@@ -1,5 +1,5 @@
 import { Scope } from "../../types";
-import { DucArrowElement, DucDimensionElement, DucDocElement, DucElement, DucEllipseElement, DucEmbeddableElement, DucFeatureControlFrameElement, DucFrameElement, DucFreeDrawElement, DucGenericElement, DucImageElement, DucLeaderElement, DucLinearElement, DucMermaidElement, DucModelElement, DucPdfElement, DucPlotElement, DucPolygonElement, DucTableElement, DucTextElement, DucViewportElement, DucXRayElement, ElementConstructorOpts, ElementUpdate, NonDeleted } from "../../types/elements";
+import { DucArrowElement, DucDocElement, DucElement, DucEllipseElement, DucEmbeddableElement, DucFrameElement, DucFreeDrawElement, DucGenericElement, DucImageElement, DucLinearElement, DucModelElement, DucPdfElement, DucPlotElement, DucPolygonElement, DucTableElement, DucTextElement, ElementConstructorOpts, ElementUpdate, NonDeleted } from "../../types/elements";
 import { Mutable } from "../../types/utility-types";
 export declare const newElementWith: <TElement extends DucElement>(element: TElement, updates: ElementUpdate<TElement>, 
 /** pass `true` to always regenerate */
@@ -12,11 +12,6 @@ export declare const newEmbeddableElement: (currentScope: Scope, opts: {
 } & ElementConstructorOpts) => NonDeleted<DucEmbeddableElement>;
 export declare const newFrameElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucFrameElement>;
 export declare const newPlotElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucPlotElement>;
-export declare const newViewportElement: (currentScope: Scope, opts: {
-    zoom?: number;
-    scopeExponentThreshold?: number;
-    mainScope?: Scope;
-} & ElementConstructorOpts) => NonDeleted<DucViewportElement>;
 export declare const newEllipseElement: (currentScope: Scope, opts: {
     type: "ellipse";
     ratio?: DucEllipseElement["ratio"];
@@ -41,12 +36,7 @@ export declare const newImageElement: (currentScope: Scope, opts: Partial<DucIma
 export declare const newTableElement: (currentScope: Scope, opts: Partial<DucTableElement> & ElementConstructorOpts) => NonDeleted<DucTableElement>;
 export declare const newDocElement: (currentScope: Scope, opts: Partial<DucDocElement> & ElementConstructorOpts) => NonDeleted<DucDocElement>;
 export declare const newPdfElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucPdfElement>;
-export declare const newMermaidElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucMermaidElement>;
-export declare const newXRayElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucXRayElement>;
-export declare const newLeaderElement: (currentScope: Scope, opts: Partial<DucLeaderElement> & ElementConstructorOpts) => NonDeleted<DucLeaderElement>;
-export declare const newDimensionElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucDimensionElement>;
-export declare const newFeatureControlFrameElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucFeatureControlFrameElement>;
-export declare const newParametricElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucModelElement>;
+export declare const newModelElement: (currentScope: Scope, opts: ElementConstructorOpts) => NonDeleted<DucModelElement>;
 /**
  * Clones DucElement data structure. Does not regenerate id, nonce, or
  * any value. The purpose is to to break object references for immutability