ducjs 2.0.0 → 2.1.0

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

@@ -1,101 +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());
-    });
-};
-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

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

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

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

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

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

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

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