ducjs 1.0.0

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

@@ -0,0 +1,145 @@
+import { HANDLE_TYPE } from 'ducjs/legacy/v1/utils/constants';
+import { AppState as BinAppState, LinearElementEditor, PointerDownState, SegmentMidpointState, SimplePoint } from 'ducjs/legacy/v1/duc';
+import { ensureFiniteNumber, getPrecisionValueField } from 'ducjs/legacy/v1/serialize/serializationUtils';
+import { serializeDucPoint, serializeElementBackground, serializeElementStroke } from 'ducjs/legacy/v1/serialize/serializeElementFromDuc';
+const serializeAppState = (builder, appState, forRenderer) => {
+    var _a, _b;
+    const nameOffset = appState.name ? builder.createString(appState.name) : undefined;
+    const selectedElementIdsOffsets = appState.selectedElementIds ? Object.keys(appState.selectedElementIds).map(id => builder.createString(id)) : [];
+    const selectedElementIdsVector = selectedElementIdsOffsets.length > 0 ? BinAppState.createSelectedElementIdsVector(builder, selectedElementIdsOffsets) : undefined;
+    const scopeOffset = appState.scope ? builder.createString(appState.scope) : undefined;
+    const mainScopeOffset = appState.mainScope ? builder.createString(appState.mainScope) : undefined;
+    const currentItemStrokeOffset = appState.currentItemStroke ? serializeElementStroke(builder, appState.currentItemStroke, forRenderer) : undefined;
+    const currentItemBackgroundOffset = appState.currentItemBackground ? serializeElementBackground(builder, appState.currentItemBackground) : undefined;
+    const currentItemFontFamilyOffset = appState.currentItemFontFamily ? builder.createString(String(appState.currentItemFontFamily)) : undefined;
+    const viewBackgroundColorOffset = appState.viewBackgroundColor ? builder.createString(appState.viewBackgroundColor) : undefined;
+    const hoveredElementIdOffset = appState.elementHovered ? builder.createString(appState.elementHovered.id) : undefined;
+    const suggestedBindingElementIdOffset = ((_a = appState.suggestedBindings) === null || _a === void 0 ? void 0 : _a.length) ?
+        builder.createString(Array.isArray(appState.suggestedBindings[0])
+            ? appState.suggestedBindings[0][0].id
+            : appState.suggestedBindings[0].id) : undefined;
+    const elementsPendingErasureVector = ((_b = appState.elementsPendingErasure) === null || _b === void 0 ? void 0 : _b.size) ?
+        BinAppState.createElementsPendingErasureVector(builder, Array.from(appState.elementsPendingErasure).map(id => builder.createString(id))) :
+        undefined;
+    let editingLinearElementOffset;
+    if (appState.editingLinearElement) {
+        const el = appState.editingLinearElement;
+        const elementIdOffset = builder.createString(el.elementId || '');
+        const getBindingElementIdOffset = (bindingElem) => {
+            if (!bindingElem)
+                return undefined;
+            if (typeof bindingElem === 'string')
+                return builder.createString(bindingElem);
+            return builder.createString(bindingElem.id || '');
+        };
+        const startBindingElementOffset = getBindingElementIdOffset(el.startBindingElement);
+        const endBindingElementOffset = getBindingElementIdOffset(el.endBindingElement);
+        const selectedPointsIndices = el.selectedPointsIndices ? Array.from(el.selectedPointsIndices).map(idx => ensureFiniteNumber(idx)) : [];
+        const selectedPointsIndicesVector = selectedPointsIndices.length > 0 ?
+            LinearElementEditor.createSelectedPointsIndicesVector(builder, selectedPointsIndices) : undefined;
+        const pointerOffsetOffset = el.pointerOffset ?
+            SimplePoint.createSimplePoint(builder, ensureFiniteNumber(el.pointerOffset.x), ensureFiniteNumber(el.pointerOffset.y)) : undefined;
+        const lastUncommittedPointOffset = el.lastUncommittedPoint ? serializeDucPoint(builder, el.lastUncommittedPoint, forRenderer) : undefined;
+        const segmentMidPointHoveredCoordsOffset = el.segmentMidPointHoveredCoords ? serializeDucPoint(builder, el.segmentMidPointHoveredCoords, forRenderer) : undefined;
+        let pointerDownStateOffset;
+        if (el.pointerDownState) {
+            const pds = el.pointerDownState;
+            const prevSelectedPointsIndices = pds.prevSelectedPointsIndices ? Array.from(pds.prevSelectedPointsIndices).map(idx => ensureFiniteNumber(idx)) : [];
+            const prevSelectedPointsIndicesVector = prevSelectedPointsIndices.length > 0 ?
+                PointerDownState.createPrevSelectedPointsIndicesVector(builder, prevSelectedPointsIndices) : undefined;
+            const originOffset = pds.origin ?
+                SimplePoint.createSimplePoint(builder, ensureFiniteNumber(pds.origin.x), ensureFiniteNumber(pds.origin.y)) : undefined;
+            let segmentMidpointOffset;
+            if (pds.segmentMidpoint) {
+                const sm = pds.segmentMidpoint;
+                const valueOffset = sm.value ? serializeDucPoint(builder, sm.value, forRenderer) : undefined;
+                SegmentMidpointState.startSegmentMidpointState(builder);
+                if (valueOffset)
+                    SegmentMidpointState.addValue(builder, valueOffset);
+                SegmentMidpointState.addIndex(builder, sm.index || 0);
+                SegmentMidpointState.addAdded(builder, sm.added || false);
+                segmentMidpointOffset = SegmentMidpointState.endSegmentMidpointState(builder);
+            }
+            PointerDownState.startPointerDownState(builder);
+            prevSelectedPointsIndicesVector && PointerDownState.addPrevSelectedPointsIndices(builder, prevSelectedPointsIndicesVector);
+            PointerDownState.addLastClickedPoint(builder, ensureFiniteNumber(pds.lastClickedPoint));
+            PointerDownState.addLastClickedIsEndPoint(builder, pds.lastClickedIsEndPoint || false);
+            originOffset && PointerDownState.addOrigin(builder, originOffset);
+            segmentMidpointOffset && PointerDownState.addSegmentMidpoint(builder, segmentMidpointOffset);
+            const handleType = pds.handleType;
+            if (handleType !== undefined && handleType !== null) {
+                let handleTypeValue = undefined;
+                if (handleType === 'handleIn')
+                    handleTypeValue = HANDLE_TYPE.HANDLE_IN;
+                else if (handleType === 'handleOut')
+                    handleTypeValue = HANDLE_TYPE.HANDLE_OUT;
+                if (handleTypeValue !== undefined) {
+                    PointerDownState.addHandleType(builder, handleTypeValue);
+                }
+            }
+            pointerDownStateOffset = PointerDownState.endPointerDownState(builder);
+        }
+        LinearElementEditor.startLinearElementEditor(builder);
+        LinearElementEditor.addElementId(builder, elementIdOffset);
+        selectedPointsIndicesVector && LinearElementEditor.addSelectedPointsIndices(builder, selectedPointsIndicesVector);
+        pointerDownStateOffset && LinearElementEditor.addPointerDownState(builder, pointerDownStateOffset);
+        LinearElementEditor.addIsDragging(builder, el.isDragging || false);
+        lastUncommittedPointOffset && LinearElementEditor.addLastUncommittedPoint(builder, lastUncommittedPointOffset);
+        pointerOffsetOffset && LinearElementEditor.addPointerOffset(builder, pointerOffsetOffset);
+        startBindingElementOffset && LinearElementEditor.addStartBindingElement(builder, startBindingElementOffset);
+        endBindingElementOffset && LinearElementEditor.addEndBindingElement(builder, endBindingElementOffset);
+        LinearElementEditor.addHoverPointIndex(builder, ensureFiniteNumber(el.hoverPointIndex));
+        segmentMidPointHoveredCoordsOffset && LinearElementEditor.addSegmentMidPointHoveredCoords(builder, segmentMidPointHoveredCoordsOffset);
+        editingLinearElementOffset = LinearElementEditor.endLinearElementEditor(builder);
+    }
+    BinAppState.startAppState(builder);
+    nameOffset && BinAppState.addName(builder, nameOffset);
+    selectedElementIdsVector && BinAppState.addSelectedElementIds(builder, selectedElementIdsVector);
+    elementsPendingErasureVector && BinAppState.addElementsPendingErasure(builder, elementsPendingErasureVector);
+    scopeOffset && BinAppState.addScope(builder, scopeOffset);
+    mainScopeOffset && BinAppState.addMainScope(builder, mainScopeOffset);
+    currentItemStrokeOffset && BinAppState.addCurrentItemStroke(builder, currentItemStrokeOffset);
+    currentItemBackgroundOffset && BinAppState.addCurrentItemBackground(builder, currentItemBackgroundOffset);
+    currentItemFontFamilyOffset && BinAppState.addCurrentItemFontFamilyV2(builder, currentItemFontFamilyOffset);
+    viewBackgroundColorOffset && BinAppState.addViewBackgroundColor(builder, viewBackgroundColorOffset);
+    editingLinearElementOffset && BinAppState.addEditingLinearElement(builder, editingLinearElementOffset);
+    hoveredElementIdOffset && BinAppState.addHoveredElementId(builder, hoveredElementIdOffset);
+    elementsPendingErasureVector && BinAppState.addElementsPendingErasure(builder, elementsPendingErasureVector);
+    suggestedBindingElementIdOffset && BinAppState.addSuggestedBindingElementId(builder, suggestedBindingElementIdOffset);
+    if (appState.zoom) {
+        const zoomValueToSerialize = forRenderer ? appState.zoom.scoped : appState.zoom.value;
+        BinAppState.addZoom(builder, ensureFiniteNumber(zoomValueToSerialize));
+    }
+    appState.zoomStep !== undefined && BinAppState.addZoomStep(builder, appState.zoomStep);
+    appState.gridSize !== undefined && BinAppState.addGridSize(builder, appState.gridSize);
+    appState.gridStep !== undefined && BinAppState.addGridStep(builder, appState.gridStep);
+    appState.isBindingEnabled !== undefined && BinAppState.addIsBindingEnabled(builder, appState.isBindingEnabled);
+    if (appState.scrollX) {
+        BinAppState.addScrollX(builder, getPrecisionValueField(appState.scrollX, forRenderer));
+    }
+    if (appState.scrollY) {
+        BinAppState.addScrollY(builder, getPrecisionValueField(appState.scrollY, forRenderer));
+    }
+    appState.scrolledOutside !== undefined && BinAppState.addScrolledOutside(builder, appState.scrolledOutside);
+    appState.currentItemOpacity !== undefined && BinAppState.addCurrentItemOpacity(builder, appState.currentItemOpacity);
+    appState.currentItemFontSize !== undefined && BinAppState.addCurrentItemFontSizeV3(builder, getPrecisionValueField(appState.currentItemFontSize, forRenderer));
+    appState.currentItemRoundness && BinAppState.addCurrentItemRoundnessV3(builder, getPrecisionValueField(appState.currentItemRoundness, forRenderer));
+    appState.currentItemTextAlign && BinAppState.addCurrentItemTextAlignV3(builder, appState.currentItemTextAlign);
+    appState.scaleRatioLocked !== undefined && BinAppState.addScaleRatioLocked(builder, appState.scaleRatioLocked);
+    appState.displayAllPointDistances !== undefined && BinAppState.addDisplayAllPointDistances(builder, appState.displayAllPointDistances);
+    appState.displayDistanceOnDrawing !== undefined && BinAppState.addDisplayDistanceOnDrawing(builder, appState.displayDistanceOnDrawing);
+    appState.displayAllPointCoordinates !== undefined && BinAppState.addDisplayAllPointCoordinates(builder, appState.displayAllPointCoordinates);
+    appState.coordDecimalPlaces !== undefined && BinAppState.addCoordDecimalPlacesV3(builder, appState.coordDecimalPlaces);
+    appState.scopeExponentThreshold !== undefined && BinAppState.addScopeExponentThreshold(builder, appState.scopeExponentThreshold);
+    appState.displayAllPointInfoSelected !== undefined && BinAppState.addDisplayAllPointInfoSelected(builder, appState.displayAllPointInfoSelected);
+    appState.displayRootAxis !== undefined && BinAppState.addDisplayRootAxis(builder, appState.displayRootAxis);
+    appState.lineBendingMode && BinAppState.addLineBendingMode(builder, appState.lineBendingMode);
+    appState.standard && BinAppState.addStandard(builder, appState.standard);
+    appState.currentItemStartLineHead && BinAppState.addCurrentItemStartLineHead(builder, appState.currentItemStartLineHead);
+    appState.currentItemEndLineHead && BinAppState.addCurrentItemEndLineHead(builder, appState.currentItemEndLineHead);
+    appState.antiAliasing !== undefined && BinAppState.addAntiAliasing(builder, appState.antiAliasing);
+    appState.vSync !== undefined && BinAppState.addVSync(builder, appState.vSync);
+    appState.debugRendering !== undefined && BinAppState.addDebugRendering(builder, appState.debugRendering);
+    return BinAppState.endAppState(builder);
+};
+export { serializeAppState };

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

