@toolpath/dfm 0.4.0 → 0.5.0

package/dist/model/index.js

@@ -1,8 +1,11 @@
 import {
   CRITICAL_COLOR,
   FILE_KIND,
+  ID_KINDS,
   LENGTH_PLACES,
+  MILLING_RULES,
   RULE_COLORS,
+  TURNING_RULES,
   TYPE_SUBJECT,
   WARNING_COLOR,
   breaks,
@@ -26,10 +29,12 @@ import {
   runStart,
   sameDepth,
   serializeRuleSet,
+  subjectInfo,
   trimmedCurve,
+  turnedTypeLabel,
   unitLabel,
   worseUpward
-} from "../chunk-5MPHT7BC.js";
+} from "../chunk-4IRNLDE6.js";
 
 // src/model/broken-rules.ts
 var byColor = (hits) => [...hits].sort((a, b) => compareColors(a.rule.color, b.rule.color));
@@ -41,12 +46,12 @@ var worstHits = (hits) => {
     return true;
   });
 };
-var brokenRules = (check, tag, units) => worstHits(check.hitsByTag.get(tag.toLowerCase()) ?? []).map((hit) => {
+var brokenRules = (check, tag, units, vocabulary = MILLING_RULES) => worstHits(check.hitsByTag.get(tag.toLowerCase()) ?? []).map((hit) => {
   const figure = hitFigure(hit, units);
   return {
     key: hit.rule.id,
     color: hit.rule.color,
-    text: describeRule(hit.rule, units),
+    text: describeRule(hit.rule, units, vocabulary),
     ...figure ? { figure } : {}
   };
 });
@@ -106,9 +111,9 @@ var featureIs = (subject, featureType, sheet) => {
       return false;
   }
 };
-var at = (record, path) => path.split(".").reduce(
+var at = (record2, path) => path.split(".").reduce(
   (value, key) => typeof value === "object" && value !== null ? value[key] : void 0,
-  record
+  record2
 );
 var readPath = (datasheet, metric) => {
   for (const path of metric.path ?? []) {
@@ -217,6 +222,22 @@ var requiredTags = (features) => {
     features.filter((feature) => feature.regionIdxs.some((region) => owners.get(region) === 1)).map((feature) => feature.tag.toLowerCase())
   );
 };
+var worstColor = (hits) => hits?.map((hit) => hit.rule.color).sort(compareColors)[0];
+var ruleResults = (rules, features, hitsByTag, required) => rules.map((rule) => {
+  const hits = features.flatMap((feature) => {
+    const tag = feature.tag.toLowerCase();
+    const hit = hitsByTag.get(tag)?.find((each) => each.rule.id === rule.id);
+    return hit ? [{ tag: feature.tag, value: hit.value, metric: hit.metric, required: required.has(tag) }] : [];
+  });
+  const [first] = hits;
+  const up = first ? worseUpward(rule, first.metric) : true;
+  hits.sort((a, b) => up ? b.value - a.value : a.value - b.value);
+  return {
+    rule,
+    tags: hits.filter((hit) => hit.required).map((hit) => hit.tag),
+    otherTags: hits.filter((hit) => !hit.required).map((hit) => hit.tag)
+  };
+});
 var QUALIFIERS = ["undercut", "filleted", "tslot", "dovetail"];
 var EDGE_TYPES = ["fillet", "chamfer", "sink"];
 var featureComplexity = (featureType) => {
@@ -226,7 +247,6 @@ var featureComplexity = (featureType) => {
 };
 var CONTOUR = "contour_surface";
 var unavoidableFaces = (features, hitsByTag, regionAreas) => {
-  const worstColor = (feature) => hitsByTag.get(feature.tag.toLowerCase())?.map((hit) => hit.rule.color).sort(compareColors)[0];
   const areaOf = (feature) => [...new Set(feature.regionIdxs)].reduce(
     (sum, region) => sum + (regionAreas.get(region) ?? 0),
     0
@@ -242,7 +262,7 @@ var unavoidableFaces = (features, hitsByTag, regionAreas) => {
   for (const [region, candidates] of owners) {
     const colored = candidates.map((feature) => ({
       feature,
-      color: worstColor(feature),
+      color: worstColor(hitsByTag.get(feature.tag.toLowerCase())),
       area: areaOf(feature)
     }));
     const isContour = ({ feature }) => feature.featureType === CONTOUR;
@@ -269,10 +289,10 @@ var unavoidableFaces = (features, hitsByTag, regionAreas) => {
 };
 var withSurroundedFaces = (check, features, adjacency) => {
   const paintedFor = new Map(check.paintedFaces);
-  const regionsOf = /* @__PURE__ */ new Map();
+  const regionsOf2 = /* @__PURE__ */ new Map();
   for (const feature of features) {
     const key = feature.tag.toLowerCase();
-    regionsOf.set(key, new Set(feature.regionIdxs));
+    regionsOf2.set(key, new Set(feature.regionIdxs));
     const whole = check.paintedWhole.get(key);
     if (whole) {
       for (const region of feature.regionIdxs)
@@ -290,7 +310,7 @@ var withSurroundedFaces = (check, features, adjacency) => {
       counts.set(key, { paint: paint2, count: (counts.get(key)?.count ?? 0) + 1 });
     }
     const most = Math.max(0, ...[...counts.values()].map(({ count }) => count));
-    const [paint] = [...counts].filter(([key, { count }]) => count === most && regionsOf.get(key)?.has(region)).map(([, { paint: paint2 }]) => paint2).sort((a, b) => compareColors(a.color, b.color));
+    const [paint] = [...counts].filter(([key, { count }]) => count === most && regionsOf2.get(key)?.has(region)).map(([, { paint: paint2 }]) => paint2).sort((a, b) => compareColors(a.color, b.color));
     if (paint) surrounded.set(region, paint);
   }
   if (surrounded.size === 0) return check;
@@ -304,25 +324,10 @@ var checkPart = (features, sources, rules) => {
       featureHits(features, feature, sources, rules)
     ])
   );
-  const byRule = rules.map((rule) => {
-    const hits = features.flatMap((feature) => {
-      const tag = feature.tag.toLowerCase();
-      const hit = hitsByTag.get(tag)?.find((each) => each.rule.id === rule.id);
-      return hit ? [{ tag: feature.tag, value: hit.value, metric: hit.metric, required: required.has(tag) }] : [];
-    });
-    const [first] = hits;
-    const up = first ? worseUpward(rule, first.metric) : true;
-    hits.sort((a, b) => up ? b.value - a.value : a.value - b.value);
-    return {
-      rule,
-      tags: hits.filter((hit) => hit.required).map((hit) => hit.tag),
-      otherTags: hits.filter((hit) => !hit.required).map((hit) => hit.tag)
-    };
-  });
   return {
     hitsByTag,
     required,
-    byRule,
+    byRule: ruleResults(rules, features, hitsByTag, required),
     ...unavoidableFaces(features, hitsByTag, sources.regionAreas)
   };
 };
@@ -715,8 +720,8 @@ var featureMeasurements = ({
   if (ld && top !== null && bottom !== void 0) {
     const across = ld.basis === "bore" ? `D = facts.diameter = ${mm(ld.across)}` : ld.basis === "pinch" ? `D = widest tool (the tightest pinch disc, tolerance taken out) = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""}` : `D = widest tool = 2 \xD7 inside corner radius = ${mm(ld.across)}${ld.atLeast ? " (at most, so L/D is at least)" : ""} (no pinch points reported)`;
     const ratioOf = (depth) => {
-      const ratio = (depth / ld.across).toFixed(3);
-      return ld.atLeast ? `\u2265 ${ratio}` : ratio;
+      const ratio2 = (depth / ld.across).toFixed(3);
+      return ld.atLeast ? `\u2265 ${ratio2}` : ratio2;
     };
     if (ld.drilling) {
       rows.push({
@@ -948,16 +953,16 @@ var undercutRows = (sheet, undercut, top, length) => {
     );
     if (top !== null && zMin !== void 0) {
       const reach = top - zMin;
-      const ratio = (reach / head).toFixed(3);
+      const ratio2 = (reach / head).toFixed(3);
       rows.push({
         key: "topLd",
         label: "L/D to top of part",
         milling: true,
-        value: ratio,
+        value: ratio2,
         derivation: [
           `L = depth below top of part = ${mm(reach)}`,
           `D = max cutting diameter = ${mm(head)}`,
-          `L / D = ${mm(reach)} / ${mm(head)} = ${ratio}`
+          `L / D = ${mm(reach)} / ${mm(head)} = ${ratio2}`
         ]
       });
     }
@@ -1208,14 +1213,217 @@ var placePinchTool = (mark, triangles, direction, origin = { x: 0, y: 0, z: 0 })
     across: asVec(across)
   };
 };
+
+// src/model/turned-check.ts
+var regionsOf = (feature) => Array.isArray(feature.regionIdxs) ? feature.regionIdxs : [];
+var stretchKey = (feature) => {
+  const regions = regionsOf(feature);
+  return regions.length === 0 ? `tag:${feature.featureTag}` : `${feature.featureType}:${[...regions].sort((a, b) => a - b).join(",")}`;
+};
+var isApproach = (value) => value === "PlusZ" || value === "MinusZ";
+var turnedStretches = (features) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const key = stretchKey(feature);
+    groups.set(key, [...groups.get(key) ?? [], feature]);
+  }
+  const merged = [...groups.values()].flatMap((copies) => {
+    const [first] = copies;
+    if (!first) return [];
+    const approaches = [...new Set(copies.map((each) => each.approach).filter(isApproach))];
+    const only = approaches.length === 1 ? approaches[0] : void 0;
+    const z = only === "PlusZ" ? 1 : only === "MinusZ" ? -1 : 0;
+    return [{ first, copies, approaches, machiningDirection: { x: 0, y: 0, z } }];
+  });
+  const numbered = dfmFeatures(
+    merged.map(({ first, machiningDirection }) => ({
+      featureTag: first.featureTag,
+      featureType: first.featureType,
+      machiningDirection,
+      regionIdxs: regionsOf(first)
+    }))
+  );
+  return merged.flatMap(({ copies, approaches }, at2) => {
+    const feature = numbered[at2];
+    return feature ? [{ ...feature, copies, approaches }] : [];
+  });
+};
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+var finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var ratio = (top, bottom) => top !== null && bottom !== null && bottom > 0 ? top / bottom : null;
+var narrowestStep = (facts) => {
+  const steps = Array.isArray(facts.steps) ? facts.steps : [];
+  const diameters = steps.map((step) => finite(record(step)?.diameter)).filter((each) => each !== null && each > 0);
+  return diameters.length > 0 ? Math.min(...diameters) : null;
+};
+var threadSpec = (facts, field) => finite(record(facts.threadSpec)?.[field]) ?? finite(record(record(facts.thread)?.threadSpec)?.[field]);
+var partEnds = (stretches) => {
+  const zs = stretches.flatMap(
+    (stretch) => stretch.copies.flatMap((copy) => {
+      const sheet = record(copy.datasheet);
+      return [finite(sheet?.zMin), finite(sheet?.zMax)].filter(
+        (each) => each !== null
+      );
+    })
+  );
+  return zs.length > 0 ? { low: Math.min(...zs), high: Math.max(...zs) } : null;
+};
+var turnedLd = (sheet, facts, kind, approach, ends) => {
+  if (kind === "AxialHole") return ratio(finite(facts.depth), narrowestStep(facts));
+  const inside = ID_KINDS;
+  if (!kind || !inside.includes(kind) || !ends || !approach) return null;
+  const zMin = finite(sheet.zMin);
+  const zMax = finite(sheet.zMax);
+  const reach = approach === "PlusZ" ? zMin === null ? null : ends.high - zMin : zMax === null ? null : zMax - ends.low;
+  const rMin = finite(sheet.rMin);
+  const bore = finite(sheet.entryDiameter) ?? (rMin === null ? null : 2 * rMin);
+  return ratio(reach, bore);
+};
+var HAIR = 1e-3;
+var FLAT_CONE = 179.5;
+var copyMeasure = (metric, copy, ends) => {
+  const sheet = record(copy.datasheet);
+  if (!sheet) return null;
+  const facts = record(sheet.facts) ?? {};
+  const kind = typeof facts.kind === "string" ? facts.kind : kindOfType(copy.featureType);
+  const kinds = metric.kinds;
+  if (kinds && !(kind && kinds.includes(kind))) return null;
+  const doubled = (value) => {
+    const radius = finite(value);
+    return radius === null ? null : 2 * radius;
+  };
+  switch (metric.key) {
+    case "maxDiameter":
+      return doubled(sheet.rMax);
+    case "minDiameter":
+      return doubled(sheet.rMin);
+    case "length": {
+      const zMin = finite(sheet.zMin);
+      const zMax = finite(sheet.zMax);
+      return zMin === null || zMax === null || zMax - zMin < HAIR ? null : zMax - zMin;
+    }
+    case "ld":
+      return turnedLd(sheet, facts, kind, copy.approach ?? null, ends);
+    case "grooveWidth":
+      return finite(facts.width);
+    case "grooveDepth":
+    case "threadDepth":
+    case "holeDepth":
+      return finite(facts.depth);
+    case "grooveAspect":
+      return ratio(finite(facts.depth), finite(facts.width));
+    case "threadPitch":
+      return finite(facts.pitch) ?? threadSpec(facts, "threadPitch");
+    case "threadDiameter":
+      return threadSpec(facts, "basicDiameter");
+    case "holeDiameter":
+      return narrowestStep(facts);
+    case "holeSteps":
+      return Array.isArray(facts.steps) ? facts.steps.length : null;
+    case "flatBottom": {
+      if (facts.bottom === void 0) return 0;
+      const cone = finite(record(facts.bottom)?.coneDeg);
+      return cone === null ? null : cone >= FLAT_CONE ? 1 : 0;
+    }
+    // Zero is a figure here: a sharp corner, which a "radius ≤" rule is most of all about.
+    case "cornerRadius":
+      return finite(sheet.minConcaveRadius);
+    case "sharpCorner": {
+      const radius = finite(sheet.minConcaveRadius);
+      return radius === null ? 0 : radius <= HAIR ? 1 : 0;
+    }
+    // Absent where nothing stands between the feature and its end: nothing to pass, so clean.
+    case "entryDiameter":
+      return finite(sheet.entryDiameter);
+    case "axialTool":
+      return typeof sheet.mounting === "string" ? sheet.mounting === "Axial" ? 1 : 0 : null;
+    case "tolerance":
+      return finite(record(sheet.toleranceBand)?.atolMax);
+    default:
+      return null;
+  }
+};
+var kindOfType = (featureType) => featureType.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+var stretchFacts = (stretch) => stretch.copies.map((copy) => record(record(copy.datasheet)?.facts)).find((each) => each !== void 0);
+var stretchIs = (subject, stretch) => {
+  const type = stretch.featureType.toLowerCase();
+  if (subject.startsWith(TYPE_SUBJECT)) return type === subject.slice(TYPE_SUBJECT.length);
+  const facts = stretchFacts(stretch);
+  const kind = typeof facts?.kind === "string" ? facts.kind : kindOfType(type);
+  const hole = kind === "AxialHole";
+  switch (subject) {
+    case "any":
+      return true;
+    case "thread":
+      return kind === "OdThread" || kind === "IdThread" || hole && record(facts?.thread) !== void 0;
+    case "throughHole":
+      return hole && facts?.through === true;
+    case "blindHole":
+      return hole && facts?.through === false;
+    case "threadedHole":
+      return hole && record(facts?.thread) !== void 0;
+    default: {
+      const kinds = subjectInfo(subject, TURNING_RULES)?.kinds;
+      return kinds !== void 0 && kinds.includes(kind);
+    }
+  }
+};
+var stretchHit = (stretch, rule, metric, ends) => {
+  if (metric.quantity === "presence") return { rule, metric, value: 1 };
+  const measured = stretch.copies.filter((copy) => record(copy.datasheet) !== void 0);
+  if (measured.length === 0) return null;
+  const values = [];
+  for (const copy of measured) {
+    const value2 = copyMeasure(metric, copy, ends);
+    if (value2 === null || !breaks(rule, metric.quantity, value2)) return null;
+    values.push(value2);
+  }
+  const value = worseUpward(rule, metric) ? Math.min(...values) : Math.max(...values);
+  return { rule, metric, value };
+};
+var checkTurnedPart = (stretches, rules) => {
+  const ends = partEnds(stretches);
+  const hitsByTag = new Map(
+    stretches.map((stretch) => [
+      stretch.tag.toLowerCase(),
+      rules.flatMap((rule) => {
+        const metric = metricInfo(rule.metric, TURNING_RULES);
+        if (!metric || !stretchIs(rule.subject, stretch)) return [];
+        const hit = stretchHit(stretch, rule, metric, ends);
+        return hit ? [hit] : [];
+      })
+    ])
+  );
+  const required = new Set(stretches.map((stretch) => stretch.tag.toLowerCase()));
+  const paintedFaces = /* @__PURE__ */ new Map();
+  for (const stretch of stretches) {
+    const color = worstColor(hitsByTag.get(stretch.tag.toLowerCase()));
+    if (!color) continue;
+    for (const region of stretch.regionIdxs) {
+      const painted = paintedFaces.get(region);
+      if (!painted || compareColors(color, painted.color) < 0)
+        paintedFaces.set(region, { tag: stretch.tag, color });
+    }
+  }
+  return {
+    hitsByTag,
+    required,
+    byRule: ruleResults(rules, stretches, hitsByTag, required),
+    paintedFaces,
+    paintedWhole: /* @__PURE__ */ new Map()
+  };
+};
 export {
   CRITICAL_COLOR,
   FILE_KIND,
+  MILLING_RULES,
   PINCH_TOOL_MM,
   RULE_COLORS,
+  TURNING_RULES,
   WARNING_COLOR,
   brokenRules,
   checkPart,
+  checkTurnedPart,
   compareColors,
   describeRule,
   dfmFeatures,
@@ -1242,5 +1450,7 @@ export {
   sameDepth,
   serializeRuleSet,
   trimmedCurve,
+  turnedStretches,
+  turnedTypeLabel,
   withSurroundedFaces
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolpath/dfm",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Toolpath DFM rules: the rule list, the rules and the part checker, and the feature panel",
   "license": "MIT",
   "engines": {
@@ -64,8 +64,8 @@
     "tsup": "8.5.1",
     "typescript": "5.9.3",
     "vitest": "4.1.10",
-    "@toolpath/ui": "^1.0.0",
-    "@toolpath/api": "^0.7.0"
+    "@toolpath/api": "^0.8.1",
+    "@toolpath/ui": "^1.0.0"
   },
   "scripts": {
     "build": "tsup src/index.ts src/model/index.ts --format esm --dts --clean --external react --external react-dom --external @toolpath/ui",