@toolpath/tool-drawing 0.1.0 → 0.3.0

package/README.md

@@ -14,6 +14,12 @@ in 3D; this one draws a catalog tool in 2D.
 npm install @toolpath/tool-drawing react react-dom
 ```
 
+Its one runtime dependency is [`@toolpath/tool-support`](../tool-support), the
+shared cutting-tool domain, which itself depends on nothing. `Provenance`,
+`ViewerTool`, `ViewerHolder` and `ViewerHolderProfile` are aliases of its types
+and are re-exported here, so a consumer that also uses `@toolpath/tool-support`
+gets the same types and needs no adapter between them.
+
 ## Exports
 
 | Entry point                        | What it is                                              |
@@ -24,6 +30,7 @@ npm install @toolpath/tool-drawing react react-dom
 
 `/geometry` is pure and server-safe: it touches no DOM and imports no React, so
 a Node server can measure an assembly without paying for a renderer.
+`tests/subpaths.test.ts` asserts that from the import graph.
 
 ## Geometry
 
@@ -45,6 +52,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`
@@ -68,19 +99,52 @@ as a plausible cylinder.
 ## Dimensions
 
 ```tsx
-<ToolDrawing assembly={assembly} dimensions dimensionSides="both" formatLength={inches} />
+<ToolDrawing
+  assembly={assembly}
+  dimensions
+  dimensionSides="both"
+  highlight={hovered}
+  onDimensionHover={setHovered}
+/>
 ```
 
 Every stated length and width, each in its own lane, nested shortest-innermost
