@toolpath/tool-drawing 0.1.0 → 0.2.0

package/README.md

@@ -45,6 +45,30 @@ chamfer. Where a number has to be assumed to draw at all — a drill point angle
 the vendor never published — the segment says so in its `provenance`, and a
 renderer is expected to show it.
 
+## Two kinds of holder
+
+`holder` is a union, and the two members are different inputs rather than two
+grades of one:
+
+```ts
+// What a vendor's table states: a nose, a body, a flange.
+holder: { noseDiameter: 28, noseLength: null, gaugeLength: 50, /* … */ }
+
+// What the vendor's own CAD model measures: the silhouette, `[z, r]` in mm.
+holder: { points: [[-48.4, 16], /* … */ [60, 8.5]], datum: 'gage-line', /* … */ }
+```
+
+A measured profile is **not** projected onto the parametric fields — the
+V-flange groove and the thread relief are the reason to measure at all, and a
+nose diameter and a body length cannot carry them. It is drawn as measured,
+vertex for vertex, with its nose face at the stickout. `isHolderProfile`
+narrows the union for an adapter that holds both.
+
+On a `gage-line` profile the drawing splits at `z = 0` — the spindle face — so
+everything above it is shaded as the spindle connection, exactly as the
+parametric flange is. A `nose`-datumed profile has no spindle face to split on
+and no gauge length to state, and the note under the drawing says so.
+
 `geometry` keys are the scraper's own field names (`DC`, `SFDM`, `OAL`, `LCF`,
 `RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length`). They are not
 renamed here: a translation table between two vocabularies is where an `SFDM`
