ducjs 1.0.0

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

@@ -0,0 +1,435 @@
+import { BindingPoint as BinBindingPoint, BoundElement as BinBoundElement, DucBlockInstanceElementOverride as BinDucBlockInstanceElementOverride, DucElement as BinDucElement, DucLine as BinDucLine, DucLineReference as BinDucLineReference, DucPath as BinDucPath, DucTableCell as BinDucTableCell, DucTableColumn as BinDucTableColumn, DucTableRow as BinDucTableRow, DucTableStyle as BinDucTableStyle, DucTableStyleProps as BinDucTableStyleProps, ElementBackground as BinElementBackground, ElementContentBase as BinElementContentBase, ElementStroke as BinElementStroke, ImageCrop as BinImageCrop, Point as BinPoint, PointBinding as BinPointBinding, SimplePoint as BinSimplePoint, StrokeSides as BinStrokeSides, StrokeStyle as BinStrokeStyle, TilingProperties as BinTilingProperties } from 'ducjs/legacy/v1/duc';
+import { isLinearElement } from 'ducjs/legacy/v1/types/elements/typeChecks';
+import { ensureFiniteNumber, getPrecisionValueField } from 'ducjs/legacy/v1/serialize/serializationUtils';
+export const serializeDucElement = (builder, element, forRenderer = false) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    const idOffset = builder.createString(element.id);
+    const labelOffset = builder.createString(element.label);
+    const scopeOffset = builder.createString(element.scope);
+    const frameIdOffset = element.frameId ? builder.createString(element.frameId) : undefined;
+    const linkOffset = element.link ? builder.createString(element.link) : undefined;
+    const typeOffset = builder.createString(element.type);
+    const descriptionOffset = element.description ? builder.createString(element.description) : undefined;
+    let fontFamilyOffset;
+    let textOffset;
+    let containerIdOffset;
+    if (element.type === 'text') {
+        fontFamilyOffset = element.fontFamily ? builder.createString(String(element.fontFamily)) : undefined;
+        textOffset = builder.createString(element.text);
+        containerIdOffset = element.containerId ? builder.createString(element.containerId) : undefined;
+    }
+    let fileIdOffset;
+    let statusOffset;
+    if (element.type === 'image') {
+        fileIdOffset = element.fileId ? builder.createString(element.fileId) : undefined;
+        statusOffset = element.status ? builder.createString(element.status) : undefined;
+    }
+    let docContentOffset;
+    if (element.type === 'doc') {
+        docContentOffset = builder.createString(element.content);
+    }
+    let freedrawEasingOffset;
+    let freedrawStartEasingOffset;
+    let freedrawEndEasingOffset;
+    let freedrawSvgPathOffset;
+    if (element.type === 'freedraw') {
+        freedrawEasingOffset = element.easing ? builder.createString(element.easing.name) : undefined;
+        freedrawStartEasingOffset = ((_a = element.start) === null || _a === void 0 ? void 0 : _a.easing) ? builder.createString(element.start.easing.name) : undefined;
+        freedrawEndEasingOffset = ((_b = element.end) === null || _b === void 0 ? void 0 : _b.easing) ? builder.createString(element.end.easing.name) : undefined;
+        freedrawSvgPathOffset = element.svgPath && forRenderer ? builder.createString(element.svgPath) : undefined;
+    }
+    // Pre-create frame/magicframe strings
+    let labelingColorOffset;
+    if (element.type === 'frame') {
+        const frameLikeElement = element;
+        if (frameLikeElement.labelingColor) {
+            labelingColorOffset = builder.createString(frameLikeElement.labelingColor);
+        }
+    }
+    // Pre-create blockinstance strings
+    let blockIdOffset;
+    let overrideOffsets = [];
+    let overridesVector;
+    if (element.type === 'blockinstance') {
+        const blockInstanceElement = element;
+        if (blockInstanceElement.blockId) {
+            blockIdOffset = builder.createString(blockInstanceElement.blockId);
+        }
+        if (blockInstanceElement.blockElementOverrides) {
+            // Create all override objects first
+            overrideOffsets = Object.entries(blockInstanceElement.blockElementOverrides).map(([elementId, overrides]) => {
+                const elementIdOffset = builder.createString(elementId);
+                const overridesOffset = builder.createString(overrides);
+                // Create DucBlockInstanceElementOverride
+                BinDucBlockInstanceElementOverride.startDucBlockInstanceElementOverride(builder);
+                BinDucBlockInstanceElementOverride.addElementId(builder, elementIdOffset);
+                BinDucBlockInstanceElementOverride.addOverrides(builder, overridesOffset);
+                return BinDucBlockInstanceElementOverride.endDucBlockInstanceElementOverride(builder);
+            });
+            if (overrideOffsets.length > 0) {
+                overridesVector = BinDucElement.createBlockInstanceElementOverridesVector(builder, overrideOffsets);
+            }
+        }
+    }
+    // Pre-create all table-related strings and objects
+    let columnOrderVector;
+    let rowOrderVector;
+    let columnsVector;
+    let rowsVector;
+    let cellsVector;
+    let tableStyleOffset;
+    if (element.type === 'table') {
+        const tableElement = element;
+        columnOrderVector = BinDucElement.createTableColumnOrderVector(builder, tableElement.columnOrder.map(id => builder.createString(id)));
+        rowOrderVector = BinDucElement.createTableRowOrderVector(builder, tableElement.rowOrder.map(id => builder.createString(id)));
+        columnsVector = BinDucElement.createTableColumnsVector(builder, Object.values(tableElement.columns).map(col => serializeDucTableColumn(builder, col, forRenderer)));
+        rowsVector = BinDucElement.createTableRowsVector(builder, Object.values(tableElement.rows).map(row => serializeDucTableRow(builder, row, forRenderer)));
+        cellsVector = BinDucElement.createTableCellsVector(builder, Object.values(tableElement.cells).map(cell => serializeDucTableCell(builder, cell, forRenderer)));
+        if (tableElement.style) {
+            const stylePropsOffset = serializeDucTableStyleProps(builder, tableElement.style, forRenderer);
+            BinDucTableStyle.startDucTableStyle(builder);
+            BinDucTableStyle.addDefaultProps(builder, stylePropsOffset);
+            tableStyleOffset = BinDucTableStyle.endDucTableStyle(builder);
+        }
+    }
+    // Pre-create all vector offsets and child objects
+    const groupIdOffsets = element.groupIds.map(groupId => builder.createString(groupId));
+    const groupIdsVector = element.groupIds.length > 0
+        ? BinDucElement.createGroupIdsVector(builder, groupIdOffsets)
+        : undefined;
+    const boundElementOffsets = (_d = (_c = element.boundElements) === null || _c === void 0 ? void 0 : _c.map(boundElement => {
+        const boundIdOffset = builder.createString(boundElement.id);
+        const boundTypeOffset = builder.createString(boundElement.type);
+        return BinBoundElement.createBoundElement(builder, boundIdOffset, boundTypeOffset);
+    })) !== null && _d !== void 0 ? _d : [];
+    const boundElementsVector = boundElementOffsets.length > 0
+        ? BinDucElement.createBoundElementsVector(builder, boundElementOffsets)
+        : undefined;
+    const strokeOffsets = (_f = (_e = element.stroke) === null || _e === void 0 ? void 0 : _e.map(stroke => serializeElementStroke(builder, stroke, forRenderer))) !== null && _f !== void 0 ? _f : [];
+    const strokeVector = strokeOffsets.length > 0
+        ? BinDucElement.createStrokeVector(builder, strokeOffsets)
+        : undefined;
+    const backgroundOffsets = (_h = (_g = element.background) === null || _g === void 0 ? void 0 : _g.map(bg => serializeElementBackground(builder, bg))) !== null && _h !== void 0 ? _h : [];
+    const backgroundVector = backgroundOffsets.length > 0
+        ? BinDucElement.createBackgroundVector(builder, backgroundOffsets)
+        : undefined;
+    let pointsVector;
+    let lastCommittedPointOffset;
+    let pressuresVector;
+    if ((element.type === 'freedraw' || element.type === 'arrow' || element.type === 'line') && element.points) {
+        const points = element.points.map(p => serializeDucPoint(builder, p, forRenderer));
+        pointsVector = BinDucElement.createLinearElementPointsVector(builder, points);
+        lastCommittedPointOffset = element.lastCommittedPoint ? serializeDucPoint(builder, element.lastCommittedPoint, forRenderer) : undefined;
+    }
+    if (element.type === 'freedraw' && element.pressures) {
+        pressuresVector = BinDucElement.createFreeDrawPressuresVector(builder, Array.from(element.pressures).map(p => ensureFiniteNumber(p)));
+    }
+    let linesVector;
+    let pathOverridesVector;
+    if (isLinearElement(element)) {
+        const lines = element.lines.map(line => serializeDucLine(builder, line, forRenderer));
+        linesVector = BinDucElement.createLinearElementLinesVector(builder, lines);
+        if (element.pathOverrides && element.pathOverrides.length > 0) {
+            const pathOverrides = element.pathOverrides.map(path => serializeDucPath(builder, path, forRenderer));
+            pathOverridesVector = BinDucElement.createLinearElementPathOverridesVector(builder, pathOverrides);
+        }
+    }
+    let startBindingOffset;
+    let endBindingOffset;
+    if (element.type === 'line' || element.type === 'arrow') {
+        startBindingOffset = element.startBinding ? serializeDucPointBinding(builder, element.startBinding, forRenderer) : undefined;
+        endBindingOffset = element.endBinding ? serializeDucPointBinding(builder, element.endBinding, forRenderer) : undefined;
+    }
+    let imageScaleOffset;
+    let imageCropOffset;
+    if (element.type === 'image') {
+        imageScaleOffset = BinSimplePoint.createSimplePoint(builder, ensureFiniteNumber((_j = element.scale) === null || _j === void 0 ? void 0 : _j[0], 1), ensureFiniteNumber((_k = element.scale) === null || _k === void 0 ? void 0 : _k[1], 1));
+        imageCropOffset = element.crop ? serializeImageCrop(builder, element.crop) : undefined;
+    }
+    // Pre-create frame/magicframe override objects
+    let strokeOverrideOffset;
+    let backgroundOverrideOffset;
+    if (element.type === 'frame') {
+        const frameLikeElement = element;
+        if (frameLikeElement.strokeOverride) {
+            strokeOverrideOffset = serializeElementStroke(builder, frameLikeElement.strokeOverride, forRenderer);
+        }
+        if (frameLikeElement.backgroundOverride) {
+            backgroundOverrideOffset = serializeElementBackground(builder, frameLikeElement.backgroundOverride);
+        }
+    }
+    BinDucElement.startDucElement(builder);
+    BinDucElement.addId(builder, idOffset);
+    BinDucElement.addType(builder, typeOffset);
+    element.x && BinDucElement.addX(builder, getPrecisionValueField(element.x, forRenderer));
+    element.y && BinDucElement.addY(builder, getPrecisionValueField(element.y, forRenderer));
+    BinDucElement.addScope(builder, scopeOffset);
+    labelOffset && BinDucElement.addLabel(builder, labelOffset);
+    BinDucElement.addIsVisible(builder, element.isVisible !== undefined ? element.isVisible : true);
+    BinDucElement.addOpacity(builder, element.opacity);
+    element.width && BinDucElement.addWidth(builder, getPrecisionValueField(element.width, forRenderer));
+    element.height && BinDucElement.addHeight(builder, getPrecisionValueField(element.height, forRenderer));
+    BinDucElement.addAngle(builder, element.angle);
+    BinDucElement.addIsDeleted(builder, element.isDeleted || false);
+    frameIdOffset && BinDucElement.addFrameId(builder, frameIdOffset);
+    linkOffset && BinDucElement.addLink(builder, linkOffset);
+    BinDucElement.addLocked(builder, element.locked || false);
+    groupIdsVector && BinDucElement.addGroupIds(builder, groupIdsVector);
+    boundElementsVector && BinDucElement.addBoundElements(builder, boundElementsVector);
+    strokeVector && BinDucElement.addStroke(builder, strokeVector);
+    backgroundVector && BinDucElement.addBackground(builder, backgroundVector);
+    element.blending !== undefined && BinDucElement.addBlending(builder, element.blending);
+    element.zIndex !== undefined && BinDucElement.addZIndex(builder, element.zIndex);
+    element.roundness && BinDucElement.addRoundness(builder, getPrecisionValueField(element.roundness, forRenderer));
+    element.subset !== undefined && element.subset !== null && BinDucElement.addSubset(builder, element.subset);
+    descriptionOffset && BinDucElement.addDescription(builder, descriptionOffset);
+    element.noPlot !== undefined && BinDucElement.addNoPlot(builder, element.noPlot);
+    if (element.type === 'polygon') {
+        element.sides && BinDucElement.addPolygonSides(builder, element.sides);
+    }
+    if (element.type === 'text') {
+        element.fontSize && BinDucElement.addTextFontSize(builder, getPrecisionValueField(element.fontSize, forRenderer));
+        fontFamilyOffset && BinDucElement.addTextFontFamily(builder, fontFamilyOffset);
+        textOffset && BinDucElement.addTextText(builder, textOffset);
+        element.textAlign && BinDucElement.addTextTextAlign(builder, element.textAlign);
+        element.verticalAlign && BinDucElement.addTextVerticalAlign(builder, element.verticalAlign);
+        containerIdOffset && BinDucElement.addTextContainerId(builder, containerIdOffset);
+        element.lineHeight !== undefined && BinDucElement.addTextLineHeight(builder, element.lineHeight);
+        element.autoResize !== undefined && BinDucElement.addTextAutoResize(builder, element.autoResize);
+    }
+    if (element.type === 'line' || element.type === 'arrow') {
+        pointsVector && BinDucElement.addLinearElementPoints(builder, pointsVector);
+        linesVector && BinDucElement.addLinearElementLines(builder, linesVector);
+        pathOverridesVector && BinDucElement.addLinearElementPathOverrides(builder, pathOverridesVector);
+        lastCommittedPointOffset && BinDucElement.addLinearElementLastCommittedPoint(builder, lastCommittedPointOffset);
+        startBindingOffset && BinDucElement.addLinearElementStartBinding(builder, startBindingOffset);
+        endBindingOffset && BinDucElement.addLinearElementEndBinding(builder, endBindingOffset);
+        if (element.type === 'arrow' && element.elbowed !== undefined) {
+            BinDucElement.addArrowElbowed(builder, element.elbowed);
+        }
+    }
+    if (element.type === 'freedraw') {
+        pressuresVector && BinDucElement.addFreeDrawPressures(builder, pressuresVector);
+        element.simulatePressure !== undefined && BinDucElement.addFreeDrawSimulatePressure(builder, element.simulatePressure);
+        lastCommittedPointOffset && BinDucElement.addLinearElementLastCommittedPoint(builder, lastCommittedPointOffset);
+        pointsVector && BinDucElement.addLinearElementPoints(builder, pointsVector);
+        element.size !== undefined && BinDucElement.addFreeDrawSize(builder, getPrecisionValueField(element.size, forRenderer));
+        element.thinning !== undefined && BinDucElement.addFreeDrawThinning(builder, element.thinning);
+        element.smoothing !== undefined && BinDucElement.addFreeDrawSmoothing(builder, element.smoothing);
+        element.streamline !== undefined && BinDucElement.addFreeDrawStreamline(builder, element.streamline);
+        freedrawEasingOffset && BinDucElement.addFreeDrawEasing(builder, freedrawEasingOffset);
+        ((_l = element.start) === null || _l === void 0 ? void 0 : _l.cap) !== undefined && BinDucElement.addFreeDrawStartCap(builder, element.start.cap);
+        ((_m = element.start) === null || _m === void 0 ? void 0 : _m.taper) !== undefined && BinDucElement.addFreeDrawStartTaper(builder, element.start.taper);
+        freedrawStartEasingOffset && BinDucElement.addFreeDrawStartEasing(builder, freedrawStartEasingOffset);
+        ((_o = element.end) === null || _o === void 0 ? void 0 : _o.cap) !== undefined && BinDucElement.addFreeDrawEndCap(builder, element.end.cap);
+        ((_p = element.end) === null || _p === void 0 ? void 0 : _p.taper) !== undefined && BinDucElement.addFreeDrawEndTaper(builder, element.end.taper);
+        freedrawEndEasingOffset && BinDucElement.addFreeDrawEndEasing(builder, freedrawEndEasingOffset);
+        freedrawSvgPathOffset && BinDucElement.addFreeDrawSvgPath(builder, freedrawSvgPathOffset);
+    }
+    if (element.type === 'image') {
+        fileIdOffset && BinDucElement.addFileId(builder, fileIdOffset);
+        statusOffset && BinDucElement.addImageStatus(builder, statusOffset);
+        imageScaleOffset && BinDucElement.addImageScale(builder, imageScaleOffset);
+        imageCropOffset && BinDucElement.addImageCrop(builder, imageCropOffset);
+    }
+    if (element.type === 'frame') {
+        const frameLikeElement = element;
+        frameLikeElement.isCollapsed !== undefined && BinDucElement.addStackLikeIsCollapsed(builder, frameLikeElement.isCollapsed);
+        frameLikeElement.clip !== undefined && BinDucElement.addStackLikeClip(builder, frameLikeElement.clip);
+        // Add pre-created stack-like fields
+        labelingColorOffset && BinDucElement.addStackLikeLabelingColor(builder, labelingColorOffset);
+        strokeOverrideOffset && BinDucElement.addStackLikeStrokeOverride(builder, strokeOverrideOffset);
+        backgroundOverrideOffset && BinDucElement.addStackLikeBackgroundOverride(builder, backgroundOverrideOffset);
+    }
+    if (element.type === 'table') {
+        columnOrderVector && BinDucElement.addTableColumnOrder(builder, columnOrderVector);
+        rowOrderVector && BinDucElement.addTableRowOrder(builder, rowOrderVector);
+        columnsVector && BinDucElement.addTableColumns(builder, columnsVector);
+        rowsVector && BinDucElement.addTableRows(builder, rowsVector);
+        cellsVector && BinDucElement.addTableCells(builder, cellsVector);
+        tableStyleOffset && BinDucElement.addTableStyle(builder, tableStyleOffset);
+    }
+    if (element.type === 'doc') {
+        docContentOffset && BinDucElement.addDocContent(builder, docContentOffset);
+    }
+    if (element.type === 'ellipse') {
+        element.ratio !== undefined && BinDucElement.addEllipseRatio(builder, element.ratio);
+        element.startAngle !== undefined && BinDucElement.addEllipseStartAngle(builder, element.startAngle);
+        element.endAngle !== undefined && BinDucElement.addEllipseEndAngle(builder, element.endAngle);
+        element.showAuxCrosshair !== undefined && BinDucElement.addEllipseShowAuxCrosshair(builder, element.showAuxCrosshair);
+    }
+    if (element.type === 'blockinstance') {
+        blockIdOffset && BinDucElement.addBlockInstanceBlockId(builder, blockIdOffset);
+        overridesVector && BinDucElement.addBlockInstanceElementOverrides(builder, overridesVector);
+    }
+    return BinDucElement.endDucElement(builder);
+};
+export const serializeDucPoint = (builder, point, forRenderer) => {
+    BinPoint.startPoint(builder);
+    point.x !== undefined && BinPoint.addXV3(builder, getPrecisionValueField(point.x, forRenderer));
+    point.y !== undefined && BinPoint.addYV3(builder, getPrecisionValueField(point.y, forRenderer));
+    point.mirroring !== undefined && BinPoint.addMirroring(builder, point.mirroring);
+    return BinPoint.endPoint(builder);
+};
+const serializeDucLineReference = (builder, lineRef, forRenderer) => {
+    const handleOffset = lineRef.handle ? BinSimplePoint.createSimplePoint(builder, getPrecisionValueField(lineRef.handle.x, forRenderer), getPrecisionValueField(lineRef.handle.y, forRenderer)) : undefined;
+    BinDucLineReference.startDucLineReference(builder);
+    BinDucLineReference.addIndex(builder, lineRef.index);
+    handleOffset && BinDucLineReference.addHandle(builder, handleOffset);
+    return BinDucLineReference.endDucLineReference(builder);
+};
+const serializeDucLine = (builder, line, forRenderer) => {
+    const startOffset = serializeDucLineReference(builder, line[0], forRenderer);
+    const endOffset = serializeDucLineReference(builder, line[1], forRenderer);
+    BinDucLine.startDucLine(builder);
+    BinDucLine.addStart(builder, startOffset);
+    BinDucLine.addEnd(builder, endOffset);
+    return BinDucLine.endDucLine(builder);
+};
+const serializeDucPath = (builder, path, forRenderer) => {
+    const lineIndicesVector = BinDucPath.createLineIndicesVector(builder, Array.from(path.lineIndices));
+    const backgroundOffset = path.background ? serializeElementBackground(builder, path.background) : undefined;
+    const strokeOffset = path.stroke ? serializeElementStroke(builder, path.stroke, forRenderer) : undefined;
+    BinDucPath.startDucPath(builder);
+    BinDucPath.addLineIndices(builder, lineIndicesVector);
+    backgroundOffset && BinDucPath.addBackground(builder, backgroundOffset);
+    strokeOffset && BinDucPath.addStroke(builder, strokeOffset);
+    return BinDucPath.endDucPath(builder);
+};
+export const serializeDucPointBinding = (builder, pointBinding, forRenderer) => {
+    const elementIdOffset = builder.createString(pointBinding.elementId || '');
+    const fixedPointOffset = pointBinding.fixedPoint ?
+        BinSimplePoint.createSimplePoint(builder, ensureFiniteNumber(pointBinding.fixedPoint.x, 0.5), ensureFiniteNumber(pointBinding.fixedPoint.y, 0.5)) : undefined;
+    let bindingPointOffset;
+    if (pointBinding.point) {
+        BinBindingPoint.startBindingPoint(builder);
+        BinBindingPoint.addIndex(builder, ensureFiniteNumber(pointBinding.point.index));
+        BinBindingPoint.addOffset(builder, ensureFiniteNumber(pointBinding.point.offset));
+        bindingPointOffset = BinBindingPoint.endBindingPoint(builder);
+    }
+    BinPointBinding.startPointBinding(builder);
+    BinPointBinding.addElementId(builder, elementIdOffset);
+    pointBinding.focus !== undefined && BinPointBinding.addFocus(builder, pointBinding.focus);
+    pointBinding.gap && BinPointBinding.addGap(builder, getPrecisionValueField(pointBinding.gap, forRenderer));
+    fixedPointOffset && BinPointBinding.addFixedPoint(builder, fixedPointOffset);
+    bindingPointOffset && BinPointBinding.addPoint(builder, bindingPointOffset);
+    pointBinding.head !== undefined && pointBinding.head !== null && BinPointBinding.addHead(builder, pointBinding.head);
+    return BinPointBinding.endPointBinding(builder);
+};
+const serializeTilingProperties = (builder, tiling) => {
+    BinTilingProperties.startTilingProperties(builder);
+    tiling.angle !== undefined && BinTilingProperties.addAngle(builder, tiling.angle);
+    tiling.offsetX !== undefined && BinTilingProperties.addOffsetX(builder, tiling.offsetX);
+    tiling.offsetY !== undefined && BinTilingProperties.addOffsetY(builder, tiling.offsetY);
+    return BinTilingProperties.endTilingProperties(builder);
+};
+const serializeElementContentBase = (builder, content) => {
+    const srcOffset = builder.createString(content.src || '');
+    const tilingOffset = content.tiling ? serializeTilingProperties(builder, content.tiling) : undefined;
+    BinElementContentBase.startElementContentBase(builder);
+    BinElementContentBase.addPreference(builder, content.preference);
+    BinElementContentBase.addSrc(builder, srcOffset);
+    BinElementContentBase.addVisible(builder, content.visible !== undefined ? content.visible : true);
+    content.opacity !== undefined && BinElementContentBase.addOpacity(builder, content.opacity);
+    tilingOffset && BinElementContentBase.addTiling(builder, tilingOffset);
+    return BinElementContentBase.endElementContentBase(builder);
+};
+const serializeStrokeStyle = (builder, style) => {
+    const dashVector = style.dash && style.dash.length > 0
+        ? BinStrokeStyle.createDashVector(builder, style.dash.map(d => ensureFiniteNumber(d)))
+        : undefined;
+    BinStrokeStyle.startStrokeStyle(builder);
+    style.preference !== undefined && BinStrokeStyle.addPreference(builder, style.preference);
+    style.cap !== undefined && BinStrokeStyle.addCap(builder, style.cap);
+    style.join !== undefined && BinStrokeStyle.addJoin(builder, style.join);
+    dashVector && BinStrokeStyle.addDash(builder, dashVector);
+    style.miterLimit !== undefined && BinStrokeStyle.addMiterLimit(builder, style.miterLimit);
+    return BinStrokeStyle.endStrokeStyle(builder);
+};
+const serializeStrokeSides = (builder, sides) => {
+    if (!sides)
+        return undefined;
+    const valuesVector = sides.values && sides.values.length > 0
+        ? BinStrokeSides.createValuesVector(builder, sides.values.map(v => ensureFiniteNumber(v)))
+        : undefined;
+    BinStrokeSides.startStrokeSides(builder);
+    BinStrokeSides.addPreference(builder, sides.preference);
+    valuesVector && BinStrokeSides.addValues(builder, valuesVector);
+    return BinStrokeSides.endStrokeSides(builder);
+};
+export const serializeElementStroke = (builder, stroke, forRenderer) => {
+    const contentOffset = serializeElementContentBase(builder, stroke.content);
+    const styleOffset = serializeStrokeStyle(builder, stroke.style);
+    const strokeSidesOffset = serializeStrokeSides(builder, stroke.strokeSides);
+    BinElementStroke.startElementStroke(builder);
+    BinElementStroke.addContent(builder, contentOffset);
+    stroke.placement !== undefined && BinElementStroke.addPlacement(builder, stroke.placement);
+    stroke.width && BinElementStroke.addWidth(builder, getPrecisionValueField(stroke.width, forRenderer));
+    styleOffset && BinElementStroke.addStyle(builder, styleOffset);
+    strokeSidesOffset && BinElementStroke.addStrokeSides(builder, strokeSidesOffset);
+    return BinElementStroke.endElementStroke(builder);
+};
+export const serializeElementBackground = (builder, background) => {
+    const contentOffset = serializeElementContentBase(builder, background.content);
+    BinElementBackground.startElementBackground(builder);
+    BinElementBackground.addContent(builder, contentOffset);
+    return BinElementBackground.endElementBackground(builder);
+};
+const serializeImageCrop = (builder, crop) => {
+    BinImageCrop.startImageCrop(builder);
+    crop.x !== undefined && BinImageCrop.addX(builder, ensureFiniteNumber(crop.x));
+    crop.y !== undefined && BinImageCrop.addY(builder, ensureFiniteNumber(crop.y));
+    crop.width !== undefined && BinImageCrop.addWidth(builder, ensureFiniteNumber(crop.width, 1));
+    crop.height !== undefined && BinImageCrop.addHeight(builder, ensureFiniteNumber(crop.height, 1));
+    return BinImageCrop.endImageCrop(builder);
+};
+const serializeDucTableStyleProps = (builder, styleProps, forRenderer) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const backgroundColorOffset = styleProps.background ? builder.createString(styleProps.background) : undefined;
+    const borderColorOffset = ((_a = styleProps.border) === null || _a === void 0 ? void 0 : _a.color) ? builder.createString(styleProps.border.color) : undefined;
+    const textColorOffset = ((_b = styleProps.text) === null || _b === void 0 ? void 0 : _b.color) ? builder.createString(styleProps.text.color) : undefined;
+    const textFontOffset = ((_c = styleProps.text) === null || _c === void 0 ? void 0 : _c.font) ? builder.createString(styleProps.text.font) : undefined;
+    const borderDashesVector = ((_d = styleProps.border) === null || _d === void 0 ? void 0 : _d.dashes) && styleProps.border.dashes.length > 0
+        ? BinDucTableStyleProps.createBorderDashesVector(builder, styleProps.border.dashes.map(d => ensureFiniteNumber(d)))
+        : undefined;
+    BinDucTableStyleProps.startDucTableStyleProps(builder);
+    backgroundColorOffset && BinDucTableStyleProps.addBackgroundColor(builder, backgroundColorOffset);
+    ((_e = styleProps.border) === null || _e === void 0 ? void 0 : _e.width) && BinDucTableStyleProps.addBorderWidth(builder, getPrecisionValueField(styleProps.border.width, forRenderer));
+    borderDashesVector && BinDucTableStyleProps.addBorderDashes(builder, borderDashesVector);
+    borderColorOffset && BinDucTableStyleProps.addBorderColor(builder, borderColorOffset);
+    textColorOffset && BinDucTableStyleProps.addTextColor(builder, textColorOffset);
+    ((_f = styleProps.text) === null || _f === void 0 ? void 0 : _f.size) && BinDucTableStyleProps.addTextSize(builder, getPrecisionValueField(styleProps.text.size, forRenderer));
+    textFontOffset && BinDucTableStyleProps.addTextFont(builder, textFontOffset);
+    ((_g = styleProps.text) === null || _g === void 0 ? void 0 : _g.align) && BinDucTableStyleProps.addTextAlign(builder, styleProps.text.align);
+    return BinDucTableStyleProps.endDucTableStyleProps(builder);
+};
+const serializeDucTableColumn = (builder, column, forRenderer) => {
+    const idOffset = builder.createString(column.id);
+    const styleOffset = column.style ? serializeDucTableStyleProps(builder, column.style, forRenderer) : undefined;
+    BinDucTableColumn.startDucTableColumn(builder);
+    BinDucTableColumn.addId(builder, idOffset);
+    column.width && BinDucTableColumn.addWidth(builder, getPrecisionValueField(column.width, forRenderer));
+    styleOffset && BinDucTableColumn.addStyle(builder, styleOffset);
+    return BinDucTableColumn.endDucTableColumn(builder);
+};
+const serializeDucTableRow = (builder, row, forRenderer) => {
+    const idOffset = builder.createString(row.id);
+    const styleOffset = row.style ? serializeDucTableStyleProps(builder, row.style, forRenderer) : undefined;
+    BinDucTableRow.startDucTableRow(builder);
+    BinDucTableRow.addId(builder, idOffset);
+    row.height && BinDucTableRow.addHeight(builder, getPrecisionValueField(row.height, forRenderer));
+    styleOffset && BinDucTableRow.addStyle(builder, styleOffset);
+    return BinDucTableRow.endDucTableRow(builder);
+};
+const serializeDucTableCell = (builder, cell, forRenderer) => {
+    const rowIdOffset = builder.createString(cell.rowId);
+    const columnIdOffset = builder.createString(cell.columnId);
+    const dataOffset = builder.createString(cell.data);
+    const styleOffset = cell.style ? serializeDucTableStyleProps(builder, cell.style, forRenderer) : undefined;
+    BinDucTableCell.startDucTableCell(builder);
+    BinDucTableCell.addRowId(builder, rowIdOffset);
+    BinDucTableCell.addColumnId(builder, columnIdOffset);
+    BinDucTableCell.addData(builder, dataOffset);
+    styleOffset && BinDucTableCell.addStyle(builder, styleOffset);
+    return BinDucTableCell.endDucTableCell(builder);
+};

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

