@constructorfleet/sketchforge-engine 1.19.0 → 1.21.0

package/dist/skfProject.js

@@ -8,6 +8,7 @@ import { canonicalizeShape } from "./workplaneShapes.js";
 import { importedShapeFromStl } from "./stlImport.js";
 import { importedShapeFromSvg } from "./svgImport.js";
 import { normalizeSnapGrid, normalizeWorkspaceSettings } from "./workplaneSettings.js";
+import { cadSketchRegions, cadSketchSweepPaths } from "./sketchCadProfile.js";
 export const SKF_SCHEMA_ID = "com.sketchforge.project";
 export const SKF_FORMAT_VERSION = 2;
 export const SKF_MINIMUM_READER_VERSION = 2;
@@ -30,7 +31,7 @@ const SHAPE_KINDS = new Set([
 ]);
 const LOFT_PROFILE_SHAPES = new Set(["Oval", "Rectangle", "Triangle", "Pentagon", "Hexagon"]);
 const FEATURE_TYPES = new Set([
-    "group", "boolean-subtraction", "boolean-intersection", "mirror", "sketch-extrusion", "sketch-revolve", "sketch-sweep", "fillet", "chamfer",
+    "group", "boolean-subtraction", "boolean-intersection", "mirror", "sketch-extrusion", "sketch-revolve", "sketch-sweep", "fillet", "chamfer", "face-draft",
 ]);
 function exactArrayBuffer(bytes) {
     return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
@@ -438,6 +439,9 @@ async function serializeShapeNode(shape, nodeId, nodes, builder, sourceAssetsByA
                 sketchRevolve: undefined,
                 sketchSourceId: undefined,
                 sketchSourceNodeId: undefined,
+                faceDraft: undefined,
+                faceDraftSourceFrame: undefined,
+                faceDraftSourceSegmentId: undefined,
                 sketchSourceOfObjectId: shape.id,
             },
         });
@@ -576,6 +580,19 @@ function activeProjectIndexes(state) {
             });
             previous = featureId;
         }