@@ -80,7 +104,6 @@ unit a shop reads in is the application's.
 
 ```tsx
 import { ClearanceOverlay, tightestGaps, describeGaps } from '@toolpath/tool-drawing/clearance'
-
 ;<ToolDrawing assembly={assembly} collisions={collisions} verdict={{ clears, note }}>
   <ClearanceOverlay
     profile={profile}

package/dist/{chunk-OUMNS4RI.js → chunk-UBENO6GN.js}

@@ -1,3 +1,6 @@
+// src/model/types.ts
+var isHolderProfile = (holder) => "points" in holder;
+
 // src/model/outline.ts
 var EPSILON = 1e-6;
 var stated = (tool, code) => tool.provenance?.[code] ?? "vendor-stated";
@@ -96,6 +99,93 @@ var tip = (tool, LCF) => {
       return null;
   }
 };
+var profileSegments = (holder, stickout) => {
+  const nose = holder.points[holder.points.length - 1];
+  if (holder.points.length < 2 || nose === void 0) {
+    return [];
+  }
+  const provenance = holder.provenance?.["points"] ?? "vendor-stated";
+  const gage = stickout + nose[0];
+  const up = [...holder.points].reverse().map(([z, r]) => ({ r, z: stickout + (nose[0] - z) }));
+  const cut = holder.datum === "gage-line" ? up.findIndex((point) => point.z > gage) : -1;
+  if (cut <= 0) {
+    return [{ part: "body", points: up, provenance }];
+  }
+  const below = up.slice(0, cut);
+  const above = up.slice(cut);
+  const last = below[below.length - 1];
+  const first = above[0];
+  const meet = last.z === gage ? last : {
+    r: last.r + (gage - last.z) / (first.z - last.z) * (first.r - last.r),
+    z: gage
+  };
+  if (meet !== last) {
+    below.push(meet);
+  }
+  above.unshift(meet);
+  return [
+    { part: "body", points: below, provenance },
+    { part: "flange", points: above, provenance }
+  ];
+};
+var parametricSegments = (holder, stickout, DC) => {
+  if (holder.noseDiameter === null) {
+    return [];
+  }
+  const segments = [];
+  const rh = holder.noseDiameter / 2;
+  const holderStated = (code) => holder.provenance?.[code] ?? "vendor-stated";
+  let top = stickout;
+  const noseLength = holder.noseLength ?? holder.gaugeLength ?? Math.max(20, DC * 3);
+  segments.push({
+    part: "nose",
+    points: [
+      { r: rh, z: stickout },
+      { r: rh, z: stickout + noseLength }
+    ],
+    provenance: holder.noseLength !== null ? holderStated("noseLength") : holder.gaugeLength === null ? "assumed" : holderStated("noseDiameter")
+  });
+  top = stickout + noseLength;
+  let radius = rh;
+  if (holder.bodyDiameter !== null && holder.bodyLength !== null) {
+    const rb = holder.bodyDiameter / 2;
+    segments.push({
+      part: "body",
+      points: [
+        { r: rb, z: top },
+        { r: rb, z: top + holder.bodyLength }
+      ],
+      provenance: holderStated("bodyDiameter")
+    });
+    top += holder.bodyLength;
+    radius = rb;
+  }
+  if (holder.projection !== null && holder.flangeDiameter !== null) {
+    const flangeAt = stickout + holder.projection;
+    const rf = holder.flangeDiameter / 2;
+    if (flangeAt > top) {
+      segments.push({
+        part: "body",
+        points: [
+          { r: radius, z: top },
+          { r: radius, z: flangeAt }
+        ],
+        provenance: "assumed"
+      });
+    }
+    const flangeTop = holder.gaugeLength !== null && holder.gaugeLength > holder.projection ? stickout + holder.gaugeLength : flangeAt + 20;
+    segments.push({
+      part: "flange",
+      points: [
+        { r: rf, z: flangeAt },
+        { r: rf, z: flangeTop }
+      ],
+      provenance: holder.gaugeLength === null ? "assumed" : holderStated("flangeDiameter")
+    });
+    top = flangeTop;
+  }
+  return segments;
+};
 var assemblyOutline = (assembly) => {
   const { tool, holder, stickout } = assembly;
   const { DC, LCF, SFDM } = tool.geometry;
@@ -151,9 +241,8 @@ var assemblyOutline = (assembly) => {
     });
     top = shankTop;
   }
-  if (stickout !== null && holder !== null && holder.noseDiameter !== null) {
-    const rh = holder.noseDiameter / 2;
-    const holderStated = (code) => holder.provenance?.[code] ?? "vendor-stated";
+  const holderSegments = stickout === null || holder === null ? [] : isHolderProfile(holder) ? profileSegments(holder, stickout) : parametricSegments(holder, stickout, DC);
+  if (stickout !== null && holder !== null && holderSegments.length > 0) {
     const series = /(\d+(?:\.\d+)?)/.exec(holder.colletSeries ?? "");
     if (holder.colletProtrusion !== null && series) {
       const rc = Number(series[1]) / 2;
@@ -163,63 +252,18 @@ var assemblyOutline = (assembly) => {
           { r: rc, z: stickout - holder.colletProtrusion },
           { r: rc, z: stickout }
         ],
-        provenance: holderStated("colletProtrusion")
-      });
-    }
-    const noseLength = holder.noseLength ?? holder.gaugeLength ?? Math.max(20, DC * 3);
-    segments.push({
-      part: "nose",
-      points: [
-        { r: rh, z: stickout },
-        { r: rh, z: stickout + noseLength }
-      ],
-      provenance: holder.noseLength !== null ? holderStated("noseLength") : holder.gaugeLength === null ? "assumed" : holderStated("noseDiameter")
-    });
-    top = stickout + noseLength;
-    let radius2 = rh;
-    if (holder.bodyDiameter !== null && holder.bodyLength !== null) {
-      const rb = holder.bodyDiameter / 2;
-      segments.push({
-        part: "body",
-        points: [
-          { r: rb, z: top },
-          { r: rb, z: top + holder.bodyLength }
-        ],
-        provenance: holderStated("bodyDiameter")
-      });
-      top += holder.bodyLength;
-      radius2 = rb;
-    }
-    if (holder.projection !== null && holder.flangeDiameter !== null) {
-      const flangeAt = stickout + holder.projection;
-      const rf = holder.flangeDiameter / 2;
-      if (flangeAt > top) {
-        segments.push({
-          part: "body",
-          points: [
-            { r: radius2, z: top },
-            { r: radius2, z: flangeAt }
-          ],
-          provenance: "assumed"
-        });
-      }
-      const flangeTop = holder.gaugeLength !== null && holder.gaugeLength > holder.projection ? stickout + holder.gaugeLength : flangeAt + 20;
-      segments.push({
-        part: "flange",
-        points: [
-          { r: rf, z: flangeAt },
-          { r: rf, z: flangeTop }
-        ],
-        provenance: holder.gaugeLength === null ? "assumed" : holderStated("flangeDiameter")
+        provenance: holder.provenance?.["colletProtrusion"] ?? "vendor-stated"
       });
-      top = flangeTop;
     }
+    segments.push(...holderSegments);
+    top = holderSegments[holderSegments.length - 1].points.at(-1)?.z ?? top;
   }
   const radius = Math.max(...segments.flatMap((segment) => segment.points.map((point2) => point2.r)));
   return { segments, height: top, radius };
 };
 
 export {
+  isHolderProfile,
   hasNeck,
   assemblyOutline
 };

package/dist/geometry/index.d.ts

@@ -36,9 +36,65 @@ interface ViewerHolder {
     readonly colletProtrusion: number | null;
     readonly provenance?: Readonly<Record<string, Provenance>>;
 }
+/**
+ * A holder as its own CAD model measures it: the silhouette, and nothing
+ * parametric.
+ *
+ * A {@link ViewerHolder} is a handful of numbers a vendor publishes in a table,
+ * and a drawing built from them is a stylised holder. This is the other thing a
+ * catalog can have — the envelope measured off the vendor's STEP model, a
+ * hundred-odd vertices carrying the V-flange groove and the thread relief that
+ * a machinist actually looks for. **It is not a refinement of the parametric
+ * form and does not project onto it**: reducing it to a nose and a body throws
+ * away the only reason to measure.
+ *
+ * So the two are a union rather than one shape with optional extras, and
+ * {@link isHolderProfile} tells them apart. A consumer that has both picks one;
+ * a consumer that has neither passes `null` and the tool is drawn alone.
+ */
+interface ViewerHolderProfile {
+    /**
+     * The silhouette as `[z, r]` in millimetres, `z` ascending.
+     *
+     * Two vertices share a `z` where the solid steps, so this is a polyline and
+     * not a function of `z`. Fewer than two vertices is no holder and draws none.
+     */
+    readonly points: ReadonlyArray<readonly [z: number, r: number]>;
+    /**
+     * What `z = 0` means.
+     *
+     * `gage-line` is the spindle face, with `z` increasing toward the cutting end
+     * — so the taper is negative, the nose positive, and the holder's gauge
+     * length is the last vertex's `z`. `nose` is the frame a holder with no taper
+     * to solve a gauge plane on is measured in, and it is stated rather than
+     * silently referenced to an arbitrary end: there is no gauge length to read
+     * off it, and the drawing says so instead of printing one.
+     */
+    readonly datum: 'gage-line' | 'nose';
+    /** The series the holder takes, as {@link ViewerHolder} means it. */
+    readonly colletSeries: string | null;
+    /** How far the seated collet stands proud of the nose, in millimetres. */
+    readonly colletProtrusion: number | null;
+    /**
+     * Keyed as {@link ViewerHolder}'s is, plus `points` for the measurement
+     * itself — which is `vendor-stated` unless a caller says otherwise, because
+     * the shape measured is the vendor's own model rather than a derivation from
+     * its table.
+     */
+    readonly provenance?: Readonly<Record<string, Provenance>>;
+}
+/**
+ * Which of the two holder forms this is.
+ *
+ * On the presence of `points` rather than on a `kind` tag, because a tag would
+ * have to be added to {@link ViewerHolder} as well and every existing adapter
+ * would stop compiling to gain nothing a structural check does not already
+ * give.
+ */
+declare const isHolderProfile: (holder: ViewerHolder | ViewerHolderProfile) => holder is ViewerHolderProfile;
 interface ViewerAssembly {
     readonly tool: ViewerTool;
-    readonly holder: ViewerHolder | null;
+    readonly holder: ViewerHolder | ViewerHolderProfile | null;
     /**
      * How far the tool stands out of the holder nose, in millimetres — the
      * shop's number, nobody's else. Null draws the tool alone.
@@ -99,4 +155,4 @@ interface Outline {
  */
 declare const assemblyOutline: (assembly: ViewerAssembly) => Outline | null;
 
-export { type Outline, type OutlinePart, type OutlinePoint, type OutlineSegment, type Provenance, type ViewerAssembly, type ViewerHolder, type ViewerTool, assemblyOutline };
+export { type Outline, type OutlinePart, type OutlinePoint, type OutlineSegment, type Provenance, type ViewerAssembly, type ViewerHolder, type ViewerHolderProfile, type ViewerTool, assemblyOutline, isHolderProfile };

package/dist/geometry/index.js

@@ -1,6 +1,8 @@
 import {
-  assemblyOutline
-} from "../chunk-OUMNS4RI.js";
+  assemblyOutline,
+  isHolderProfile
+} from "../chunk-UBENO6GN.js";
 export {
-  assemblyOutline
+  assemblyOutline,
+  isHolderProfile
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { ViewerAssembly, Outline } from './geometry/index.js';
-export { Provenance, ViewerHolder, ViewerTool } from './geometry/index.js';
+export { Provenance, ViewerHolder, ViewerHolderProfile, ViewerTool, isHolderProfile } from './geometry/index.js';
 import { F as Frame, S as Sheet, T as Theme, P as Padding } from './sheet-D0LSO7qP.js';
 export { B as Box, E as Extent, a as FrameOptions, O as Orientation, b as SHEETS, f as frameFor, o as orientationFor, t as typeSizeFor } from './sheet-D0LSO7qP.js';
 import * as react from 'react';

package/dist/index.js

@@ -9,8 +9,9 @@ import {
 } from "./chunk-7ZID4QRO.js";
 import {
   assemblyOutline,
-  hasNeck
-} from "./chunk-OUMNS4RI.js";
+  hasNeck,
+  isHolderProfile
+} from "./chunk-UBENO6GN.js";
 
 // src/model/frame.ts
 var DEFAULT_PADDING = 16;
@@ -629,6 +630,7 @@ var ToolDrawing = ({
   const { tool, holder } = assembly;
   const name = caption ?? tool.label ?? tool.form;
   const outline = assemblyOutline(assembly);
+  const unstatedLength = holder !== null && (isHolderProfile(holder) ? holder.datum !== "gage-line" : holder.gaugeLength === null);
   if (outline === null) {
     const missing = tool.geometry.DC === void 0 || tool.geometry.LCF === void 0;
     return /* @__PURE__ */ jsx2(
@@ -818,7 +820,7 @@ var ToolDrawing = ({
               "Drawn from stated dimensions",
               assumed.length > 0 ? `; ${assumed.join(", ")} assumed` : "",
               ".",
-              holder !== null && holder.gaugeLength === null ? " The holder length is not stated." : ""
+              unstatedLength ? " The holder length is not stated." : ""
             ]
           }
         )
@@ -838,6 +840,7 @@ export {
   figureType,
   formatMillimetres,
   frameFor,
+  isHolderProfile,
   laneOffset,
   orientationFor,
   stackLabels,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolpath/tool-drawing",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "2D elevation drawing of a cutting tool and its holder",
   "license": "MIT",
   "engines": {
@@ -43,11 +43,6 @@
     "README.md"
   ],
   "sideEffects": false,
-  "scripts": {
-    "build": "tsup src/index.ts src/geometry/index.ts src/clearance/index.ts --format esm --dts --clean --external react --external react-dom",
-    "check-types": "tsc --noEmit",
-    "test": "vitest run"
-  },
   "peerDependencies": {
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
@@ -63,5 +58,10 @@
     "tsup": "8.5.1",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/geometry/index.ts src/clearance/index.ts --format esm --dts --clean --external react --external react-dom",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
   }
-}
+}