ducjs 2.0.0 → 2.1.0

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

@@ -1,387 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

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

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

@@ -1,15 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,4 +0,0 @@
-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 };