@@ -0,0 +1,4 @@
+import * as flatbuffers from 'flatbuffers';
+import { BinaryFiles as BinaryFilesType } from 'ducjs/legacy/v1/types';
+declare const serializeBinaryFiles: (builder: flatbuffers.Builder, files: BinaryFilesType) => flatbuffers.Offset;
+export { serializeBinaryFiles };

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

@@ -0,0 +1,46 @@
+import { BinaryFileData, BinaryFilesEntry, BinaryFiles as BinBinaryFiles } from 'ducjs/legacy/v1/duc';
+import { ensureFiniteNumber } from 'ducjs/legacy/v1/serialize/serializationUtils'; // Import shared helper
+// Helper function to convert a DataURL (base64 string) to Uint8Array
+const dataURLToUint8Array = (dataURL) => {
+    if (!dataURL || dataURL.indexOf(',') === -1) { // Added check for valid dataURL format
+        // console.error("Invalid dataURL format in dataURLToUint8Array");
+        return new Uint8Array(0);
+    }
+    const base64 = dataURL.split(',')[1];
+    if (!base64)
+        return new Uint8Array(0);
+    try {
+        const binaryString = atob(base64);
+        const len = binaryString.length;
+        const bytes = new Uint8Array(len);
+        for (let i = 0; i < len; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes;
+    }
+    catch (e) {
+        console.error("Error decoding base64 string in dataURLToUint8Array:", e);
+        return new Uint8Array(0);
+    }
+};
+const serializeBinaryFiles = (builder, files) => {
+    const fileEntriesOffsets = Object.keys(files).map(key => {
+        const file = files[key];
+        const keyOffset = builder.createString(key);
+        const mimeTypeOffset = builder.createString(file.mimeType || "application/octet-stream");
+        const idOffset = builder.createString(file.id || key);
+        const data = dataURLToUint8Array(file.dataURL || "");
+        const dataOffset = BinaryFileData.createDataVector(builder, data);
+        // Use imported ensureFiniteNumber for timestamps
+        const createdTimestamp = ensureFiniteNumber(file.created, Date.now());
+        const lastRetrievedTimestamp = ensureFiniteNumber(file.lastRetrieved, Date.now());
+        const binaryFileDataOffset = BinaryFileData.createBinaryFileData(builder, mimeTypeOffset, idOffset, dataOffset, BigInt(createdTimestamp), BigInt(lastRetrievedTimestamp));
+        BinaryFilesEntry.startBinaryFilesEntry(builder);
+        BinaryFilesEntry.addKey(builder, keyOffset);
+        BinaryFilesEntry.addValue(builder, binaryFileDataOffset);
+        return BinaryFilesEntry.endBinaryFilesEntry(builder);
+    });
+    const filesVectorOffset = BinBinaryFiles.createEntriesVector(builder, fileEntriesOffsets);
+    return BinBinaryFiles.createBinaryFiles(builder, filesVectorOffset);
+};
+export { serializeBinaryFiles };

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

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

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

@@ -0,0 +1,60 @@
+import { DucBlock as BinDucBlock, DucBlockAttribute as BinDucBlockAttribute, DucBlockAttributeDetails as BinDucBlockAttributeDetails, SimplePoint, } from 'ducjs/legacy/v1/duc';
+import { serializeDucElement } from './serializeElementFromDuc';
+import { getPrecisionValueField } from './serializationUtils';
+export const serializeDucBlock = (builder, block, forRenderer = false) => {
+    // Create string offsets
+    const idOffset = builder.createString(block.id);
+    const labelOffset = builder.createString(block.label);
+    const descriptionOffset = block.description ? builder.createString(block.description) : null;
+    // Serialize elements
+    const elementOffsets = block.elements.map(element => serializeDucElement(builder, element, forRenderer));
+    const elementsVector = BinDucBlock.createElementsVector(builder, elementOffsets);
+    // Serialize attributes
+    const attributeOffsets = block.attributes
+        ? Object.entries(block.attributes).map(([name, details]) => serializeDucBlockAttribute(builder, { name, details: details }, forRenderer))
+        : [];
+    const attributesVector = attributeOffsets.length > 0
+        ? BinDucBlock.createAttributesVector(builder, attributeOffsets)
+        : null;
+    // Create the block
+    BinDucBlock.startDucBlock(builder);
+    BinDucBlock.addId(builder, idOffset);
+    BinDucBlock.addLabel(builder, labelOffset);
+    if (descriptionOffset) {
+        BinDucBlock.addDescription(builder, descriptionOffset);
+    }
+    BinDucBlock.addVersion(builder, block.version);
+    BinDucBlock.addElements(builder, elementsVector);
+    if (attributesVector) {
+        BinDucBlock.addAttributes(builder, attributesVector);
+    }
+    return BinDucBlock.endDucBlock(builder);
+};
+const serializeDucBlockAttribute = (builder, attribute, forRenderer = false) => {
+    const nameOffset = builder.createString(attribute.name);
+    const detailsOffset = serializeDucBlockAttributeDetails(builder, attribute.details, forRenderer);
+    BinDucBlockAttribute.startDucBlockAttribute(builder);
+    BinDucBlockAttribute.addName(builder, nameOffset);
+    BinDucBlockAttribute.addDetails(builder, detailsOffset);
+    return BinDucBlockAttribute.endDucBlockAttribute(builder);
+};
+const serializeDucBlockAttributeDetails = (builder, details, forRenderer = false) => {
+    const tagOffset = builder.createString(details.tag);
+    const defaultValueOffset = builder.createString(details.defaultValue);
+    const promptOffset = details.prompt ? builder.createString(details.prompt) : null;
+    // Serialize position if present
+    let positionOffset = null;
+    if (details.position) {
+        positionOffset = SimplePoint.createSimplePoint(builder, getPrecisionValueField(details.position.x, forRenderer), getPrecisionValueField(details.position.y, forRenderer));
+    }
+    BinDucBlockAttributeDetails.startDucBlockAttributeDetails(builder);
+    BinDucBlockAttributeDetails.addTag(builder, tagOffset);
+    BinDucBlockAttributeDetails.addDefaultValue(builder, defaultValueOffset);
+    if (promptOffset) {
+        BinDucBlockAttributeDetails.addPrompt(builder, promptOffset);
+    }
+    if (positionOffset) {
+        BinDucBlockAttributeDetails.addPosition(builder, positionOffset);
+    }
+    return BinDucBlockAttributeDetails.endDucBlockAttributeDetails(builder);
+};

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

@@ -0,0 +1,8 @@
+import type { DucPoint } from 'ducjs/legacy/v1/types/elements';
+import { DucElement, DucPointBinding, ElementBackground, ElementStroke } from 'ducjs/legacy/v1/types/elements';
+import * as flatbuffers from 'flatbuffers';
+export declare const serializeDucElement: (builder: flatbuffers.Builder, element: DucElement, forRenderer?: boolean) => flatbuffers.Offset;
+export declare const serializeDucPoint: (builder: flatbuffers.Builder, point: DucPoint, forRenderer: boolean) => flatbuffers.Offset;
+export declare const serializeDucPointBinding: (builder: flatbuffers.Builder, pointBinding: DucPointBinding, forRenderer: boolean) => flatbuffers.Offset;
+export declare const serializeElementStroke: (builder: flatbuffers.Builder, stroke: ElementStroke, forRenderer: boolean) => flatbuffers.Offset;
+export declare const serializeElementBackground: (builder: flatbuffers.Builder, background: ElementBackground) => flatbuffers.Offset;