-so no two lines cross, with each figure in the band just outboard of its own
-lane. Only stated numbers are dimensioned. `formatLength` is yours, because the
-unit a shop reads in is the application's.
+so no two lines cross. Only stated numbers are dimensioned.
+
+**The drawing letters none of them.** The numbers belong in your own table,
+where they can be read; six two-line figures fighting for the margin said the
+same numbers a second time and worse. Which line is which is answered by
+pointing at it instead:
+
+- `highlight` names the dimension or dimensions to draw in the sheet's accent,
+  by ISO 13399 code — `DC`, `LCF`, `OAL`, `SFDM`, `LBH`, `stickout`, `SIG`, and
+  the two `shoulder-` codes. A code the tool does not dimension highlights
+  nothing.
+- `onDimensionHover` is told the code under the pointer and `null` when it
+  leaves, so your table can be lit from the drawing as well as the other way
+  about. Passing it puts hit targets on the lines; leaving it off draws none.
+
+Where two codes are one span the drawing carries one line, not two. A shop that
+clamps to its own rule states the stickout and the below-holder length as the
+same number, and a tool stood out to its flutes states it again as the flute
+length; with nothing lettered, identical lines in two lanes cannot be told
+apart. The first code named keeps the line — the tool's own number ahead of the
+shop's — and the others light it too. Hover reports the code the line is drawn
+under.
+
+**The stickout is yours.** `assembly.stickout` is where the holder nose goes,
+and nothing here derives it — pass `LBH` as the stickout if standing the tool
+out to its below-holder length is the rule you want drawn. Where the two
+disagree and `LBH` ends up inside the holder, it is not dimensioned: the
+drawing will not run a line to a face it has drawn a holder over.
+
+A highlighted line is drawn in the accent **and heavier**, so the highlight
+survives a reader who cannot tell the two colours apart.
 
 ## Clearance overlay
 
 ```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-WYHJGR7P.js}

@@ -1,4 +1,8 @@
+// src/model/types.ts
+import { isHolderProfile } from "@toolpath/tool-support";
+
 // src/model/outline.ts
+import { hasNeck } from "@toolpath/tool-support";
 var EPSILON = 1e-6;
 var stated = (tool, code) => tool.provenance?.[code] ?? "vendor-stated";
 var arc = (centre, radius, fromDeg, toDeg, steps = 6) => Array.from({ length: steps + 1 }, (_, index) => {
@@ -9,16 +13,6 @@ var arc = (centre, radius, fromDeg, toDeg, steps = 6) => Array.from({ length: st
     z: exact(centre.z + radius * Math.sin(angle))
   };
 });
-var hasNeck = (tool) => {
-  const { LCF, SFDM, DC } = tool.geometry;
-  const shoulder = tool.geometry["shoulder-length"];
-  const relief = tool.geometry["shoulder-diameter"];
-  if (shoulder === void 0 || relief === void 0 || LCF === void 0 || shoulder <= LCF) {
-    return false;
-  }
-  const shank = SFDM ?? DC;
-  return shank === void 0 ? true : relief < shank - EPSILON;
-};
 var cone = (tool, r, whenUnstated) => {
   const angle = tool.geometry.SIG;
   const half = (angle ?? whenUnstated) / 2 * (Math.PI / 180);
@@ -96,6 +90,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 +232,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 +243,35 @@ 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")
+        provenance: holder.provenance?.["colletProtrusion"] ?? "vendor-stated"
       });
-      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")
-      });
-      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 };
 };
+var edgeRadius = (from, to, z) => {
+  const low = Math.min(from.z, to.z);
+  const high = Math.max(from.z, to.z);
+  if (z < low - EPSILON || z > high + EPSILON) {
+    return null;
+  }
+  if (high - low <= EPSILON) {
+    return Math.max(from.r, to.r);
+  }
+  return from.r + (z - from.z) / (to.z - from.z) * (to.r - from.r);
+};
+var radiusAt = (outline, z) => Math.max(
+  0,
+  ...outline.segments.flatMap(
+    (segment) => segment.points.slice(1).map((point, index) => edgeRadius(segment.points[index], point, z)).filter((radius) => radius !== null)
+  )
+);
 
 export {
-  hasNeck,
-  assemblyOutline
+  isHolderProfile,
+  assemblyOutline,
+  radiusAt
 };

package/dist/clearance/index.d.ts

@@ -1,47 +1,25 @@
+import { ReachCurve } from '@toolpath/tool-support';
+export { ReachCurve, heightAt } from '@toolpath/tool-support';
 import { OutlinePart, OutlineSegment, OutlinePoint } from '../geometry/index.js';
 import * as react from 'react';
-import { F as Frame, E as Extent, S as Sheet } from '../sheet-D0LSO7qP.js';
+import { F as Frame, E as Extent, S as Sheet } from '../sheet-DicKQYfF.js';
 
 /**
  * The feature's reach curve, and how the drawing reads it.
  *
- * **Declared structurally, on purpose.** The shape is exactly what
- * `@toolpath/part-contracts` calls a `ReachCurve`, and naming it here rather
- * than importing it is one of the three senses in which this overlay stays
- * optional: a consumer that draws a tool alone pulls in no Toolpath schema.
- * A `ReachCurve` from the API satisfies this by structure, with no adapter.
+ * **Still declared structurally, one package up.** `@toolpath/tool-support`
+ * names the shape and imports no Toolpath schema to do it, which is one of the
+ * three senses in which this overlay stays optional: a consumer that draws a
+ * tool alone pulls in no OpenAPI contract. A `ReachCurve` off a report
+ * satisfies it by structure, with no adapter, exactly as before.
  */
-/**
- * The worst-case material around a feature, as a staircase.
- *
- * Read as "material within `horizontalOffset[i]` of the cut rises to
- * `verticalOffset[i]`". Both are in millimetres; the offsets run outward from
- * the cutting edge and the heights up from the bottom of the feature.
- */
-interface ReachCurve {
-    readonly horizontalOffset: ReadonlyArray<number>;
-    readonly verticalOffset: ReadonlyArray<number>;
-}
+
 /** Room the shop wants kept between the stack and the part, in millimetres. */
 interface Margins {
     readonly radial: number;
     readonly axial: number;
 }
 declare const NO_MARGINS: Margins;
-/**
- * The tallest material within `offset` mm of the cut, above the feature's bottom.
- *
- * **The one piece of the verdict's own arithmetic that had to travel.** The
- * decision — whether an assembly clears — stays with the catalog's
- * tool-selection engine, which has a dozen callers that never draw anything.
- * This is not that decision: it is the reading of the curve that the drawn
- * staircase is drawn from, and the gaps this overlay dimensions are measured
- * against. It is here because {@link tightestGaps} cannot be written without
- * it, and it must keep agreeing with whatever draws the material profile — the
- * rise comes at the *start* of each run, so everything out to a knot is
- * already as tall as that knot says.
- */
-declare const heightAt: (curve: ReachCurve, offset: number) => number;
 /**
  * Where the wall face stands at a given height, as an offset from the cut:
  * the start of the first run of the staircase that rises above that height.
@@ -202,4 +180,4 @@ declare const ClearanceOverlay: ({ profile, frame: framed, outline: extent, cutt
  */
 declare const describeGaps: (gaps: Gaps, margins: Margins, formatLength: (millimetres: number) => string) => string | null;
 
-export { type AxialGap, ClearanceOverlay, type ClearanceOverlayProps, type Gap, type Gaps, type Margins, NO_MARGINS, type ReachCurve, clipped, describeGaps, heightAt, lastRise, tightestGaps, wallCorners, wallFaceAt, wallPath, zigzag };
+export { type AxialGap, ClearanceOverlay, type ClearanceOverlayProps, type Gap, type Gaps, type Margins, NO_MARGINS, clipped, describeGaps, lastRise, tightestGaps, wallCorners, wallFaceAt, wallPath, zigzag };

package/dist/clearance/index.js

@@ -8,16 +8,9 @@ import {
 } from "../chunk-7ZID4QRO.js";
 
 // src/clearance/model/curve.ts
+import { heightAt } from "@toolpath/tool-support";
 var NO_MARGINS = { radial: 0, axial: 0 };
 var GAP_TOLERANCE = 1e-6;
-var heightAt = (curve, offset) => {
-  for (let index = 0; index < curve.horizontalOffset.length; index += 1) {
-    if ((curve.horizontalOffset[index] ?? 0) >= offset) {
-      return curve.verticalOffset[index] ?? 0;
-    }
-  }
-  return curve.verticalOffset[curve.verticalOffset.length - 1] ?? 0;
-};
 var wallFaceAt = (curve, z) => {
   let from = 0;
   for (let index = 0; index < curve.horizontalOffset.length; index += 1) {

package/dist/geometry/index.d.ts

@@ -1,44 +1,66 @@
+import { Tool, Holder, HolderProfile, Provenance } from '@toolpath/tool-support';
+export { Provenance, isHolderProfile } from '@toolpath/tool-support';
+
 /**
- * What this package needs to draw an assembly, and nothing more.
+ * What this package needs to draw an assembly — which is the shared cutting-tool
+ * domain, under the names this package has always published.
+ *
+ * These four were declared here until `@toolpath/tool-support` existed, and the
+ * declarations were three-way duplicates: the same provenance strings, the same
+ * geometry codes and three shapes called "holder" of which no two agreed on
+ * which fields exist. A drawing and the number printed beside it were free to
+ * disagree about one tool, and once did — the stickout the details table showed
+ * was not the stickout the dimension line drew.
+ *
+ * So the shapes now come from the one declaration and these are **aliases**,
+ * exported from `.` and from `/geometry` exactly as before. A consumer's adapter
+ * does not move: `ViewerTool` is `Tool`, and a catalog record that satisfied one
+ * satisfies the other by structure.
+ *
+ * ## Why the alias and not a rename
  *
- * The contract is the package's own, so nothing here depends on a particular
- * catalog's record types. A consumer writes one adapter that projects its own
- * tool onto {@link ViewerTool}; the adapter is the single file that fails
- * loudly when either side moves.
+ * A consumer's adapter is the single file that fails loudly when either side
+ * moves, and renaming the type it targets would be that failure for no gain. The
+ * `Viewer*` names are also what the two entry points publish, so dropping them
+ * is a major bump this change has no reason to spend. `@toolpath/tool-support`
+ * is where the domain is documented; this file is the seam.
  *
- * `geometry` keeps the scraper's own field names — `DC`, `SFDM`, `OAL`, `LCF`,
- * `RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length`. Renaming one here
- * would put a translation table between two vocabularies, which is where an
- * `SFDM` silently becomes a `DC`.
+ * `geometry` still keeps the scraper's own field names — `DC`, `SFDM`, `OAL`,
+ * `LCF`, `RE`, `SIG`, `NOF`, `shoulder-diameter`, `shoulder-length` — and
+ * `@toolpath/tool-support`'s `GEOMETRY_FIELDS` is now the dictionary behind
+ * them.
  *
  * All lengths are in millimetres and all angles in degrees, and every generator
  * works in whatever unit system it is handed: an inch tool yields an inch
  * outline. Converting is the caller's, at the seam where a tool meets a holder.
  */
-/** Where a stated number came from. */
-type Provenance = 'vendor-stated' | 'derived' | 'assumed';
-interface ViewerTool {
-    /** The CAM-library name for what the tool is: `flat end mill`, `drill`, `slot mill`. */
-    readonly form: string;
-    readonly label?: string;
-    readonly geometry: Readonly<Record<string, number | undefined>>;
-    readonly provenance?: Readonly<Record<string, Provenance>>;
-}
-interface ViewerHolder {
-    readonly noseDiameter: number | null;
-    readonly noseLength: number | null;
-    readonly bodyDiameter: number | null;
-    readonly bodyLength: number | null;
-    readonly projection: number | null;
-    readonly flangeDiameter: number | null;
-    readonly gaugeLength: number | null;
-    readonly colletSeries: string | null;
-    readonly colletProtrusion: number | null;
-    readonly provenance?: Readonly<Record<string, Provenance>>;
-}
+
+/** A cutting tool, as the drawing needs one. */
+type ViewerTool = Tool;
+/** A holder as its vendor publishes it: a nose, a body, a projection. */
+type ViewerHolder = Holder;
+/**
+ * A holder as its own CAD model measures it: the silhouette, and nothing
+ * parametric.
+ *
+ * Not a refinement of {@link ViewerHolder} and it does not project onto one —
+ * reducing a measured envelope to a nose and a body throws away the only reason
+ * to measure. The two are a union and {@link isHolderProfile} tells them apart;
+ * a consumer that has neither passes `null` and the tool is drawn alone.
+ */
+type ViewerHolderProfile = HolderProfile;
+
+/**
+ * A tool, the holder it is clamped in, and how far it stands out.
+ *
+ * Deliberately **not** `@toolpath/tool-support`'s `Assembly`, which also carries
+ * the collet: a drawing reads a collet only through the holder's own series and
+ * protrusion, and taking one it never reads would be a field every adapter has
+ * to fill for nothing.
+ */
 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 +121,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 ViewerAssembly, type ViewerHolder, type ViewerHolderProfile, type ViewerTool, assemblyOutline };

package/dist/geometry/index.js

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