ducjs 1.0.0

package/dist/legacy/v1/parse/parseElementFromBinary.js

@@ -0,0 +1,387 @@
+import { getPrecisionValueFromRaw, NEUTRAL_SCOPE } from 'ducjs/legacy/v1/utils/scopes';
+import { DEFAULT_ELEMENT_PROPS, FREEDRAW_EASINGS } from 'ducjs/legacy/v1/utils/constants';
+import tinycolor from 'tinycolor2';
+export const parsePoint = (point, elementScope) => {
+    if (!point)
+        return null;
+    return Object.assign({ x: getPrecisionValueFromRaw(point.xV3(), elementScope, elementScope), y: getPrecisionValueFromRaw(point.yV3(), elementScope, elementScope) }, (point.mirroring() && { mirroring: point.mirroring() }));
+};
+const parseLineReference = (lineRef, elementScope) => {
+    if (!lineRef)
+        return null;
+    const handle = lineRef.handle();
+    return {
+        index: lineRef.index(),
+        handle: handle ? {
+            x: getPrecisionValueFromRaw(handle.x(), elementScope, elementScope),
+            y: getPrecisionValueFromRaw(handle.y(), elementScope, elementScope)
+        } : null
+    };
+};
+const parseLine = (line, elementScope) => {
+    if (!line)
+        return null;
+    const start = parseLineReference(line.start(), elementScope);
+    const end = parseLineReference(line.end(), elementScope);
+    if (!start || !end)
+        return null;
+    return [start, end];
+};
+const parseDucPath = (path, elementScope) => {
+    if (!path)
+        return null;
+    const lineIndices = Array.from({ length: path.lineIndicesLength() })
+        .map((_, i) => path.lineIndices(i))
+        .filter((index) => index !== null && index !== undefined);
+    const background = path.background() ? parseElementBinBackground(path.background()) : null;
+    const stroke = path.stroke() ? parseElementBinStroke(path.stroke(), elementScope) : null;
+    return {
+        lineIndices,
+        background,
+        stroke
+    };
+};
+const parseBindingPoint = (bindingPoint) => {
+    if (!bindingPoint)
+        return null;
+    return {
+        index: bindingPoint.index(),
+        offset: bindingPoint.offset()
+    };
+};
+const parsePointBinding = (binding, elementScope) => {
+    if (!binding)
+        return null;
+    const fixedPoint = binding.fixedPoint();
+    return {
+        elementId: binding.elementId() || '',
+        focus: binding.focus(),
+        gap: getPrecisionValueFromRaw(binding.gap(), elementScope, elementScope),
+        fixedPoint: fixedPoint ? {
+            x: fixedPoint.x(),
+            y: fixedPoint.y(),
+        } : null,
+        point: binding.point() ? parseBindingPoint(binding.point()) : null,
+        head: binding.head()
+    };
+};
+export const parseElementFromBinary = (e, v) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    if (!e)
+        return null;
+    const elType = e.type();
+    if (!elType)
+        return null;
+    const forceNeutralScope = v <= 5;
+    let readScope = e.scope();
+    const elementScope = forceNeutralScope ? NEUTRAL_SCOPE : (readScope || NEUTRAL_SCOPE);
+    // Populate groupIds array
+    let groupIds = [];
+    for (let j = 0; j < e.groupIdsLength(); j++) {
+        groupIds.push(e.groupIds(j) || '');
+    }
+    // Populate boundElements array
+    const boundElements = Array.from({ length: e.boundElementsLength() })
+        .map((_, j) => e.boundElements(j))
+        .filter((element) => !!element)
+        .map(boundElement => ({
+        id: boundElement.id(),
+        type: boundElement.type()
+    }))
+        .filter((element) => !!element.id && !!element.type);
+    // Handle backward compatibility for stroke and background
+    let strokes = [];
+    let backgrounds = [];
+    // v4
+    if (e.strokeLength && e.strokeLength() > 0) {
+        strokes = Array.from({ length: e.strokeLength() })
+            .map((_, i) => {
+            const stroke = e.stroke(i);
+            return parseElementBinStroke(stroke, elementScope);
+        })
+            .filter((stroke) => stroke !== null);
+    }
+    // v3
+    else if (e.strokeColorV3 && e.strokeColorV3()) {
+        const strokeColor = e.strokeColorV3();
+        const color = tinycolor(strokeColor);
+        const stroke = Object.assign(Object.assign({}, DEFAULT_ELEMENT_PROPS.stroke), { content: Object.assign(Object.assign({}, DEFAULT_ELEMENT_PROPS.stroke.content), { src: color.toHexString(), opacity: color.getAlpha() }) });
+        strokes = [stroke];
+    }
+    // v4
+    if (e.backgroundLength && e.backgroundLength() > 0) {
+        backgrounds = Array.from({ length: e.backgroundLength() })
+            .map((_, i) => {
+            const background = e.background(i);
+            return parseElementBinBackground(background);
+        })
+            .filter((background) => background !== null);
+    }
+    // v3
+    else if (e.backgroundColorV3 && e.backgroundColorV3()) {
+        const backgroundColor = e.backgroundColorV3();
+        const color = tinycolor(backgroundColor);
+        const background = {
+            content: Object.assign(Object.assign({}, DEFAULT_ELEMENT_PROPS.background.content), { src: color.toHexString(), opacity: color.getAlpha() })
+        };
+        backgrounds = [background];
+    }
+    const points = ['freedraw', 'line', 'arrow'].includes(elType)
+        ? Array.from({ length: e.linearElementPointsLength() })
+            .map((_, j) => e.linearElementPoints(j))
+            .filter((point) => !!point)
+            .map(point => parsePoint(point, elementScope))
+            .filter((point) => point !== null)
+        : [];
+    const lines = ['line', 'arrow'].includes(elType)
+        ? e.linearElementLines(0) !== null || e.linearElementLinesLength() > 0 // Check if field exists
+            ? Array.from({ length: e.linearElementLinesLength() })
+                .map((_, j) => e.linearElementLines(j))
+                .filter((line) => !!line)
+                .map(line => parseLine(line, elementScope))
+                .filter((line) => line !== null)
+            : undefined
+        : undefined;
+    const pathOverrides = ['line', 'arrow'].includes(elType)
+        ? e.linearElementPathOverrides(0) !== null || e.linearElementPathOverridesLength() > 0
+            ? Array.from({ length: e.linearElementPathOverridesLength() })
+                .map((_, j) => e.linearElementPathOverrides(j))
+                .filter((path) => !!path)
+                .map(path => parseDucPath(path, elementScope))
+                .filter((path) => path !== null)
+            : undefined
+        : undefined;
+    const pressures = elType === 'freedraw'
+        ? Array.from({ length: e.freeDrawPressuresLength() })
+            .map((_, j) => e.freeDrawPressures(j))
+            .filter((pressure) => pressure !== null && pressure !== undefined)
+        : [];
+    const xValue = v > 2 ? e.x() : e.xV2() || undefined;
+    const yValue = v > 2 ? e.y() : e.yV2() || undefined;
+    const widthValue = v > 2 ? e.width() : e.widthV2() || undefined;
+    const heightValue = v > 2 ? e.height() : e.heightV2() || undefined;
+    const roundnessValue = e.roundness();
+    const baseElement = {
+        id: e.id() || undefined,
+        x: xValue ? getPrecisionValueFromRaw(xValue, elementScope, elementScope) : undefined,
+        y: yValue ? getPrecisionValueFromRaw(yValue, elementScope, elementScope) : undefined,
+        isVisible: e.isVisible(),
+        opacity: e.opacity(),
+        width: widthValue ? getPrecisionValueFromRaw(widthValue, elementScope, elementScope) : undefined,
+        height: heightValue ? getPrecisionValueFromRaw(heightValue, elementScope, elementScope) : undefined,
+        angle: (v > 2 ? e.angle() : e.angleV2()) || undefined,
+        isDeleted: e.isDeleted(),
+        frameId: e.frameId(),
+        link: e.link() || undefined,
+        locked: e.locked(),
+        groupIds: groupIds,
+        scope: elementScope,
+        label: e.label() || undefined,
+        boundElements: boundElements,
+        stroke: strokes,
+        background: backgrounds,
+        blending: e.blending(),
+        roundness: roundnessValue ? getPrecisionValueFromRaw(roundnessValue, elementScope, elementScope) : undefined,
+        subset: e.subset(),
+        zIndex: e.zIndex(),
+        description: e.description() || undefined,
+        noPlot: e.noPlot() || undefined,
+    };
+    switch (elType) {
+        case "text":
+            const fontSizeValue = v > 2 ? e.textFontSize() : e.textFontSizeV2() || undefined;
+            return Object.assign(Object.assign({}, baseElement), { type: elType, fontSize: fontSizeValue ? getPrecisionValueFromRaw(fontSizeValue, elementScope, elementScope) : undefined, fontFamily: Number(e.textFontFamily()), text: e.textText(), textAlign: e.textTextAlign(), verticalAlign: e.textVerticalAlign(), containerId: e.textContainerId(), originalText: e.textText(), lineHeight: v > 2 ? e.textLineHeight() : e.textLineHeightV2() || undefined, autoResize: e.textAutoResize() });
+        case "arrow":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, points,
+                lines,
+                pathOverrides, lastCommittedPoint: e.linearElementLastCommittedPoint() ? parsePoint(e.linearElementLastCommittedPoint(), elementScope) : null, startBinding: parsePointBinding(e.linearElementStartBinding(), elementScope), endBinding: parsePointBinding(e.linearElementEndBinding(), elementScope), elbowed: e.arrowElbowed() });
+        case "line":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, points: points, lines,
+                pathOverrides, lastCommittedPoint: e.linearElementLastCommittedPoint() ? parsePoint(e.linearElementLastCommittedPoint(), elementScope) : null, startBinding: parsePointBinding(e.linearElementStartBinding(), elementScope), endBinding: parsePointBinding(e.linearElementEndBinding(), elementScope) });
+        case "freedraw":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, size: e.freeDrawSize() ? getPrecisionValueFromRaw(e.freeDrawSize(), elementScope, elementScope) : undefined, points: points, pressures: pressures, simulatePressure: e.freeDrawSimulatePressure(), lastCommittedPoint: e.linearElementLastCommittedPoint() ? parsePoint(e.linearElementLastCommittedPoint(), elementScope) : null, thinning: ((_a = e.freeDrawThinning()) !== null && _a !== void 0 ? _a : undefined), smoothing: ((_b = e.freeDrawSmoothing()) !== null && _b !== void 0 ? _b : undefined), streamline: ((_c = e.freeDrawStreamline()) !== null && _c !== void 0 ? _c : undefined), easing: e.freeDrawEasing() ? FREEDRAW_EASINGS[e.freeDrawEasing()] : undefined, start: e.freeDrawStartCap() !== null || e.freeDrawStartTaper() !== null || e.freeDrawStartEasing() !== null ? {
+                    cap: (_d = e.freeDrawStartCap()) !== null && _d !== void 0 ? _d : false,
+                    taper: ((_e = e.freeDrawStartTaper()) !== null && _e !== void 0 ? _e : 0),
+                    easing: e.freeDrawStartEasing() ? FREEDRAW_EASINGS[e.freeDrawStartEasing()] : undefined,
+                } : null, end: e.freeDrawEndCap() !== null || e.freeDrawEndTaper() !== null || e.freeDrawEndEasing() !== null ? {
+                    cap: (_f = e.freeDrawEndCap()) !== null && _f !== void 0 ? _f : false,
+                    taper: ((_g = e.freeDrawEndTaper()) !== null && _g !== void 0 ? _g : 0),
+                    easing: e.freeDrawEndEasing() ? FREEDRAW_EASINGS[e.freeDrawEndEasing()] : undefined,
+                } : null, svgPath: (_h = e.freeDrawSvgPath()) !== null && _h !== void 0 ? _h : undefined });
+        case "image":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, fileId: e.fileId(), status: e.imageStatus(), scale: (() => { const s = e.imageScale(); return s ? [s.x(), s.y()] : undefined; })(), crop: parseImageCrop(e.imageCrop()) });
+        case "frame":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, isCollapsed: e.stackLikeIsCollapsed(), clip: e.stackLikeClip() || undefined, labelingColor: e.stackLikeLabelingColor() || undefined, strokeOverride: e.stackLikeStrokeOverride() ? parseElementBinStroke(e.stackLikeStrokeOverride(), elementScope) : null, backgroundOverride: e.stackLikeBackgroundOverride() ? parseElementBinBackground(e.stackLikeBackgroundOverride()) : null });
+        case "selection":
+            return Object.assign(Object.assign({}, baseElement), { type: elType });
+        case "rectangle":
+            return Object.assign(Object.assign({}, baseElement), { type: elType });
+        case "polygon":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, sides: e.polygonSides() });
+        case "ellipse":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, ratio: (_j = e.ellipseRatio()) !== null && _j !== void 0 ? _j : undefined, startAngle: (_k = e.ellipseStartAngle()) !== null && _k !== void 0 ? _k : undefined, endAngle: (_l = e.ellipseEndAngle()) !== null && _l !== void 0 ? _l : undefined, showAuxCrosshair: (_m = e.ellipseShowAuxCrosshair()) !== null && _m !== void 0 ? _m : undefined });
+        case "table":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, columnOrder: Array.from({ length: e.tableColumnOrderLength() }, (_, j) => e.tableColumnOrder(j) || ''), rowOrder: Array.from({ length: e.tableRowOrderLength() }, (_, j) => e.tableRowOrder(j) || ''), columns: parseDucTableColumns(e.tableColumnsLength(), e.tableColumns.bind(e), elementScope), rows: parseDucTableRows(e.tableRowsLength(), e.tableRows.bind(e), elementScope), cells: parseDucTableCells(e.tableCellsLength(), e.tableCells.bind(e), elementScope), style: e.tableStyle() ? parseDucTableStyleProps(e.tableStyle().defaultProps(), elementScope) : undefined });
+        case "doc":
+            return Object.assign(Object.assign({}, baseElement), { type: elType, content: e.docContent() || "" });
+        case "blockinstance":
+            const blockElementOverrides = {};
+            for (let j = 0; j < e.blockInstanceElementOverridesLength(); j++) {
+                const override = e.blockInstanceElementOverrides(j);
+                if (override && override.elementId() && override.overrides()) {
+                    blockElementOverrides[override.elementId()] = override.overrides();
+                }
+            }
+            return Object.assign(Object.assign({}, baseElement), { type: elType, blockId: e.blockInstanceBlockId() || '', blockElementOverrides: Object.keys(blockElementOverrides).length > 0 ? blockElementOverrides : undefined });
+        default:
+            return null;
+    }
+};
+export const parseElementContentBase = (content, defaults) => {
+    var _a, _b;
+    if (!content)
+        return defaults;
+    return {
+        preference: content.preference(),
+        src: (_a = content.src()) !== null && _a !== void 0 ? _a : defaults.src,
+        visible: content.visible(),
+        opacity: content.opacity(),
+        tiling: parseTiling((_b = content.tiling()) !== null && _b !== void 0 ? _b : null)
+    };
+};
+const parseTiling = (tiling) => {
+    var _a, _b, _c;
+    if (!tiling)
+        return undefined;
+    const sizeInPercent = tiling.sizeInPercent();
+    const angle = tiling.angle();
+    // Ensure both sizeInPercent and angle are defined
+    if (sizeInPercent === undefined || angle === undefined) {
+        return undefined;
+    }
+    return {
+        sizeInPercent: sizeInPercent,
+        angle: angle,
+        spacing: (_a = tiling.spacing()) !== null && _a !== void 0 ? _a : undefined,
+        offsetX: (_b = tiling.offsetX()) !== null && _b !== void 0 ? _b : undefined,
+        offsetY: (_c = tiling.offsetY()) !== null && _c !== void 0 ? _c : undefined,
+    };
+};
+const parseStrokeLines = (strokeSides) => {
+    if (!strokeSides)
+        return undefined;
+    return {
+        preference: strokeSides.preference(),
+        values: strokeSides.valuesLength() > 0
+            ? Array.from({ length: strokeSides.valuesLength() }, (_, i) => strokeSides.values(i)).filter((item) => item !== null)
+            : undefined
+    };
+};
+export const parseElementBinStroke = (stroke, elementScope) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+    if (!stroke) {
+        return Object.assign(Object.assign({}, DEFAULT_ELEMENT_PROPS.stroke), { width: getPrecisionValueFromRaw(DEFAULT_ELEMENT_PROPS.stroke.width.value, elementScope, elementScope) });
+    }
+    const widthValue = (_b = (_a = stroke.width) === null || _a === void 0 ? void 0 : _a.call(stroke)) !== null && _b !== void 0 ? _b : DEFAULT_ELEMENT_PROPS.stroke.width.value;
+    return {
+        content: parseElementContentBase((_c = stroke.content()) !== null && _c !== void 0 ? _c : null, DEFAULT_ELEMENT_PROPS.stroke.content),
+        width: getPrecisionValueFromRaw(widthValue, elementScope, elementScope),
+        style: {
+            preference: (_f = (_e = (_d = stroke.style()) === null || _d === void 0 ? void 0 : _d.preference) === null || _e === void 0 ? void 0 : _e.call(_d)) !== null && _f !== void 0 ? _f : DEFAULT_ELEMENT_PROPS.stroke.style.preference,
+            cap: (_j = (_h = (_g = stroke.style()) === null || _g === void 0 ? void 0 : _g.cap) === null || _h === void 0 ? void 0 : _h.call(_g)) !== null && _j !== void 0 ? _j : undefined,
+            join: (_m = (_l = (_k = stroke.style()) === null || _k === void 0 ? void 0 : _k.join) === null || _l === void 0 ? void 0 : _l.call(_k)) !== null && _m !== void 0 ? _m : undefined,
+            dash: Array.from({ length: ((_o = stroke.style()) === null || _o === void 0 ? void 0 : _o.dashLength()) || 0 }, (_, i) => { var _a; return (_a = stroke.style()) === null || _a === void 0 ? void 0 : _a.dash(i); }),
+            dashCap: (_r = (_q = (_p = stroke.style()) === null || _p === void 0 ? void 0 : _p.dashCap) === null || _q === void 0 ? void 0 : _q.call(_p)) !== null && _r !== void 0 ? _r : undefined,
+            miterLimit: (_u = (_t = (_s = stroke.style()) === null || _s === void 0 ? void 0 : _s.miterLimit) === null || _t === void 0 ? void 0 : _t.call(_s)) !== null && _u !== void 0 ? _u : undefined,
+        },
+        placement: (_w = (_v = stroke.placement) === null || _v === void 0 ? void 0 : _v.call(stroke)) !== null && _w !== void 0 ? _w : DEFAULT_ELEMENT_PROPS.stroke.placement,
+        strokeSides: parseStrokeLines((_x = stroke.strokeSides()) !== null && _x !== void 0 ? _x : null)
+    };
+};
+export const parseElementBinBackground = (background) => {
+    var _a;
+    if (!background) {
+        return DEFAULT_ELEMENT_PROPS.background;
+    }
+    return {
+        content: parseElementContentBase((_a = background.content()) !== null && _a !== void 0 ? _a : null, DEFAULT_ELEMENT_PROPS.background.content),
+    };
+};
+const parseImageCrop = (crop) => {
+    if (!crop)
+        return null;
+    return {
+        x: crop.x(),
+        y: crop.y(),
+        width: crop.width(),
+        height: crop.height(),
+        naturalWidth: crop.naturalWidth(),
+        naturalHeight: crop.naturalHeight()
+    };
+};
+const parseDucTableStyleProps = (styleProps, elementScope) => {
+    if (!styleProps)
+        return undefined;
+    const rawDashes = Array.from({ length: styleProps.borderDashesLength() }, (_, j) => styleProps.borderDashes(j));
+    const dashes = rawDashes.filter((d) => d !== null && d !== undefined);
+    const border = {
+        width: styleProps.borderWidth() ? getPrecisionValueFromRaw(styleProps.borderWidth(), elementScope, elementScope) : undefined,
+        dashes: dashes.length > 0 ? dashes : undefined,
+        color: styleProps.borderColor() || undefined,
+    };
+    const text = {
+        color: styleProps.textColor() || undefined,
+        size: styleProps.textSize() ? getPrecisionValueFromRaw(styleProps.textSize(), elementScope, elementScope) : undefined,
+        font: styleProps.textFont() || undefined,
+        align: styleProps.textAlign() || undefined,
+    };
+    return {
+        background: styleProps.backgroundColor() || undefined,
+        border: Object.values(border).some(val => val !== undefined) ? border : undefined,
+        text: Object.values(text).some(val => val !== undefined) ? text : undefined,
+    };
+};
+const parseDucTableColumns = (length, getter, elementScope) => {
+    const columns = {};
+    for (let j = 0; j < length; j++) {
+        const col = getter(j);
+        if (col && col.id()) {
+            columns[col.id()] = {
+                id: col.id(),
+                width: col.width() ? getPrecisionValueFromRaw(col.width(), elementScope, elementScope) : undefined,
+                style: parseDucTableStyleProps(col.style(), elementScope),
+            };
+        }
+    }
+    return columns;
+};
+const parseDucTableRows = (length, getter, elementScope) => {
+    const rows = {};
+    for (let j = 0; j < length; j++) {
+        const row = getter(j);
+        if (row && row.id()) {
+            rows[row.id()] = {
+                id: row.id(),
+                height: row.height() ? getPrecisionValueFromRaw(row.height(), elementScope, elementScope) : undefined,
+                style: parseDucTableStyleProps(row.style(), elementScope),
+            };
+        }
+    }
+    return rows;
+};
+const parseDucTableCells = (length, getter, elementScope) => {
+    const cells = {};
+    for (let j = 0; j < length; j++) {
+        const cell = getter(j);
+        if (cell && cell.rowId() && cell.columnId()) {
+            const key = `${cell.rowId()}:${cell.columnId()}`;
+            cells[key] = {
+                rowId: cell.rowId(),
+                columnId: cell.columnId(),
+                data: cell.data() || "",
+                style: parseDucTableStyleProps(cell.style(), elementScope),
+            };
+        }
+    }
+    return cells;
+};