@@ -0,0 +1,3 @@
+import * as flatbuffers from 'flatbuffers';
+import { DucGroup } from 'ducjs/legacy/v1/types/elements';
+export declare const serializeDucGroup: (builder: flatbuffers.Builder, group: DucGroup, forRenderer?: boolean) => flatbuffers.Offset;

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

@@ -0,0 +1,37 @@
+import { DucGroup as BinDucGroup, } from 'ducjs/legacy/v1/duc';
+import { serializeElementStroke, serializeElementBackground } from './serializeElementFromDuc';
+export const serializeDucGroup = (builder, group, forRenderer = false) => {
+    // Create string offsets
+    const idOffset = builder.createString(group.id);
+    const labelOffset = builder.createString(group.label);
+    const descriptionOffset = group.description ? builder.createString(group.description) : null;
+    const labelingColorOffset = builder.createString(group.labelingColor);
+    // Serialize stroke and background overrides
+    const strokeOverrideOffset = group.strokeOverride
+        ? serializeElementStroke(builder, group.strokeOverride, forRenderer)
+        : null;
+    const backgroundOverrideOffset = group.backgroundOverride
+        ? serializeElementBackground(builder, group.backgroundOverride)
+        : null;
+    // Create the group
+    BinDucGroup.startDucGroup(builder);
+    BinDucGroup.addId(builder, idOffset);
+    BinDucGroup.addLabel(builder, labelOffset);
+    if (descriptionOffset) {
+        BinDucGroup.addDescription(builder, descriptionOffset);
+    }
+    BinDucGroup.addIsCollapsed(builder, group.isCollapsed);
+    BinDucGroup.addNoPlot(builder, group.noPlot);
+    BinDucGroup.addLocked(builder, group.locked);
+    BinDucGroup.addIsVisible(builder, group.isVisible);
+    BinDucGroup.addOpacity(builder, group.opacity);
+    BinDucGroup.addLabelingColor(builder, labelingColorOffset);
+    if (strokeOverrideOffset) {
+        BinDucGroup.addStrokeOverride(builder, strokeOverrideOffset);
+    }
+    if (backgroundOverrideOffset) {
+        BinDucGroup.addBackgroundOverride(builder, backgroundOverrideOffset);
+    }
+    BinDucGroup.addClip(builder, group.clip);
+    return BinDucGroup.endDucGroup(builder);
+};

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

@@ -0,0 +1,4 @@
+import * as flatbuffers from 'flatbuffers';
+export declare const serializeRendererState: (builder: flatbuffers.Builder, rendererState: {
+    deletedElementIds: string[];
+}) => number;

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

@@ -0,0 +1,7 @@
+import { RendererState } from 'ducjs/legacy/v1/duc';
+export const serializeRendererState = (builder, rendererState) => {
+    const deletedElementIdsOffset = RendererState.createDeletedElementIdsVector(builder, rendererState.deletedElementIds.map((id) => builder.createString(id)));
+    RendererState.startRendererState(builder);
+    RendererState.addDeletedElementIds(builder, deletedElementIdsOffset);
+    return RendererState.endRendererState(builder);
+};