ducjs 1.0.0

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

@@ -0,0 +1,101 @@
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as flatbuffers from 'flatbuffers';
+import { restore } from 'ducjs/legacy/v1/utils/restore';
+import { ExportedDataState } from 'ducjs/legacy/v1/duc';
+import { parseAppStateFromBinary } from 'ducjs/legacy/v1/parse/parseAppStateFromBinary';
+import { parseBinaryFilesFromBinary } from 'ducjs/legacy/v1/parse/parseBinaryFilesFromBinary';
+import { parseElementFromBinary } from 'ducjs/legacy/v1/parse/parseElementFromBinary';
+import { parseRendererStateFromBinary } from 'ducjs/legacy/v1/parse/parseRendererStateFromBinary';
+import { parseBlockFromBinary } from 'ducjs/legacy/v1/parse/parseBlockFromBinary';
+import { parseGroupFromBinary } from 'ducjs/legacy/v1/parse/parseGroupFromBinary';
+export const parseDucFlatBuffers = (blob_1, ...args_1) => __awaiter(void 0, [blob_1, ...args_1], void 0, function* (blob, fileHandle = null) {
+    const arrayBuffer = yield blob.arrayBuffer();
+    const byteBuffer = new flatbuffers.ByteBuffer(new Uint8Array(arrayBuffer));
+    const data = ExportedDataState.getRootAsExportedDataState(byteBuffer);
+    const version = data.versionLegacy();
+    // Parse elements
+    const elements = [];
+    for (let i = 0; i < data.elementsLength(); i++) {
+        const e = data.elements(i);
+        if (e) {
+            const element = parseElementFromBinary(e, version);
+            if (element) {
+                elements.push(element);
+            }
+        }
+    }
+    // Parse appState
+    const appState = data.appState();
+    const parsedAppState = parseAppStateFromBinary(appState, version);
+    // Parse files
+    const binaryFiles = data.files();
+    const parsedFiles = parseBinaryFilesFromBinary(binaryFiles);
+    // Parse rendererState
+    const rendererState = data.rendererState();
+    const parsedRendererState = parseRendererStateFromBinary(rendererState);
+    // Parse blocks
+    const blocks = [];
+    for (let i = 0; i < data.blocksLength(); i++) {
+        const block = data.blocks(i);
+        if (block) {
+            const parsedBlock = parseBlockFromBinary(block, version);
+            if (parsedBlock) {
+                blocks.push(parsedBlock);
+            }
+        }
+    }
+    // Parse groups
+    const groups = [];
+    for (let i = 0; i < data.groupsLength(); i++) {
+        const group = data.groups(i);
+        if (group && parsedAppState.scope) {
+            const parsedGroup = parseGroupFromBinary(group, parsedAppState.scope);
+            if (parsedGroup) {
+                groups.push(parsedGroup);
+            }
+        }
+    }
+    const customExtendedAppStateRestorer = (extendedAppState, localExtendedAppState, restoredDucState) => {
+        return Object.assign(Object.assign({}, restoredDucState), { fileHandle: fileHandle || (blob && 'handle' in blob ? blob.handle : null) });
+    };
+    const sanitized = restore({
+        elements: elements,
+        appState: parsedAppState,
+        files: parsedFiles,
+        blocks,
+        groups,
+        rendererState: parsedRendererState,
+    }, undefined, undefined, customExtendedAppStateRestorer, {
+        repairBindings: true,
+        refreshDimensions: false,
+        syncInvalidIndices: (elements) => elements,
+    });
+    const cleanAppState = __rest(sanitized.appState, []);
+    return {
+        elements: sanitized.elements,
+        appState: cleanAppState,
+        files: sanitized.files,
+        blocks: sanitized.blocks,
+        groups: sanitized.groups,
+        rendererState: parsedRendererState,
+    };
+});

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

@@ -0,0 +1,3 @@
+import { AppState as BinAppState } from 'ducjs/legacy/v1/duc';
+import { DucState } from 'ducjs/legacy/v1/types';
+export declare const parseAppStateFromBinary: (appStateBin: BinAppState | null, v: number) => Partial<DucState>;

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