package/dist/legacy/v1/parse/parseGroupFromBinary.d.ts

@@ -0,0 +1,4 @@
+import { DucGroup as BinDucGroup } from 'ducjs/legacy/v1/duc';
+import { DucGroup } from 'ducjs/legacy/v1/types/elements';
+import { Scope } from 'ducjs/legacy/v1/types';
+export declare const parseGroupFromBinary: (group: BinDucGroup, currentScope: Scope) => Partial<DucGroup> | null;

package/dist/legacy/v1/parse/parseGroupFromBinary.js

@@ -0,0 +1,36 @@
+import { parseElementBinBackground, parseElementBinStroke } from './parseElementFromBinary';
+export const parseGroupFromBinary = (group, currentScope) => {
+    if (!group)
+        return null;
+    const id = group.id() || undefined;
+    const label = group.label() || undefined;
+    const description = group.description() || null;
+    const isCollapsed = group.isCollapsed();
+    const noPlot = group.noPlot() || undefined;
+    const locked = group.locked();
+    const isVisible = group.isVisible();
+    const opacity = group.opacity() || undefined;
+    const labelingColor = group.labelingColor() || undefined;
+    const clip = group.clip() || undefined;
+    // Parse stroke and background overrides
+    const strokeOverride = group.strokeOverride()
+        ? parseElementBinStroke(group.strokeOverride(), currentScope)
+        : null;
+    const backgroundOverride = group.backgroundOverride()
+        ? parseElementBinBackground(group.backgroundOverride())
+        : null;
+    return {
+        id,
+        label,
+        description,
+        isCollapsed,
+        noPlot,
+        locked,
+        isVisible,
+        opacity,
+        labelingColor,
+        strokeOverride,
+        backgroundOverride,
+        clip,
+    };
+};

