ducjs 2.3.0 → 3.0.0

package/dist/technical/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./standards";
 export * from "./measurements";
 export * from "./scopes";

package/dist/technical/index.js

@@ -1,3 +1,2 @@
-export * from "./standards";
 export * from "./measurements";
 export * from "./scopes";

package/dist/technical/scopes.d.ts

@@ -1,4 +1,4 @@
-import { UNIT_SYSTEM } from "../flatbuffers/duc";
+import { UNIT_SYSTEM } from "../enums";
 import { PrecisionValue, RawValue, ScaledZoom, Scope, ScopedValue, ScopedZoomValue, ValueOf } from "../types";
 import { DucPoint } from "../types/elements";
 import { GeometricPoint } from "../types/geometryTypes";

package/dist/technical/scopes.js

@@ -1,4 +1,4 @@
-import { UNIT_SYSTEM } from "../flatbuffers/duc";
+import { UNIT_SYSTEM } from "../enums";
 export const MIN_ZOOM = 1e-32;
 export const MAX_ZOOM = 1e32;
 export const NEUTRAL_SCOPE = "m";

package/dist/transform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Post-parse transformation: fix stack element nesting
+ * (move stackBase fields to top level for frame/plot elements).
+ *
+ * Also adds `type` discriminator to version graph entries.
+ */
+export declare function transformFromRust(data: any): any;
+/**
+ * Pre-serialize transformation: re-wrap stack element fields
+ * and flatten PrecisionValue objects to plain numbers for Rust.
+ */
+export declare function transformToRust(data: any): any;

package/dist/transform.js