@@ -0,0 +1,139 @@
+import { parseElementBinBackground, parseElementBinStroke, parsePoint } from 'ducjs/legacy/v1/parse/parseElementFromBinary';
+import { getPrecisionValueFromRaw, NEUTRAL_SCOPE } from 'ducjs/legacy/v1/utils/scopes';
+import { HANDLE_TYPE } from 'ducjs/legacy/v1/utils/constants';
+export const parseAppStateFromBinary = (appStateBin, v) => {
+    var _a;
+    if (!appStateBin)
+        return {};
+    const forceNeutralScope = v <= 5;
+    let readScope = appStateBin.scope();
+    const scope = forceNeutralScope ? NEUTRAL_SCOPE : (readScope || NEUTRAL_SCOPE);
+    let readMainScope = appStateBin.mainScope();
+    const mainScope = forceNeutralScope ? NEUTRAL_SCOPE : (readMainScope || NEUTRAL_SCOPE);
+    // Parse LinearElementEditor 
+    let editingLinearElement = null;
+    if (appStateBin.editingLinearElement()) {
+        const editor = appStateBin.editingLinearElement();
+        // Parse selected points indices
+        const selectedPointsIndices = Array.from({ length: editor.selectedPointsIndicesLength() })
+            .map((_, i) => editor.selectedPointsIndices(i));
+        // Parse pointer down state
+        let pointerDownState = undefined;
+        if (editor.pointerDownState()) {
+            const pds = editor.pointerDownState();
+            const handleType = pds.handleType();
+            pointerDownState = {
+                prevSelectedPointsIndices: Array.from({ length: pds.prevSelectedPointsIndicesLength() })
+                    .map((_, i) => pds.prevSelectedPointsIndices(i)),
+                // prevSelectedHandles: Array.from({ length: pds.prevSelectedHandlesLength() })
+                //   .map((_, i) => pds.prevSelectedHandles(i)),
+                prevSelectedHandles: null,
+                lastClickedPoint: pds.lastClickedPoint(),
+                lastClickedIsEndPoint: pds.lastClickedIsEndPoint(),
+                origin: pds.origin() ? {
+                    x: pds.origin().x(),
+                    y: pds.origin().y(),
+                } : undefined,
+                segmentMidpoint: pds.segmentMidpoint() ? {
+                    value: pds.segmentMidpoint().value() ?
+                        parsePoint(pds.segmentMidpoint().value(), scope) :
+                        undefined,
+                    index: pds.segmentMidpoint().index(),
+                    added: pds.segmentMidpoint().added(),
+                } : undefined,
+                handleType: HANDLE_TYPE.HANDLE_IN === handleType ? "handleIn" : "handleOut",
+                handleInfo: null,
+            };
+        }
+        // Create LinearElementEditor with all required properties
+        editingLinearElement = {
+            elementId: editor.elementId(),
+            selectedPointsIndices,
+            pointerDownState,
+            isDragging: editor.isDragging(),
+            wasDragging: false,
+            lastUncommittedPoint: editor.lastUncommittedPoint() ?
+                parsePoint(editor.lastUncommittedPoint(), scope) :
+                undefined,
+            pointerOffset: editor.pointerOffset() ? {
+                x: editor.pointerOffset().x(),
+                y: editor.pointerOffset().y(),
+            } : { x: 0, y: 0 },
+            startBindingElement: editor.startBindingElement() || undefined,
+            endBindingElement: editor.endBindingElement() || undefined,
+            hoverPointIndex: editor.hoverPointIndex(),
+            // selectedHandles: editor.selectedHandles() ? 
+            //   editor.selectedHandles()!.map(handle => ({
+            //     pointIndex: handle.pointIndex(),
+            //     handleType: handle.handleType() as LinearElementEditor["pointerDownState"]["handleType"],
+            //   })) : 
+            //   null,
+            // hoveredHandle: editor.hoveredHandle() ? 
+            //   {
+            //     pointIndex: editor.hoveredHandle()!.pointIndex(),
+            //     handleType: editor.hoveredHandle()!.handleType() as LinearElementEditor["pointerDownState"]["handleType"],
+            //   } : 
+            //   null,
+            selectedHandles: null,
+            hoveredHandle: null,
+            segmentMidPointHoveredCoords: editor.segmentMidPointHoveredCoords() ?
+                parsePoint(editor.segmentMidPointHoveredCoords(), scope) :
+                undefined,
+            _dragCache: null,
+            shouldStartNewChain: false,
+            addingPointToExistingElement: false,
+            lastClosedPathPointIndex: null,
+            elementScope: scope,
+            pointsCoincidentWithExisting: new Map(), // Initialize coincidence tracking
+        };
+    }
+    return {
+        name: appStateBin.name(),
+        zoom: {
+            value: appStateBin.zoom(),
+        }, // So that we don't have to parse the stateless values, this is handled on restore.ts
+        selectedElementIds: Object.fromEntries(Array.from({ length: appStateBin.selectedElementIdsLength() }, (_, i) => [
+            appStateBin.selectedElementIds(i),
+            true,
+        ])),
+        elementsPendingErasure: new Set(Array.from({ length: appStateBin.elementsPendingErasureLength() }, (_, i) => appStateBin.elementsPendingErasure(i))),
+        gridSize: appStateBin.gridSize(),
+        gridStep: appStateBin.gridStep(),
+        scrollX: {
+            value: appStateBin.scrollX(),
+        }, // So that we don't have to parse the stateless values, this is handled on restore.ts
+        scrollY: {
+            value: appStateBin.scrollY(),
+        }, // So that we don't have to parse the stateless values, this is handled on restore.ts
+        scrolledOutside: appStateBin.scrolledOutside(),
+        scope,
+        mainScope,
+        standard: (_a = appStateBin.standard()) !== null && _a !== void 0 ? _a : undefined,
+        currentItemStroke: parseElementBinStroke(appStateBin.currentItemStroke(), scope),
+        currentItemBackground: parseElementBinBackground(appStateBin.currentItemBackground()),
+        currentItemFontFamily: Number(appStateBin.currentItemFontFamilyV2()),
+        currentItemRoundness: getPrecisionValueFromRaw(appStateBin.currentItemRoundnessV3(), scope, scope),
+        currentItemFontSize: getPrecisionValueFromRaw(appStateBin.currentItemFontSizeV3(), scope, scope),
+        currentItemTextAlign: appStateBin.currentItemTextAlignV3(),
+        currentItemStartLineHead: appStateBin.currentItemStartLineHead(),
+        currentItemEndLineHead: appStateBin.currentItemEndLineHead(),
+        viewBackgroundColor: appStateBin.viewBackgroundColor() || undefined,
+        scaleRatioLocked: appStateBin.scaleRatioLocked(),
+        displayAllPointDistances: appStateBin.displayAllPointDistances(),
+        displayDistanceOnDrawing: appStateBin.displayDistanceOnDrawing(),
+        displayAllPointCoordinates: appStateBin.displayAllPointCoordinates(),
+        displayAllPointInfoSelected: appStateBin.displayAllPointInfoSelected(),
+        displayRootAxis: appStateBin.displayRootAxis(),
+        coordDecimalPlaces: appStateBin.coordDecimalPlacesV3(),
+        scopeExponentThreshold: appStateBin.scopeExponentThreshold(),
+        lineBendingMode: appStateBin.lineBendingMode(),
+        antiAliasing: appStateBin.antiAliasing(),
+        vSync: appStateBin.vSync(),
+        debugRendering: appStateBin.debugRendering(),
+        zoomStep: appStateBin.zoomStep(),
+        // hoveredElementId: appStateBin.hoveredElementId() || undefined,
+        // suggestedBindingElementId: appStateBin.suggestedBindingElementId() || undefined,
+        isBindingEnabled: appStateBin.isBindingEnabled(),
+        editingLinearElement: v <= 5 ? undefined : editingLinearElement,
+    };
+};

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