package/dist/legacy/v1/parse/parseRendererStateFromBinary.d.ts

@@ -0,0 +1,4 @@
+import { RendererState } from 'ducjs/legacy/v1/duc';
+export declare const parseRendererStateFromBinary: (rendererState: RendererState | null) => {
+    deletedElementIds: string[];
+};

package/dist/legacy/v1/parse/parseRendererStateFromBinary.js

@@ -0,0 +1,15 @@
+export const parseRendererStateFromBinary = (rendererState) => {
+    if (!rendererState) {
+        return { deletedElementIds: [] };
+    }
+    const deletedElementIds = [];
+    for (let i = 0; i < rendererState.deletedElementIdsLength(); i++) {
+        const id = rendererState.deletedElementIds(i);
+        if (id) {
+            deletedElementIds.push(id);
+        }
+    }
+    return {
+        deletedElementIds,
+    };
+};

package/dist/legacy/v1/serialize/index.d.ts

@@ -0,0 +1,5 @@
+import { DucBlock, DucElement, DucGroup } from 'ducjs/legacy/v1/types/elements';
+import { BinaryFiles, RendererState, DucState } from 'ducjs/legacy/v1/types';
+import { ExtendedAppStateRestorer } from 'ducjs/legacy/v1/utils/restore';
+export declare const DUC_SCHEMA_VERSION: string;
+export declare const serializeAsFlatBuffers: (elements: readonly DucElement[], ducState: Partial<DucState>, files: BinaryFiles, blocks: readonly DucBlock[], groups: readonly DucGroup[], rendererState?: RendererState, extendedAppStateRestorer?: ExtendedAppStateRestorer<DucState>) => Promise<Uint8Array>;

