@constructorfleet/sketchforge-engine 1.20.0 → 1.22.0

package/dist/skfProject.js

@@ -8,7 +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 } from "./sketchCadProfile.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;
@@ -441,6 +441,7 @@ async function serializeShapeNode(shape, nodeId, nodes, builder, sourceAssetsByA
                 sketchSourceNodeId: undefined,
                 faceDraft: undefined,
                 faceDraftSourceFrame: undefined,
+                faceDraftSourceSegmentId: undefined,
                 sketchSourceOfObjectId: shape.id,
             },
         });
@@ -579,33 +580,33 @@ function activeProjectIndexes(state) {
             });
             previous = featureId;
         }
-        const treatments = Array.isArray(node.definition.edgeTreatments) ? node.definition.edgeTreatments : [];
-        treatments.forEach((treatment, index) => {
-            const type = treatment.kind === "fillet" ? "fillet" : "chamfer";
-            const featureId = `feature/${safeNodeToken(node.nodeId)}/${type}/${index}`;
+        const faceDraft = node.definition.faceDraft;
+        if (faceDraft) {
+            const featureId = `feature/${safeNodeToken(node.nodeId)}/face-draft`;
             features.push({
                 id: featureId,
-                type,
+                type: "face-draft",
                 outputObjectId: node.objectId,
                 inputObjectIds: [node.objectId],
                 dependsOnFeatureIds: previous ? [previous] : [],
-                parameters: { ...treatment },
+                parameters: { ...faceDraft },
             });
             previous = featureId;
-        });
-        const faceDraft = node.definition.faceDraft;
-        if (faceDraft) {
-            const featureId = `feature/${safeNodeToken(node.nodeId)}/face-draft`;
+        }
+        const treatments = Array.isArray(node.definition.edgeTreatments) ? node.definition.edgeTreatments : [];
+        treatments.forEach((treatment, index) => {
+            const type = treatment.kind === "fillet" ? "fillet" : "chamfer";
+            const featureId = `feature/${safeNodeToken(node.nodeId)}/${type}/${index}`;
             features.push({
                 id: featureId,
-                type: "face-draft",
+                type,
                 outputObjectId: node.objectId,
                 inputObjectIds: [node.objectId],
                 dependsOnFeatureIds: previous ? [previous] : [],
-                parameters: { ...faceDraft },
+                parameters: { ...treatment },
             });
             previous = featureId;
-        }
+        });
         if (node.definition.mirrorX || node.definition.mirrorY || node.definition.mirrorZ) {
             const featureId = `feature/${safeNodeToken(node.nodeId)}/mirror`;
             features.push({
@@ -993,14 +994,95 @@ function validateShapeDefinition(definition, label, options = {}) {
             && 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
-            || (Array.isArray(definition.edgeTreatments) && definition.edgeTreatments.length > 0)
-            || options.hasEdgeTreatmentHistory) {
+            || (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`);
@@ -1033,6 +1115,47 @@ function validateShapeDefinition(definition, label, options = {}) {
             }
         });
     }
+    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)
@@ -1203,6 +1326,7 @@ async function validateDocumentAndAssets(raw, files) {
             const definition = objectRecord(node.definition, `node '${nodeId}'.definition`);
             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 });
@@ -1538,6 +1662,7 @@ function validateLegacyRuntimeShape(shape, label) {
     delete definition.cadBrep;
     validateShapeDefinition(definition, label, {
         hasEdgeTreatmentHistory: Array.isArray(edgeHistory) && edgeHistory.length > 0,
+        edgeTreatmentHistory: Array.isArray(edgeHistory) ? edgeHistory : undefined,
     });
     if (importedMesh) {
         const mesh = objectRecord(importedMesh, `${label}.importedMesh`);