@@ -0,0 +1,4 @@
+import { BinaryFiles as BinBinaryFiles } from 'ducjs/legacy/v1/duc';
+import { BinaryFiles } from 'ducjs/legacy/v1/types';
+export declare const uint8ArrayToDataURL: (uint8Array: Uint8Array, mimeType: string) => string;
+export declare const parseBinaryFilesFromBinary: (binaryFiles: BinBinaryFiles | null) => BinaryFiles;

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

@@ -0,0 +1,32 @@
+// Helper function to convert Uint8Array to DataURL
+export const uint8ArrayToDataURL = (uint8Array, mimeType) => {
+    const binaryString = Array.from(uint8Array)
+        .map(byte => String.fromCharCode(byte))
+        .join('');
+    const base64 = btoa(binaryString);
+    return `data:${mimeType};base64,${base64}`;
+};
+export const parseBinaryFilesFromBinary = (binaryFiles) => {
+    if (!binaryFiles)
+        return {};
+    const files = {};
+    for (let i = 0; i < binaryFiles.entriesLength(); i++) {
+        const entry = binaryFiles.entries(i);
+        if (entry === null)
+            continue;
+        const key = entry.key();
+        const fileData = entry.value();
+        if (key && fileData) {
+            const mimeType = fileData.mimeType() || 'application/octet-stream';
+            const dataArray = fileData.dataArray() || new Uint8Array();
+            files[key] = {
+                mimeType,
+                id: fileData.id() || '',
+                dataURL: uint8ArrayToDataURL(dataArray, mimeType), // Convert Uint8Array back to dataURL
+                created: Number(fileData.created()),
+                lastRetrieved: Number(fileData.lastRetrieved()),
+            };
+        }
+    }
+    return files;
+};

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