+        const faceDraft = node.definition.faceDraft;
+        if (faceDraft) {
+            const featureId = `feature/${safeNodeToken(node.nodeId)}/face-draft`;
+            features.push({
+                id: featureId,
+                type: "face-draft",
+                outputObjectId: node.objectId,
+                inputObjectIds: [node.objectId],
+                dependsOnFeatureIds: previous ? [previous] : [],
+                parameters: { ...faceDraft },
+            });
+            previous = featureId;
+        }
         const treatments = Array.isArray(node.definition.edgeTreatments) ? node.definition.edgeTreatments : [];
         treatments.forEach((treatment, index) => {
             const type = treatment.kind === "fillet" ? "fillet" : "chamfer";
@@ -866,12 +883,19 @@ function validateSketchProfile(value, label) {
                 throw new LocalizedError("errors.skf.fieldInvalid", { label: `${constraintLabel}.id` });
             constraintIds.add(id);
             const kind = stringValue(constraint.kind, `${constraintLabel}.kind`);
-            if (kind === "horizontal" || kind === "vertical") {
+            if (kind === "fixed") {
+                const pointId = stringValue(constraint.pointId, `${constraintLabel}.pointId`);
+                if (!pointIds.has(pointId))
+                    throw new LocalizedError("errors.skf.fieldInvalid", { label: `${constraintLabel}.pointId` });
+                finiteNumber(constraint.xMm, `${constraintLabel}.xMm`);
+                finiteNumber(constraint.zMm, `${constraintLabel}.zMm`);
+            }
+            else if (kind === "horizontal" || kind === "vertical") {
                 if (!segmentIds.has(stringValue(constraint.segmentId, `${constraintLabel}.segmentId`))) {
                     throw new LocalizedError("errors.skf.fieldInvalid", { label: `${constraintLabel}.segmentId` });
                 }
             }
-            else if (kind === "perpendicular") {
+            else if (kind === "perpendicular" || kind === "parallel") {
                 if (!Array.isArray(constraint.segmentIds) || constraint.segmentIds.length !== 2 || constraint.segmentIds[0] === constraint.segmentIds[1] || !constraint.segmentIds.every((segmentId) => typeof segmentId === "string" && segmentIds.has(segmentId))) {
                     throw new LocalizedError("errors.skf.fieldInvalid", { label: `${constraintLabel}.segmentIds` });
                 }
@@ -890,7 +914,7 @@ function validateSketchProfile(value, label) {
         });
     }
 }
-function validateShapeDefinition(definition, label) {
+function validateShapeDefinition(definition, label, options = {}) {
     const id = stringValue(definition.id, `${label}.id`);
     stringValue(definition.name, `${label}.name`);
     const kind = stringValue(definition.kind, `${label}.kind`);
@@ -919,13 +943,13 @@ function validateShapeDefinition(definition, label) {
     if (definition.faceColors !== undefined) {
         const colors = objectRecord(definition.faceColors, `${label}.faceColors`);
         for (const [faceId, color] of Object.entries(colors)) {
-            if (!(/^(?:\d+|face_.+)$/.test(faceId)) || typeof color !== "string" || !/^#[0-9a-fA-F]{6}(?:[0-9a-fA-F]{2})?$/.test(color)) {
+            if (!faceId.trim() || typeof color !== "string" || !/^#[0-9a-fA-F]{6}(?:[0-9a-fA-F]{2})?$/.test(color)) {
                 throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceColors.${faceId}` });
             }
         }
     }
     if (definition.faceIds !== undefined && (!Array.isArray(definition.faceIds)
-        || definition.faceIds.some((faceId) => typeof faceId !== "string" || !faceId.startsWith("face_"))
+        || definition.faceIds.some((faceId) => typeof faceId !== "string" || !faceId.trim())
         || new Set(definition.faceIds).size !== definition.faceIds.length)) {
         throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceIds` });
     }
@@ -960,6 +984,178 @@ function validateShapeDefinition(definition, label) {
                 finiteNumber(settings[field], `${label}.sketchRevolve.${field}`);
         });
     }
+    if (definition.faceDraft !== undefined) {
+        const draft = objectRecord(definition.faceDraft, `${label}.faceDraft`);
+        const revolveSettings = definition.sketchRevolve && typeof definition.sketchRevolve === "object" && !Array.isArray(definition.sketchRevolve)
+            ? definition.sketchRevolve
+            : undefined;
+        const plainFullTurnRevolve = definition.sketchOperation === "revolve" && revolveSettings
+            && typeof revolveSettings.sweepAngle === "number"
+            && Math.abs(Math.abs(revolveSettings.sweepAngle) - 360) <= 1e-6
+            && (revolveSettings.pitch === undefined || revolveSettings.pitch === 0)
+            && (revolveSettings.coreRadius === undefined || revolveSettings.coreRadius === 0);
+        const treatments = Array.isArray(definition.edgeTreatments) ? definition.edgeTreatments : [];
+        const treatment = treatments[0] && typeof treatments[0] === "object" && !Array.isArray(treatments[0])
+            ? treatments[0]
+            : undefined;
+        const history = options.edgeTreatmentHistory ?? [];
+        const historyFeature = history[0]?.feature;
+        const isPersistedRevolveDraftTreatment = Boolean(plainFullTurnRevolve
+            && definition.sketchProfile !== undefined
+            && cadSketchRegions(definition.sketchProfile).length === 1
+            && definition.draftPrismAngle === undefined
+            && treatments.length === 1
+            && (treatment?.kind === "chamfer" || treatment?.kind === "fillet")
+            && treatment.allEdges === true
+            && treatment.edges === undefined
+            && (treatment.kind === "fillet"
+                || typeof treatment.chamferAngle === "number" && Math.abs(treatment.chamferAngle - 45) < 0.001)
+            && typeof treatment.amount === "number"
+            && Number.isFinite(treatment.amount)
+            && treatment.amount > 0
+            && Number.isInteger(treatment.edgeCount)
+            && treatment.edgeCount > 0
+            && history.length === 1
+            && historyFeature?.kind === treatment.kind
+            && historyFeature.allEdges === treatment.allEdges
+            && (treatment.kind === "fillet" || historyFeature.chamferAngle === treatment.chamferAngle)
+            && historyFeature.amount === treatment.amount
+            && historyFeature.edgeCount === treatment.edgeCount);
+        const extrusionRegions = definition.sketchOperation === "extrude" && definition.sketchProfile !== undefined
+            ? cadSketchRegions(definition.sketchProfile)
+            : [];
+        const isPersistedExtrusionDraftTreatment = Boolean(definition.sketchOperation === "extrude"
+            && extrusionRegions.length === 1
+            && extrusionRegions[0]?.holes.length === 0
+            && definition.draftPrismAngle === undefined
+            && treatments.length === 1
+            && (treatment?.kind === "fillet" || treatment?.kind === "chamfer")
+            && treatment.allEdges === true
+            && treatment.edges === undefined
+            && (treatment.kind === "fillet"
+                || typeof treatment.chamferAngle === "number" && Math.abs(treatment.chamferAngle - 45) < 0.001)
+            && typeof treatment.amount === "number"
+            && Number.isFinite(treatment.amount)
+            && treatment.amount > 0
+            && Number.isInteger(treatment.edgeCount)
+            && treatment.edgeCount > 0
+            && history.length === 1
+            && historyFeature?.kind === treatment.kind
+            && historyFeature.allEdges === true
+            && (treatment.kind === "fillet" || historyFeature.chamferAngle === treatment.chamferAngle)
+            && historyFeature.amount === treatment.amount
+            && historyFeature.edgeCount === treatment.edgeCount);
+        let isPersistedSweepDraftTreatment = false;
+        if (definition.sketchOperation === "sweep" && definition.sketchProfile !== undefined) {
+            try {
+                const { sections, spine } = cadSketchSweepPaths(definition.sketchProfile);
+                isPersistedSweepDraftTreatment = Boolean(sections.length === 1
+                    && sections[0]?.holes.length === 0
+                    && spine.steps.length > 0
+                    && definition.draftPrismAngle === undefined
+                    && treatments.length === 1
+                    && (treatment?.kind === "fillet" || treatment?.kind === "chamfer")
+                    && treatment.allEdges === true
+                    && treatment.edges === undefined
+                    && (treatment.kind === "fillet"
+                        || typeof treatment.chamferAngle === "number" && Math.abs(treatment.chamferAngle - 45) < 0.001)
+                    && typeof treatment.amount === "number"
+                    && Number.isFinite(treatment.amount)
+                    && treatment.amount > 0
+                    && Number.isInteger(treatment.edgeCount)
+                    && treatment.edgeCount > 0
+                    && history.length === 1
+                    && historyFeature?.kind === treatment.kind
+                    && historyFeature.allEdges === true
+                    && (treatment.kind === "fillet" || historyFeature.chamferAngle === treatment.chamferAngle)
+                    && historyFeature.amount === treatment.amount
+                    && historyFeature.edgeCount === treatment.edgeCount);
+            }
+            catch {
+                isPersistedSweepDraftTreatment = false;
+            }
+        }
+        if (kind !== "mesh"
+            || (definition.sketchOperation !== "extrude" && definition.sketchOperation !== "sweep" && !plainFullTurnRevolve)
+            || definition.sketchProfile === undefined
+            || plainFullTurnRevolve && cadSketchRegions(definition.sketchProfile).length !== 1
+            || definition.sketchSourceId === undefined
+            || definition.draftPrismAngle !== undefined
+            || (treatments.length > 0 || options.hasEdgeTreatmentHistory)
+                && !isPersistedRevolveDraftTreatment && !isPersistedExtrusionDraftTreatment && !isPersistedSweepDraftTreatment) {
+            throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraft` });
+        }
+        const sourceFaceId = stringValue(draft.sourceFaceId, `${label}.faceDraft.sourceFaceId`);
+        if (!sourceFaceId.trim())
+            throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraft.sourceFaceId` });
+        const angle = finiteNumber(draft.angle, `${label}.faceDraft.angle`);
+        if (angle === 0 || Math.abs(angle) >= 45)
+            throw new LocalizedError("errors.skf.outOfRange", { label: `${label}.faceDraft.angle` });
+        if (!["x", "y", "z", "-x", "-y", "-z"].includes(draft.pullDirection)) {
+            throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraft.pullDirection` });
+        }
+        const normal = objectRecord(draft.sourceFaceNormal, `${label}.faceDraft.sourceFaceNormal`);
+        const coordinates = ["x", "y", "z"].map((axis) => finiteNumber(normal[axis], `${label}.faceDraft.sourceFaceNormal.${axis}`));
+        const magnitude = Math.hypot(...coordinates);
+        if (Math.abs(magnitude - 1) > 1e-4)
+            throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraft.sourceFaceNormal` });
+    }
+    if (definition.faceDraftSourceFrame !== undefined) {
+        const frame = objectRecord(definition.faceDraftSourceFrame, `${label}.faceDraftSourceFrame`);
+        ["x", "z", "elevation", "width", "depth", "height"].forEach((field) => finiteNumber(frame[field], `${label}.faceDraftSourceFrame.${field}`));
+        if (["width", "depth", "height"].some((field) => frame[field] <= 0)) {
+            throw new LocalizedError("errors.skf.nonPositiveDimensions", { label: `${label}.faceDraftSourceFrame` });
+        }
+    }
+    if (definition.faceDraftSourceScale !== undefined) {
+        const scale = objectRecord(definition.faceDraftSourceScale, `${label}.faceDraftSourceScale`);
+        ["width", "depth", "height"].forEach((field) => {
+            if (finiteNumber(scale[field], `${label}.faceDraftSourceScale.${field}`) <= 0) {
+                throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraftSourceScale.${field}` });
+            }
+        });
+    }
+    if (definition.faceDraftSourceFaceIds !== undefined) {
+        if (!Array.isArray(definition.faceDraftSourceFaceIds) || definition.faceDraftSourceFaceIds.length === 0) {
+            throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraftSourceFaceIds` });
+        }
+        const sourceFaceIds = definition.faceDraftSourceFaceIds.map((id, index) => stringValue(id, `${label}.faceDraftSourceFaceIds[${index}]`));
+        if (sourceFaceIds.some((id) => !id.trim()) || new Set(sourceFaceIds).size !== sourceFaceIds.length
+            || typeof definition.faceDraft === "object" && definition.faceDraft !== null
+                && !sourceFaceIds.includes(definition.faceDraft.sourceFaceId)) {
+            throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraftSourceFaceIds` });
+        }
+    }
+    if (definition.faceDraftSourceSegmentId !== undefined) {
+        const sourceSegmentId = stringValue(definition.faceDraftSourceSegmentId, `${label}.faceDraftSourceSegmentId`);
+        const profile = definition.sketchProfile;
+        let regions = [];
+        try {
+            if (profile)
+                regions = cadSketchRegions(profile);
+        }
+        catch {
+            regions = [];
+        }
+        const segments = profile?.segments ?? [];
+        const pointsById = new Map(profile?.points.map((point) => [point.id, point]) ?? []);
+        const sourceSegmentMatches = segments.filter((segment) => segment.id === sourceSegmentId);
+        const containsBezier = segments.some((segment) => {
+            if (segment.kind !== undefined && segment.kind !== "line")
+                return true;
+            if (segment.kind !== undefined)
+                return false;
+            const start = pointsById.get(segment.startId);
+            const end = pointsById.get(segment.endId);
+            return Boolean(start && end && ((start.handleOut && end.handleIn) || (start.handleIn && end.handleOut)));
+        });
+        if (!sourceSegmentId.trim() || kind !== "mesh" || definition.sketchOperation !== "extrude"
+            || definition.faceDraft === undefined || !profile || regions.length !== 1 || regions[0]?.holes.length !== 0
+            || regions[0]?.outer.steps.length !== segments.length || containsBezier
+            || sourceSegmentMatches.length !== 1) {
+            throw new LocalizedError("errors.skf.fieldInvalid", { label: `${label}.faceDraftSourceSegmentId` });
+        }
+    }
     if (kind === "gear") {
         const teeth = finiteNumber(definition.teeth, `${label}.teeth`);
         if (!Number.isInteger(teeth) || teeth < 6 || teeth > 64)
@@ -1128,7 +1324,10 @@ async function validateDocumentAndAssets(raw, files) {
             if (nodeById.has(nodeId))
                 throw new LocalizedError("errors.skf.stateDuplicateNodeId", { state: stateId, id: nodeId });
             const definition = objectRecord(node.definition, `node '${nodeId}'.definition`);
-            const objectId = validateShapeDefinition(definition, `node '${nodeId}'`);
+            const objectId = validateShapeDefinition(definition, `node '${nodeId}'`, {
+                hasEdgeTreatmentHistory: Boolean(node.edgeTreatmentHistory?.length),
+                edgeTreatmentHistory: node.edgeTreatmentHistory,
+            });
             if (node.objectId !== objectId)
                 throw new LocalizedError("errors.skf.nodeObjectIdMismatch", { id: nodeId });
             if (node.importedMesh) {
@@ -1461,7 +1660,10 @@ function validateLegacyRuntimeShape(shape, label) {
     delete definition.groupedShapes;
     delete definition.edgeTreatmentHistory;
     delete definition.cadBrep;
-    validateShapeDefinition(definition, label);
+    validateShapeDefinition(definition, label, {
+        hasEdgeTreatmentHistory: Array.isArray(edgeHistory) && edgeHistory.length > 0,
+        edgeTreatmentHistory: Array.isArray(edgeHistory) ? edgeHistory : undefined,
+    });
     if (importedMesh) {
         const mesh = objectRecord(importedMesh, `${label}.importedMesh`);
         if (!Array.isArray(mesh.positions) || mesh.positions.length > SKF_LIMITS.meshNumbers || mesh.positions.some((value) => typeof value !== "number" || !Number.isFinite(value))) {