@@ -0,0 +1,442 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * Post-parse transformation: fix stack element nesting
+ * (move stackBase fields to top level for frame/plot elements).
+ *
+ * Also adds `type` discriminator to version graph entries.
+ */
+export function transformFromRust(data) {
+    if (!data)
+        return data;
+    if (data.elements) {
+        data.elements = data.elements.map(fixElementFromRust);
+    }
+    if (data.versionGraph) {
+        const vg = data.versionGraph;
+        if (vg.checkpoints) {
+            vg.checkpoints = vg.checkpoints.map((c) => (Object.assign(Object.assign({}, c), { type: "checkpoint" })));
+        }
+        if (vg.deltas) {
+            vg.deltas = vg.deltas.map((d) => (Object.assign(Object.assign({}, d), { type: "delta" })));
+        }
+    }
+    if (data.layers) {
+        data.layers = data.layers.map((layer) => {
+            if (layer === null || layer === void 0 ? void 0 : layer.overrides) {
+                layer = Object.assign(Object.assign({}, layer), { overrides: fixLayerOverridesHatch(layer.overrides, true) });
+            }
+            return layer;
+        });
+    }
+    if (data.blockInstances) {
+        data.blockInstances = data.blockInstances.map((bi) => {
+            if (Array.isArray(bi === null || bi === void 0 ? void 0 : bi.elementOverrides)) {
+                const record = {};
+                for (const entry of bi.elementOverrides) {
+                    if ((entry === null || entry === void 0 ? void 0 : entry.key) !== undefined)
+                        record[entry.key] = entry.value;
+                }
+                return Object.assign(Object.assign({}, bi), { elementOverrides: record });
+            }
+            return bi;
+        });
+    }
+    if (data.blocks) {
+        data.blocks = data.blocks.map((block) => {
+            if (block === null || block === void 0 ? void 0 : block.metadata)
+                fixLocalizationFromRust(block.metadata);
+            return block;
+        });
+    }
+    if (data.blockCollections) {
+        data.blockCollections = data.blockCollections.map((collection) => {
+            if (collection === null || collection === void 0 ? void 0 : collection.metadata)
+                fixLocalizationFromRust(collection.metadata);
+            return collection;
+        });
+    }
+    return data;
+}
+/**
+ * Pre-serialize transformation: re-wrap stack element fields
+ * and flatten PrecisionValue objects to plain numbers for Rust.
+ */
+export function transformToRust(data) {
+    if (!data)
+        return data;
+    const result = Object.assign({}, data);
+    if (result.elements) {
+        result.elements = result.elements.map((el) => coerceElementIntegerFields(flattenPrecisionValues(fixElementToRust(el))));
+    }
+    if (result.localState) {
+        result.localState = normalizeLocalStateForRust(result.localState);
+    }
+    if (result.globalState) {
+        result.globalState = normalizeGlobalStateForRust(result.globalState);
+    }
+    if (result.versionGraph) {
+        const vg = Object.assign({}, result.versionGraph);
+        if (vg.checkpoints) {
+            vg.checkpoints = vg.checkpoints.map((_a) => {
+                var { type: _ } = _a, rest = __rest(_a, ["type"]);
+                return rest;
+            });
+        }
+        if (vg.deltas) {
+            vg.deltas = vg.deltas.map((_a) => {
+                var { type: _ } = _a, rest = __rest(_a, ["type"]);
+                return rest;
+            });
+        }
+        result.versionGraph = vg;
+    }
+    if (result.layers) {
+        result.layers = result.layers.map((layer) => {
+            let l = Object.assign({}, layer);
+            if (l.overrides) {
+                l.overrides = fixLayerOverridesHatch(l.overrides, false);
+            }
+            return flattenPrecisionValues(l);
+        });
+    }
+    if (result.blockInstances) {
+        result.blockInstances = result.blockInstances.map((bi) => {
+            let b = Object.assign({}, bi);
+            if (b.elementOverrides && !Array.isArray(b.elementOverrides) && typeof b.elementOverrides === "object") {
+                b.elementOverrides = Object.entries(b.elementOverrides).map(([key, value]) => ({ key, value: String(value) }));
+            }
+            return flattenPrecisionValues(b);
+        });
+    }
+    if (result.blocks) {
+        result.blocks = result.blocks.map((block) => {
+            let b = Object.assign({}, block);
+            if (b.metadata) {
+                b.metadata = Object.assign({}, b.metadata);
+                fixLocalizationToRust(b.metadata);
+            }
+            return b;
+        });
+    }
+    if (result.blockCollections) {
+        result.blockCollections = result.blockCollections.map((collection) => {
+            let c = Object.assign({}, collection);
+            if (c.metadata) {
+                c.metadata = Object.assign({}, c.metadata);
+                fixLocalizationToRust(c.metadata);
+            }
+            return c;
+        });
+    }
+    return result;
+}
+import { FREEDRAW_EASINGS } from "./utils/constants";
+const STACK_ELEMENT_TYPES = new Set(["frame", "plot"]);
+const LINEAR_ELEMENT_TYPES = new Set(["line", "arrow", "freedraw"]);
+const EASING_FN_TO_NAME = new Map(Object.entries(FREEDRAW_EASINGS).map(([name, fn]) => [fn, name]));
+const TEXT_STYLE_FIELDS = new Set([
+    "isLtr", "fontFamily", "bigFontFamily", "textAlign", "verticalAlign",
+    "lineHeight", "lineSpacing", "obliqueAngle", "fontSize", "widthFactor",
+    "isUpsideDown", "isBackwards",
+]);
+// --- Hatch pattern: Rust flat fields ↔ TS nested `pattern` object ---
+function fixHatchFromRust(hatch) {
+    if (!hatch || typeof hatch !== "object" || hatch.pattern)
+        return hatch;
+    const { patternName, patternScale, patternAngle, patternOrigin, patternDouble } = hatch, rest = __rest(hatch, ["patternName", "patternScale", "patternAngle", "patternOrigin", "patternDouble"]);
+    if (patternName === undefined)
+        return hatch;
+    return Object.assign(Object.assign({}, rest), { pattern: { name: patternName, scale: patternScale, angle: patternAngle, origin: patternOrigin, double: patternDouble } });
+}
+function fixHatchToRust(hatch) {
+    if (!(hatch === null || hatch === void 0 ? void 0 : hatch.pattern))
+        return hatch;
+    const { pattern } = hatch, rest = __rest(hatch, ["pattern"]);
+    return Object.assign(Object.assign({}, rest), { patternName: pattern.name, patternScale: pattern.scale, patternAngle: pattern.angle, patternOrigin: pattern.origin, patternDouble: pattern.double });
+}
+function fixContentHatch(content, fromRust) {
+    if (!(content === null || content === void 0 ? void 0 : content.hatch))
+        return content;
+    return Object.assign(Object.assign({}, content), { hatch: fromRust ? fixHatchFromRust(content.hatch) : fixHatchToRust(content.hatch) });
+}
+function fixStylesHatch(el, fromRust) {
+    var _a, _b, _c, _d;
+    if (Array.isArray(el === null || el === void 0 ? void 0 : el.background)) {
+        for (let i = 0; i < el.background.length; i++) {
+            if ((_b = (_a = el.background[i]) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.hatch) {
+                el.background[i] = Object.assign(Object.assign({}, el.background[i]), { content: fixContentHatch(el.background[i].content, fromRust) });
+            }
+        }
+    }
+    if (Array.isArray(el === null || el === void 0 ? void 0 : el.stroke)) {
+        for (let i = 0; i < el.stroke.length; i++) {
+            if ((_d = (_c = el.stroke[i]) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.hatch) {
+                el.stroke[i] = Object.assign(Object.assign({}, el.stroke[i]), { content: fixContentHatch(el.stroke[i].content, fromRust) });
+            }
+        }
+    }
+}
+function fixLayerOverridesHatch(overrides, fromRust) {
+    var _a, _b, _c, _d;
+    if (!overrides)
+        return overrides;
+    let result = overrides;
+    if ((_b = (_a = result.stroke) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.hatch) {
+        result = Object.assign(Object.assign({}, result), { stroke: Object.assign(Object.assign({}, result.stroke), { content: fixContentHatch(result.stroke.content, fromRust) }) });
+    }
+    if ((_d = (_c = result.background) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.hatch) {
+        result = Object.assign(Object.assign({}, result), { background: Object.assign(Object.assign({}, result.background), { content: fixContentHatch(result.background.content, fromRust) }) });
+    }
+    return result;
+}
+// --- Viewer3DGrid: Rust `value` key ↔ TS `planes` key for perPlane variant ---
+function fixViewer3DGridFromRust(grid) {
+    if ((grid === null || grid === void 0 ? void 0 : grid.type) === "perPlane" && "value" in grid && !("planes" in grid)) {
+        const { value } = grid, rest = __rest(grid, ["value"]);
+        return Object.assign(Object.assign({}, rest), { planes: value });
+    }
+    return grid;
+}
+function fixViewer3DGridToRust(grid) {
+    if ((grid === null || grid === void 0 ? void 0 : grid.type) === "perPlane" && "planes" in grid) {
+        const { planes } = grid, rest = __rest(grid, ["planes"]);
+        return Object.assign(Object.assign({}, rest), { value: planes });
+    }
+    return grid;
+}
+// --- customData: Rust `Option<String>` (JSON) ↔ TS `Record<string, any>` ---
+function fixCustomDataFromRust(el) {
+    if (typeof (el === null || el === void 0 ? void 0 : el.customData) === "string") {
+        try {
+            el.customData = JSON.parse(el.customData);
+        }
+        catch ( /* keep as string */_a) { /* keep as string */ }
+    }
+}
+function fixCustomDataToRust(el) {
+    if ((el === null || el === void 0 ? void 0 : el.customData) != null && typeof el.customData !== "string") {
+        el.customData = JSON.stringify(el.customData);
+    }
+}
+// --- Block metadata localization: Rust `Option<String>` (JSON) ↔ TS Record ---
+function fixLocalizationFromRust(metadata) {
+    if (typeof (metadata === null || metadata === void 0 ? void 0 : metadata.localization) === "string") {
+        try {
+            metadata.localization = JSON.parse(metadata.localization);
+        }
+        catch ( /* keep as string */_a) { /* keep as string */ }
+    }
+}
+function fixLocalizationToRust(metadata) {
+    if ((metadata === null || metadata === void 0 ? void 0 : metadata.localization) != null && typeof metadata.localization !== "string") {
+        metadata.localization = JSON.stringify(metadata.localization);
+    }
+}
+function fixElementFromRust(el) {
+    var _a, _b, _c;
+    if (!el)
+        return el;
+    fixStylesHatch(el, true);
+    fixCustomDataFromRust(el);
+    if (el.type === "model" && ((_b = (_a = el.viewerState) === null || _a === void 0 ? void 0 : _a.display) === null || _b === void 0 ? void 0 : _b.grid)) {
+        el.viewerState = Object.assign(Object.assign({}, el.viewerState), { display: Object.assign(Object.assign({}, el.viewerState.display), { grid: fixViewer3DGridFromRust(el.viewerState.display.grid) }) });
+    }
+    // Convert Rust DucLine structs { start, end } → TypeScript tuples [start, end]
+    if (LINEAR_ELEMENT_TYPES.has(el.type) && Array.isArray(el.lines)) {
+        el.lines = el.lines.map((line) => {
+            if (Array.isArray(line))
+                return line;
+            if (line && line.start !== undefined && line.end !== undefined) {
+                return [line.start, line.end];
+            }
+            return line;
+        });
+    }
+    // Convert easing string key → function for freedraw elements
+    if (el.type === "freedraw") {
+        el = convertEasingFromRust(el);
+    }
+    // Unwrap nested text style → flat fields for TS
+    if (el.type === "text" && el.style && typeof el.style === "object") {
+        const { style } = el, rest = __rest(el, ["style"]);
+        return Object.assign(Object.assign({}, rest), style);
+    }
+    // Remove empty style from table/doc elements
+    if ((el.type === "table" || el.type === "doc") && "style" in el) {
+        const { style: _ } = el, rest = __rest(el, ["style"]);
+        return rest;
+    }
+    if (!STACK_ELEMENT_TYPES.has(el.type))
+        return el;
+    // Stack elements (frame, plot) — unwrap stackBase, remove empty plot style
+    const { stackBase, style: _plotStyle } = el, rest = __rest(el, ["stackBase", "style"]);
+    if (!stackBase)
+        return el;
+    return Object.assign(Object.assign({}, rest), { isCollapsed: (_c = stackBase.isCollapsed) !== null && _c !== void 0 ? _c : false });
+}
+function fixElementToRust(el) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!el)
+        return el;
+    fixStylesHatch(el, false);
+    fixCustomDataToRust(el);
+    if (el.type === "model" && ((_b = (_a = el.viewerState) === null || _a === void 0 ? void 0 : _a.display) === null || _b === void 0 ? void 0 : _b.grid)) {
+        el.viewerState = Object.assign(Object.assign({}, el.viewerState), { display: Object.assign(Object.assign({}, el.viewerState.display), { grid: fixViewer3DGridToRust(el.viewerState.display.grid) }) });
+    }
+    // Convert TypeScript DucLine tuples [start, end] → Rust structs { start, end }
+    if (LINEAR_ELEMENT_TYPES.has(el.type) && Array.isArray(el.lines)) {
+        el.lines = el.lines.map((line) => {
+            if (Array.isArray(line)) {
+                return { start: line[0], end: line[1] };
+            }
+            return line;
+        });
+    }
+    // Convert easing function → string key for freedraw elements
+    if (el.type === "freedraw") {
+        el = convertEasingToRust(el);
+    }
+    // Wrap flat text style fields into nested `style` object for Rust serde
+    if (el.type === "text") {
+        const style = {};
+        const rest = {};
+        for (const key of Object.keys(el)) {
+            if (TEXT_STYLE_FIELDS.has(key)) {
+                style[key] = el[key];
+            }
+            else {
+                rest[key] = el[key];
+            }
+        }
+        return Object.assign(Object.assign({}, rest), { style });
+    }
+    // Add empty style for table/doc elements
+    if (el.type === "table" || el.type === "doc") {
+        return Object.assign(Object.assign({}, el), { style: {} });
+    }
+    if (!STACK_ELEMENT_TYPES.has(el.type))
+        return el;
+    const { isCollapsed } = el, rest = __rest(el, ["isCollapsed"]);
+    return Object.assign(Object.assign(Object.assign({}, rest), (el.type === "plot" ? { style: {} } : {})), { stackBase: {
+            label: (_c = el.label) !== null && _c !== void 0 ? _c : "",
+            description: (_d = el.description) !== null && _d !== void 0 ? _d : null,
+            isCollapsed: isCollapsed !== null && isCollapsed !== void 0 ? isCollapsed : false,
+            isPlot: (_e = el.isPlot) !== null && _e !== void 0 ? _e : false,
+            isVisible: (_f = el.isVisible) !== null && _f !== void 0 ? _f : true,
+            locked: (_g = el.locked) !== null && _g !== void 0 ? _g : false,
+            opacity: (_h = el.opacity) !== null && _h !== void 0 ? _h : 1.0,
+        } });
+}
+/**
+ * Recursively convert PrecisionValue objects ({value, scoped}) to plain
+ * numbers (extracting `.value` — the raw/unscoped value) so Rust's serde
+ * can deserialize them as f64.
+ */
+function flattenPrecisionValues(obj) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (isPrecisionValueLike(obj))
+        return obj.value;
+    if (Array.isArray(obj))
+        return obj.map(flattenPrecisionValues);
+    if (typeof obj === "object") {
+        const out = {};
+        for (const key in obj) {
+            if (!Object.prototype.hasOwnProperty.call(obj, key))
+                continue;
+            out[key] = flattenPrecisionValues(obj[key]);
+        }
+        return out;
+    }
+    return obj;
+}
+function isPrecisionValueLike(v) {
+    return (v !== null &&
+        typeof v === "object" &&
+        !Array.isArray(v) &&
+        typeof v.value === "number" &&
+        typeof v.scoped === "number" &&
+        Object.keys(v).length === 2);
+}
+function toNumberFromPrecisionLike(value, fallback) {
+    const flattened = flattenPrecisionValues(value);
+    if (typeof flattened === "number" && Number.isFinite(flattened)) {
+        return flattened;
+    }
+    return fallback;
+}
+function toInteger(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    return Math.trunc(value);
+}
+function coerceElementIntegerFields(el) {
+    if (!el || typeof el !== "object")
+        return el;
+    return Object.assign(Object.assign({}, el), { seed: toInteger(el.seed, 1), version: toInteger(el.version, 1), versionNonce: toInteger(el.versionNonce, 0) });
+}
+function normalizeLocalStateForRust(localState) {
+    if (!localState || typeof localState !== "object")
+        return localState;
+    return Object.assign(Object.assign({}, localState), { scrollX: toNumberFromPrecisionLike(localState.scrollX, 0), scrollY: toNumberFromPrecisionLike(localState.scrollY, 0), zoom: localState.zoom && typeof localState.zoom === "object"
+            ? toNumberFromPrecisionLike(localState.zoom.value, 1)
+            : toNumberFromPrecisionLike(localState.zoom, 1), currentItemStroke: flattenPrecisionValues(localState.currentItemStroke), currentItemBackground: flattenPrecisionValues(localState.currentItemBackground), currentItemFontSize: toNumberFromPrecisionLike(localState.currentItemFontSize, 16), currentItemRoundness: toNumberFromPrecisionLike(localState.currentItemRoundness, 0), currentItemTextAlign: toInteger(localState.currentItemTextAlign, 10), decimalPlaces: toInteger(localState.decimalPlaces, 2) });
+}
+function normalizeGlobalStateForRust(globalState) {
+    if (!globalState || typeof globalState !== "object")
+        return globalState;
+    return Object.assign(Object.assign({}, globalState), { scopeExponentThreshold: toInteger(globalState.scopeExponentThreshold, 4), pruningLevel: toInteger(globalState.pruningLevel, 20) });
+}
+function easingFnToName(fn) {
+    var _a;
+    if (typeof fn === "string")
+        return fn;
+    if (typeof fn === "function") {
+        return (_a = EASING_FN_TO_NAME.get(fn)) !== null && _a !== void 0 ? _a : "easeOutSine";
+    }
+    return "easeOutSine";
+}
+function easingNameToFn(name) {
+    if (typeof name === "function")
+        return name;
+    if (typeof name === "string" && name in FREEDRAW_EASINGS) {
+        return FREEDRAW_EASINGS[name];
+    }
+    return FREEDRAW_EASINGS.easeOutSine;
+}
+function convertEasingToRust(el) {
+    var _a, _b;
+    const result = Object.assign({}, el);
+    if (result.easing != null) {
+        result.easing = easingFnToName(result.easing);
+    }
+    if (((_a = result.start) === null || _a === void 0 ? void 0 : _a.easing) != null) {
+        result.start = Object.assign(Object.assign({}, result.start), { easing: easingFnToName(result.start.easing) });
+    }
+    if (((_b = result.end) === null || _b === void 0 ? void 0 : _b.easing) != null) {
+        result.end = Object.assign(Object.assign({}, result.end), { easing: easingFnToName(result.end.easing) });
+    }
+    return result;
+}
+function convertEasingFromRust(el) {
+    if (typeof el.easing === "string") {
+        el.easing = easingNameToFn(el.easing);
+    }
+    if (el.start && typeof el.start.easing === "string") {
+        el.start = Object.assign(Object.assign({}, el.start), { easing: easingNameToFn(el.start.easing) });
+    }
+    if (el.end && typeof el.end.easing === "string") {
+        el.end = Object.assign(Object.assign({}, el.end), { easing: easingNameToFn(el.end.easing) });
+    }
+    return el;
+}