package/dist/legacy/v1/serialize/index.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as flatbuffers from 'flatbuffers';
+import { ExportedDataState, } from 'ducjs/legacy/v1/duc';
+import { EXPORT_DATA_TYPES } from 'ducjs/legacy/v1/utils/constants';
+import { serializeDucElement } from 'ducjs/legacy/v1/serialize/serializeElementFromDuc';
+import { serializeAppState } from 'ducjs/legacy/v1/serialize/serializeAppStateFromDuc';
+import { serializeBinaryFiles } from 'ducjs/legacy/v1/serialize/serializeBinaryFilesFromDuc';
+import { restore, noopExtendedAppStateRestorer } from 'ducjs/legacy/v1/utils/restore';
+import { serializeRendererState } from 'ducjs/legacy/v1/serialize/serializeRendererStateFromDuc';
+import { serializeDucBlock } from 'ducjs/legacy/v1/serialize/serializeBlockFromDuc';
+import { serializeDucGroup } from 'ducjs/legacy/v1/serialize/serializeGroupFromDuc';
+export const DUC_SCHEMA_VERSION = process.env.DUC_SCHEMA_VERSION || "0.0.0";
+export const serializeAsFlatBuffers = (elements_1, ducState_1, files_1, blocks_1, groups_1, rendererState_1, ...args_1) => __awaiter(void 0, [elements_1, ducState_1, files_1, blocks_1, groups_1, rendererState_1, ...args_1], void 0, function* (elements, ducState, files, blocks, groups, rendererState, extendedAppStateRestorer = noopExtendedAppStateRestorer) {
+    var _a;
+    const builder = new flatbuffers.Builder(1024);
+    const sanitized = restore({
+        elements,
+        appState: ducState,
+        files,
+        blocks,
+        groups,
+        rendererState,
+    }, null, // localExtendedAppState
+    null, // localElements
+    extendedAppStateRestorer, {
+        refreshDimensions: false,
+        syncInvalidIndices: (elements) => elements,
+    });
+    const typeOffset = builder.createString(EXPORT_DATA_TYPES.duc);
+    const sourceOffset = builder.createString((_a = window.location.origin) !== null && _a !== void 0 ? _a : "Unknown");
+    // Serialize elements
+    const elementOffsets = sanitized.elements.map((element) => {
+        return serializeDucElement(builder, element, Boolean(rendererState));
+    });
+    const elementsOffset = ExportedDataState.createElementsVector(builder, elementOffsets);
+    // Serialize appState
+    const appStateOffset = serializeAppState(builder, sanitized.appState, Boolean(rendererState));
+    // Serialize files
+    const binaryFilesOffset = serializeBinaryFiles(builder, sanitized.files);
+    // Serialize rendererState
+    const rendererStateOffset = rendererState
+        ? serializeRendererState(builder, rendererState)
+        : null;
+    // Serialize blocks
+    const blocksOffset = sanitized.blocks.length > 0
+        ? ExportedDataState.createBlocksVector(builder, sanitized.blocks.map(block => serializeDucBlock(builder, block, Boolean(rendererState))))
+        : null;
+    // Serialize groups
+    const groupsOffset = sanitized.groups.length > 0
+        ? ExportedDataState.createGroupsVector(builder, sanitized.groups.map(group => serializeDucGroup(builder, group, Boolean(rendererState))))
+        : null;
+    ExportedDataState.startExportedDataState(builder);
+    ExportedDataState.addType(builder, typeOffset);
+    // For legacy compatibility, extract major version number from semantic version
+    const majorVersion = parseInt(DUC_SCHEMA_VERSION.split('.')[0]) || 0;
+    ExportedDataState.addVersionLegacy(builder, majorVersion);
+    ExportedDataState.addSource(builder, sourceOffset);
+    ExportedDataState.addElements(builder, elementsOffset);
+    ExportedDataState.addAppState(builder, appStateOffset);
+    ExportedDataState.addFiles(builder, binaryFilesOffset);
+    if (rendererStateOffset) {
+        ExportedDataState.addRendererState(builder, rendererStateOffset);
+    }
+    if (blocksOffset) {
+        ExportedDataState.addBlocks(builder, blocksOffset);
+    }
+    if (groupsOffset) {
+        ExportedDataState.addGroups(builder, groupsOffset);
+    }
+    const exportedDataStateOffset = ExportedDataState.endExportedDataState(builder);
+    builder.finish(exportedDataStateOffset, "DUC_");
+    return builder.asUint8Array();
+});

