ducjs 1.0.0

package/dist/restore/restoreStandards.d.ts

@@ -0,0 +1,8 @@
+import { Standard } from "ducjs/technical/standards";
+import { Scope } from "ducjs/types";
+export declare const restoreStandards: (standards: any, currentScope?: Scope) => Standard[];
+/**
+ * Checks if a given id is present in the standards array.
+ * @returns true if found, false otherwise.
+ */
+export declare const isStandardIdPresent: (id: string, standards: Standard[]) => boolean;

package/dist/restore/restoreStandards.js

@@ -0,0 +1,224 @@
+import { ANGULAR_UNITS_FORMAT, DECIMAL_SEPARATOR, DIMENSION_UNITS_FORMAT, GRID_DISPLAY_TYPE, GRID_TYPE, UNIT_SYSTEM, } from "ducjs/flatbuffers/duc";
+import { isValidBoolean, isValidEnumValue, isValidRadianValue, isValidString, restorePrecisionValue } from "ducjs/restore/restoreDataState";
+import { NEUTRAL_SCOPE, ScaleFactors } from "ducjs/technical";
+import { PREDEFINED_STANDARDS } from "ducjs/technical/standards";
+export const restoreStandards = (standards, 
+// Pass current scope to resolve precision values if needed
+currentScope = NEUTRAL_SCOPE) => {
+    if (!Array.isArray(standards) || standards.length === 0) {
+        // If no standards are provided, return a default set.
+        return DEFAULT_STANDARDS;
+    }
+    const restoredStandards = [];
+    const restoredIds = new Set();
+    for (const s of standards) {
+        if (!s || typeof s !== 'object')
+            continue;
+        const identifier = restoreIdentifier(s);
+        if (!identifier || restoredIds.has(identifier.id)) {
+            continue; // Skip if no valid ID or if ID is a duplicate
+        }
+        restoredStandards.push(Object.assign(Object.assign({}, identifier), { version: isValidString(s.version, "1.0.0"), readonly: isValidBoolean(s.readonly, false), overrides: restoreStandardOverrides(s.overrides, currentScope), styles: restoreStandardStyles(s.styles, currentScope), viewSettings: restoreStandardViewSettings(s.viewSettings, currentScope), units: restoreStandardUnits(s.units, currentScope), validation: restoreStandardValidation(s.validation, currentScope) }));
+        restoredIds.add(identifier.id);
+    }
+    // Ensure the default standard is always present if it was missed
+    if (!restoredIds.has(PREDEFINED_STANDARDS.DUC)) {
+        restoredStandards.unshift(getDefaultStandard());
+    }
+    return restoredStandards;
+};
+// This would typically be defined in a central place with other default objects
+const getDefaultStandard = () => ({
+    id: PREDEFINED_STANDARDS.DUC,
+    name: "DUC",
+    version: "1.0.0",
+    readonly: true,
+    overrides: null,
+    styles: null,
+    viewSettings: null,
+    units: null,
+    validation: null,
+});
+const DEFAULT_STANDARDS = [
+    getDefaultStandard(),
+    // Potentially add other predefined standards here if they should always be present
+];
+/**
+ * Checks if a given id is present in the standards array.
+ * @returns true if found, false otherwise.
+ */
+export const isStandardIdPresent = (id, standards) => {
+    if (!Array.isArray(standards) || typeof id !== "string")
+        return false;
+    return standards.some(s => typeof s.id === "string" && s.id === id);
+};
+// --- Helper Functions for Restoration ---
+const restoreIdentifier = (ident) => {
+    if (!ident || typeof ident !== 'object' || !isValidString(ident.id)) {
+        return null;
+    }
+    return {
+        id: ident.id,
+        name: isValidString(ident.name, ident.id),
+        description: isValidString(ident.description) || undefined,
+    };
+};
+const restoreStandardUnits = (units, currentScope) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    if (!units || typeof units !== 'object')
+        return null;
+    const primary = units.primaryUnits;
+    const alternate = units.alternateUnits;
+    if (!primary || !alternate)
+        return null;
+    return {
+        primaryUnits: {
+            linear: {
+                format: isValidEnumValue((_a = primary.linear) === null || _a === void 0 ? void 0 : _a.format, DIMENSION_UNITS_FORMAT, DIMENSION_UNITS_FORMAT.DECIMAL),
+                system: isValidEnumValue((_b = primary.linear) === null || _b === void 0 ? void 0 : _b.system, UNIT_SYSTEM, UNIT_SYSTEM.METRIC),
+                precision: (_d = (_c = primary.linear) === null || _c === void 0 ? void 0 : _c.precision) !== null && _d !== void 0 ? _d : 2,
+                suppressLeadingZeros: isValidBoolean((_e = primary.linear) === null || _e === void 0 ? void 0 : _e.suppressLeadingZeros, false),
+                suppressTrailingZeros: isValidBoolean((_f = primary.linear) === null || _f === void 0 ? void 0 : _f.suppressTrailingZeros, false),
+                decimalSeparator: isValidEnumValue((_g = primary.linear) === null || _g === void 0 ? void 0 : _g.decimalSeparator, DECIMAL_SEPARATOR, DECIMAL_SEPARATOR.DOT),
+                suppressZeroFeet: isValidBoolean((_h = primary.linear) === null || _h === void 0 ? void 0 : _h.suppressZeroFeet, false),
+                suppressZeroInches: isValidBoolean((_j = primary.linear) === null || _j === void 0 ? void 0 : _j.suppressZeroInches, false),
+            },
+            angular: {
+                format: isValidEnumValue((_k = primary.angular) === null || _k === void 0 ? void 0 : _k.format, ANGULAR_UNITS_FORMAT, ANGULAR_UNITS_FORMAT.DECIMAL_DEGREES),
+                system: isValidEnumValue((_l = primary.angular) === null || _l === void 0 ? void 0 : _l.system, UNIT_SYSTEM, UNIT_SYSTEM.METRIC),
+                precision: (_o = (_m = primary.angular) === null || _m === void 0 ? void 0 : _m.precision) !== null && _o !== void 0 ? _o : 2,
+                suppressLeadingZeros: isValidBoolean((_p = primary.angular) === null || _p === void 0 ? void 0 : _p.suppressLeadingZeros, false),
+                suppressTrailingZeros: isValidBoolean((_q = primary.angular) === null || _q === void 0 ? void 0 : _q.suppressTrailingZeros, false),
+            },
+        },
+        alternateUnits: {
+            format: isValidEnumValue(alternate === null || alternate === void 0 ? void 0 : alternate.format, DIMENSION_UNITS_FORMAT, DIMENSION_UNITS_FORMAT.DECIMAL),
+            system: isValidEnumValue(alternate === null || alternate === void 0 ? void 0 : alternate.system, UNIT_SYSTEM, UNIT_SYSTEM.METRIC),
+            precision: (_r = alternate === null || alternate === void 0 ? void 0 : alternate.precision) !== null && _r !== void 0 ? _r : 2,
+            suppressLeadingZeros: isValidBoolean(alternate === null || alternate === void 0 ? void 0 : alternate.suppressLeadingZeros, false),
+            suppressTrailingZeros: isValidBoolean(alternate === null || alternate === void 0 ? void 0 : alternate.suppressTrailingZeros, false),
+            isVisible: isValidBoolean(alternate === null || alternate === void 0 ? void 0 : alternate.isVisible, false),
+            multiplier: typeof (alternate === null || alternate === void 0 ? void 0 : alternate.multiplier) === 'number' ? alternate.multiplier : 1,
+        }
+    };
+};
+const restoreStandardOverrides = (overrides, currentScope) => {
+    if (!overrides || typeof overrides !== 'object')
+        return null;
+    return {
+        mainScope: isValidEnumValue(overrides.mainScope, ScaleFactors, undefined),
+        elementsStrokeWidthOverride: overrides.elementsStrokeWidthOverride ? restorePrecisionValue(overrides.elementsStrokeWidthOverride, NEUTRAL_SCOPE, currentScope) : undefined,
+        commonStyleId: isValidString(overrides.commonStyleId) || undefined,
+        stackLikeStyleId: isValidString(overrides.stackLikeStyleId) || undefined,
+        textStyleId: isValidString(overrides.textStyleId) || undefined,
+        dimensionStyleId: isValidString(overrides.dimensionStyleId) || undefined,
+        leaderStyleId: isValidString(overrides.leaderStyleId) || undefined,
+        featureControlFrameStyleId: isValidString(overrides.featureControlFrameStyleId) || undefined,
+        tableStyleId: isValidString(overrides.tableStyleId) || undefined,
+        docStyleId: isValidString(overrides.docStyleId) || undefined,
+        viewportStyleId: isValidString(overrides.viewportStyleId) || undefined,
+        plotStyleId: isValidString(overrides.plotStyleId) || undefined,
+        hatchStyleId: isValidString(overrides.hatchStyleId) || undefined,
+        activeGridSettingsId: Array.isArray(overrides.activeGridSettingsId) ? overrides.activeGridSettingsId.map(String) : undefined,
+        activeSnapSettingsId: isValidString(overrides.activeSnapSettingsId) || undefined,
+        dashLineOverride: isValidString(overrides.dashLineOverride) || undefined,
+        unitPrecision: overrides.unitPrecision ? {
+            linear: typeof overrides.unitPrecision.linear === 'number' ? overrides.unitPrecision.linear : undefined,
+            angular: typeof overrides.unitPrecision.angular === 'number' ? overrides.unitPrecision.angular : undefined,
+            area: typeof overrides.unitPrecision.area === 'number' ? overrides.unitPrecision.area : undefined,
+            volume: typeof overrides.unitPrecision.volume === 'number' ? overrides.unitPrecision.volume : undefined,
+        } : undefined,
+    };
+};
+const restoreStandardStyles = (styles, currentScope) => {
+    if (!styles || typeof styles !== 'object')
+        return null;
+    // This is a simplified restoration. A full implementation would deeply restore each style object.
+    return {
+        commonStyles: styles.commonStyles || [],
+        stackLikeStyles: styles.stackLikeStyles || [],
+        textStyles: styles.textStyles || [],
+        dimensionStyles: styles.dimensionStyles || [],
+        leaderStyles: styles.leaderStyles || [],
+        featureControlFrameStyles: styles.featureControlFrameStyles || [],
+        tableStyles: styles.tableStyles || [],
+        docStyles: styles.docStyles || [],
+        viewportStyles: styles.viewportStyles || [],
+        hatchStyles: styles.hatchStyles || [],
+        xrayStyles: styles.xrayStyles || [],
+    };
+};
+const restoreGridSettings = (settings, currentScope) => {
+    if (!settings || typeof settings !== 'object')
+        return null;
+    const defaultGridStyle = { color: '#000000', opacity: 0.2, dashPattern: [] };
+    return {
+        type: isValidEnumValue(settings.type, GRID_TYPE, GRID_TYPE.RECTANGULAR),
+        readonly: isValidBoolean(settings.readonly, false),
+        displayType: isValidEnumValue(settings.displayType, GRID_DISPLAY_TYPE, GRID_DISPLAY_TYPE.LINES),
+        isAdaptive: isValidBoolean(settings.isAdaptive, true),
+        xSpacing: restorePrecisionValue(settings.xSpacing, NEUTRAL_SCOPE, currentScope, 100),
+        ySpacing: restorePrecisionValue(settings.ySpacing, NEUTRAL_SCOPE, currentScope, 100),
+        subdivisions: typeof settings.subdivisions === 'number' ? settings.subdivisions : 10,
+        origin: settings.origin || { x: 0, y: 0 },
+        rotation: isValidRadianValue(settings.rotation, 0),
+        followUCS: isValidBoolean(settings.followUCS, false),
+        majorStyle: settings.majorStyle || defaultGridStyle,
+        minorStyle: settings.minorStyle || defaultGridStyle,
+        showMinor: isValidBoolean(settings.showMinor, true),
+        minZoom: typeof settings.minZoom === 'number' ? settings.minZoom : 0.1,
+        maxZoom: typeof settings.maxZoom === 'number' ? settings.maxZoom : 100,
+        autoHide: isValidBoolean(settings.autoHide, true),
+        polarSettings: settings.polarSettings,
+        isometricSettings: settings.isometricSettings,
+        enableSnapping: isValidBoolean(settings.enableSnapping, true),
+    };
+};
+const restoreStandardViewSettings = (viewSettings, currentScope) => {
+    if (!viewSettings || typeof viewSettings !== 'object')
+        return null;
+    const restoredViews = (Array.isArray(viewSettings.views) ? viewSettings.views : [])
+        .map((v) => {
+        const identifier = restoreIdentifier(v);
+        // ... deep restore of DucView ...
+        return identifier ? Object.assign(Object.assign({}, identifier), v) : null; // simplified for now
+    }).filter(Boolean);
+    const restoredUcs = (Array.isArray(viewSettings.ucs) ? viewSettings.ucs : [])
+        .map((u) => {
+        const identifier = restoreIdentifier(u);
+        // ... deep restore of DucUcs ...
+        return identifier ? Object.assign(Object.assign({}, identifier), u) : null; // simplified for now
+    }).filter(Boolean);
+    const restoredGrids = (Array.isArray(viewSettings.gridSettings) ? viewSettings.gridSettings : [])
+        .map((g) => {
+        const identifier = restoreIdentifier(g);
+        const settings = restoreGridSettings(g, currentScope);
+        return (identifier && settings) ? Object.assign(Object.assign({}, identifier), settings) : null;
+    }).filter(Boolean);
+    const restoredSnaps = (Array.isArray(viewSettings.snapSettings) ? viewSettings.snapSettings : [])
+        .map((s) => {
+        const identifier = restoreIdentifier(s);
+        // ... deep restore of SnapSettings ...
+        return identifier ? Object.assign(Object.assign({}, identifier), s) : null; // simplified for now
+    }).filter(Boolean);
+    return {
+        views: restoredViews,
+        ucs: restoredUcs,
+        gridSettings: restoredGrids,
+        snapSettings: restoredSnaps,
+    };
+};
+const restoreStandardValidation = (validation, currentScope) => {
+    if (!validation || typeof validation !== 'object')
+        return null;
+    return {
+        dimensionRules: validation.dimensionRules ? {
+            minTextHeight: validation.dimensionRules.minTextHeight ? restorePrecisionValue(validation.dimensionRules.minTextHeight, NEUTRAL_SCOPE, currentScope) : undefined,
+            maxTextHeight: validation.dimensionRules.maxTextHeight ? restorePrecisionValue(validation.dimensionRules.maxTextHeight, NEUTRAL_SCOPE, currentScope) : undefined,
+            allowedPrecisions: Array.isArray(validation.dimensionRules.allowedPrecisions) ? validation.dimensionRules.allowedPrecisions.map(Number) : undefined,
+        } : undefined,
+        layerRules: validation.layerRules ? {
+            prohibitedLayerNames: Array.isArray(validation.layerRules.prohibitedLayerNames) ? validation.layerRules.prohibitedLayerNames.map(String) : undefined,
+        } : undefined,
+    };
+};

package/dist/serialize.d.ts

@@ -0,0 +1,3 @@
+import { ImportedDataState } from "ducjs/types";
+export declare const DUC_SCHEMA_VERSION: any;
+export declare const serializeDuc: (data: ImportedDataState, useScopedValues?: boolean, passThroughElementIds?: string[]) => Promise<Uint8Array>;