@@ -0,0 +1,3 @@
+import { DucBlock as BinDucBlock } from 'ducjs/legacy/v1/duc';
+import { DucBlock } from 'ducjs/legacy/v1/types/elements';
+export declare const parseBlockFromBinary: (block: BinDucBlock, version: number) => Partial<DucBlock> | null;

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

@@ -0,0 +1,70 @@
+import { getPrecisionValueFromRaw, NEUTRAL_SCOPE } from 'ducjs/legacy/v1/utils/scopes';
+import { parseElementFromBinary } from './parseElementFromBinary';
+export const parseBlockFromBinary = (block, version) => {
+    if (!block)
+        return null;
+    const id = block.id() || undefined;
+    const label = block.label() || undefined;
+    const description = block.description() || undefined;
+    const blockVersion = block.version() || undefined;
+    // Parse elements
+    const elements = [];
+    for (let i = 0; i < block.elementsLength(); i++) {
+        const element = block.elements(i);
+        if (element) {
+            const parsedElement = parseElementFromBinary(element, version);
+            if (parsedElement) {
+                elements.push(parsedElement);
+            }
+        }
+    }
+    // Parse attributes
+    const attributes = {};
+    for (let i = 0; i < block.attributesLength(); i++) {
+        const attribute = block.attributes(i);
+        if (attribute) {
+            const parsedAttribute = parseBlockAttributeFromBinary(attribute);
+            if (parsedAttribute) {
+                attributes[parsedAttribute.name] = parsedAttribute.details;
+            }
+        }
+    }
+    return {
+        id,
+        label,
+        description,
+        version: blockVersion,
+        elements,
+        attributes: Object.keys(attributes).length > 0 ? attributes : undefined,
+    };
+};
+const parseBlockAttributeFromBinary = (attribute) => {
+    if (!attribute)
+        return null;
+    const name = attribute.name() || '';
+    const details = parseBlockAttributeDetailsFromBinary(attribute.details());
+    if (!details)
+        return null;
+    return {
+        name,
+        details,
+    };
+};
+const parseBlockAttributeDetailsFromBinary = (details) => {
+    if (!details)
+        return null;
+    const tag = details.tag() || '';
+    const defaultValue = details.defaultValue() || '';
+    const prompt = details.prompt() || undefined;
+    const position = details.position();
+    const positionParsed = position ? {
+        x: getPrecisionValueFromRaw(position.x(), NEUTRAL_SCOPE, NEUTRAL_SCOPE),
+        y: getPrecisionValueFromRaw(position.y(), NEUTRAL_SCOPE, NEUTRAL_SCOPE),
+    } : undefined;
+    return {
+        tag,
+        defaultValue,
+        prompt,
+        position: positionParsed,
+    };
+};

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

@@ -0,0 +1,8 @@
+import { DucElement as BinDucElement, ElementBackground as BinElementBackground, ElementContentBase as BinElementContentBase, ElementStroke as BinElementStroke, Point as BinPoint } from 'ducjs/legacy/v1/duc';
+import { SupportedMeasures } from 'ducjs/legacy/v1/utils/measurements';
+import { DucElement, DucPoint, ElementBackground, ElementContentBase, ElementStroke } from 'ducjs/legacy/v1/types/elements';
+export declare const parsePoint: (point: BinPoint | null, elementScope: SupportedMeasures) => DucPoint | null;
+export declare const parseElementFromBinary: (e: BinDucElement, v: number) => Partial<DucElement> | null;
+export declare const parseElementContentBase: (content: BinElementContentBase | null, defaults: ElementContentBase) => ElementContentBase;
+export declare const parseElementBinStroke: (stroke: BinElementStroke | null, elementScope: SupportedMeasures) => ElementStroke;
+export declare const parseElementBinBackground: (background: BinElementBackground | null) => ElementBackground;