package/dist/legacy/v1/serialize/serializationUtils.d.ts

@@ -0,0 +1,17 @@
+import { PrecisionValue } from 'ducjs/legacy/v1/types';
+/**
+ * Ensures that a given number is finite. If not, returns a default value.
+ * This is primarily for internal use within serialization helpers like getPrecisionValueField,
+ * or for values that are not expected to be pre-sanitized by the restore phase.
+ */
+declare const ensureFiniteNumber: (num: number | undefined, defaultValue?: number) => number;
+/**
+ * Safely extracts the .value or .scoped field from a PrecisionValue object,
+ * ensuring the result is a finite number.
+ * @param pv The PrecisionValue object.
+ * @param scoped If true, uses pv.scoped; otherwise, uses pv.value.
+ * @param defaultValue The default value to return if pv is undefined or the extracted value is not finite.
+ * @returns A finite number.
+ */
+export declare const getPrecisionValueField: (pv: PrecisionValue | undefined, scoped: boolean, defaultValue?: number) => number;
+export { ensureFiniteNumber };

package/dist/legacy/v1/serialize/serializationUtils.js

@@ -0,0 +1,27 @@
+/**
+ * Ensures that a given number is finite. If not, returns a default value.
+ * This is primarily for internal use within serialization helpers like getPrecisionValueField,
+ * or for values that are not expected to be pre-sanitized by the restore phase.
+ */
+const ensureFiniteNumber = (num, defaultValue = 0) => {
+    if (typeof num === 'number' && Number.isFinite(num)) {
+        return num;
+    }
+    return defaultValue;
+};
+/**
+ * Safely extracts the .value or .scoped field from a PrecisionValue object,
+ * ensuring the result is a finite number.
+ * @param pv The PrecisionValue object.
+ * @param scoped If true, uses pv.scoped; otherwise, uses pv.value.
+ * @param defaultValue The default value to return if pv is undefined or the extracted value is not finite.
+ * @returns A finite number.
+ */
+export const getPrecisionValueField = (pv, scoped, defaultValue = 0) => {
+    if (!pv) {
+        return defaultValue;
+    }
+    const val = scoped ? pv.scoped : pv.value;
+    return ensureFiniteNumber(val, defaultValue);
+};
+export { ensureFiniteNumber };

package/dist/legacy/v1/serialize/serializeAppStateFromDuc.d.ts

@@ -0,0 +1,4 @@
+import * as flatbuffers from 'flatbuffers';
+import { DucState } from 'ducjs/legacy/v1/types';
+declare const serializeAppState: (builder: flatbuffers.Builder, appState: Partial<DucState>, forRenderer: boolean) => flatbuffers.Offset;
+export { serializeAppState };