@toolpath/tool-drawing 0.1.0

package/dist/clearance/index.js

@@ -0,0 +1,487 @@
+import {
+  AWAY_FROM_TIP,
+  TOWARD_MINUS,
+  TOWARD_PLUS,
+  TOWARD_TIP,
+  arrowhead,
+  useDrawingContext
+} from "../chunk-7ZID4QRO.js";
+
+// src/clearance/model/curve.ts
+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) {
+    if ((curve.verticalOffset[index] ?? 0) > z + GAP_TOLERANCE) {
+      return from;
+    }
+    from = curve.horizontalOffset[index] ?? from;
+  }
+  return null;
+};
+
+// src/clearance/model/gaps.ts
+var SWEPT = /* @__PURE__ */ new Set([
+  "neck",
+  "shank",
+  "collet",
+  "nose",
+  "body",
+  "flange"
+]);
+var axialGap = (segments, curve, cuttingRadius, margins) => {
+  let best = null;
+  for (const segment of segments) {
+    if (!SWEPT.has(segment.part)) {
+      continue;
+    }
+    for (const point of segment.points) {
+      const offset = point.r + margins.radial - cuttingRadius;
+      if (offset <= 0) {
+        continue;
+      }
+      const wall = heightAt(curve, offset);
+      const gap = point.z - wall;
+      if (best === null || gap < best.gap) {
+        best = {
+          part: segment.part,
+          r: point.r,
+          z: point.z,
+          wall,
+          gap,
+          clears: gap + GAP_TOLERANCE >= margins.axial
+        };
+      }
+    }
+  }
+  return best;
+};
+var radialGap = (segments, curve, cuttingRadius, margins) => {
+  let best = null;
+  for (const segment of segments) {
+    if (!SWEPT.has(segment.part)) {
+      continue;
+    }
+    for (const point of segment.points) {
+      const face = wallFaceAt(curve, point.z);
+      if (face === null) {
+        continue;
+      }
+      const gap = cuttingRadius + face - point.r;
+      if (best === null || gap < best.gap) {
+        best = {
+          part: segment.part,
+          r: point.r,
+          z: point.z,
+          gap,
+          clears: gap + GAP_TOLERANCE >= margins.radial
+        };
+      }
+    }
+  }
+  return best;
+};
+var tightestGaps = (segments, curve, cuttingRadius, margins) => {
+  const radial = radialGap(segments, curve, cuttingRadius, margins);
+  return {
+    axial: axialGap(segments, curve, cuttingRadius, margins),
+    // Nothing standing beside it is not "no room": it is nothing to measure.
+    radial: radial && radial.gap > GAP_TOLERANCE ? radial : null
+  };
+};
+
+// src/clearance/model/wall.ts
+var wallCorners = (profile, noise) => {
+  const corners = [];
+  let run = null;
+  for (const point of profile) {
+    const last = corners[corners.length - 1];
+    if (!last) {
+      corners.push({ r: point.r, z: point.z });
+      continue;
+    }
+    if (Math.abs(point.z - last.z) < noise) {
+      run = point;
+      continue;
+    }
+    if (run && run.r !== last.r) {
+      corners.push({ r: run.r, z: last.z });
+    }
+    corners.push({ r: point.r, z: point.z });
+    run = null;
+  }
+  const kept = corners[corners.length - 1];
+  if (run && kept && run.r !== kept.r) {
+    corners.push({ r: run.r, z: kept.z });
+  }
+  return corners;
+};
+var lastRise = (corners) => {
+  for (let index = corners.length - 1; index > 0; index -= 1) {
+    if (corners[index].z !== corners[index - 1].z) {
+      return corners[index].r;
+    }
+  }
+  return corners[0]?.r ?? 0;
+};
+var clipped = (profile, edge, ceiling) => {
+  const points = [];
+  for (const point of profile) {
+    if (point.r >= edge) {
+      points.push({ r: edge, z: Math.min(point.z, ceiling) });
+      break;
+    }
+    points.push({ r: point.r, z: Math.min(point.z, ceiling) });
+  }
+  const last = points[points.length - 1];
+  if (last && last.r < edge) {
+    points.push({ r: edge, z: last.z });
+  }
+  return points;
+};
+var at = (point, frame) => `${frame.toX(point.r, point.z).toFixed(2)},${frame.toY(point.r, point.z).toFixed(2)}`;
+var wallPath = (points, smooth, frame) => {
+  if (points.length === 0) {
+    return "";
+  }
+  const close = (a, b) => Math.abs(a.r - b.r) < smooth.run && Math.abs(a.z - b.z) < smooth.rise;
+  const isSmooth = (index) => {
+    const previous = points[index - 1];
+    const here = points[index];
+    const next = points[index + 1];
+    return previous !== void 0 && next !== void 0 && close(previous, here) && close(here, next);
+  };
+  let d = `M${at(points[0], frame)}`;
+  for (let index = 1; index < points.length; index += 1) {
+    const from = points[index - 1];
+    const to = points[index];
+    if (isSmooth(index - 1) && isSmooth(index)) {
+      const before = points[index - 2] ?? from;
+      const after = points[index + 1] ?? to;
+      const c1 = { r: from.r + (to.r - before.r) / 6, z: from.z + (to.z - before.z) / 6 };
+      const c2 = { r: to.r - (after.r - from.r) / 6, z: to.z - (after.z - from.z) / 6 };
+      d += ` C${at(c1, frame)} ${at(c2, frame)} ${at(to, frame)}`;
+    } else {
+      d += ` L${at(to, frame)}`;
+    }
+  }
+  return d;
+};
+var zigzag = (atR, fromZ, toZ, amplitude, steps = 8) => Array.from({ length: steps + 1 }, (_, index) => {
+  const end = index === 0 || index === steps;
+  return {
+    r: atR + (end ? 0 : index % 2 === 1 ? amplitude : -amplitude),
+    z: fromZ + (toZ - fromZ) * index / steps
+  };
+});
+var polyline = (points, frame) => points.map((point) => at(point, frame)).join(" ");
+
+// src/clearance/render/overlay.tsx
+import { useId } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var PASS = "#6ee7b7";
+var FAIL = "#f87171";
+var ClearanceOverlay = ({
+  profile,
+  frame: framed,
+  outline: extent,
+  cuttingRadius,
+  gaps,
+  margins = NO_MARGINS,
+  sheet: ink,
+  formatLength
+}) => {
+  const hatchId = `hatch-${useId().replace(/:/g, "")}`;
+  const drawing = useDrawingContext();
+  const frame = framed ?? drawing?.frame;
+  const outline = extent ?? drawing?.outline;
+  const sheet = ink ?? drawing?.sheet;
+  if (frame === void 0 || outline === void 0 || sheet === void 0) {
+    throw new Error(
+      "ClearanceOverlay needs a frame, an outline and a sheet: draw it inside <ToolDrawing>, or pass all three."
+    );
+  }
+  if (profile.length === 0) {
+    return null;
+  }
+  const { fontSize, scale } = frame;
+  const head = fontSize * 0.9;
+  const top = outline.height;
+  const noise = top * 5e-4;
+  const corners = wallCorners(profile, noise);
+  const deciding = gaps.axial;
+  const sideways = gaps.radial;
+  const sheetEdge = outline.radius + frame.padding.plus / scale;
+  const wanted = corners.length === 0 ? 0 : Math.max(lastRise(corners), sideways ? sideways.r + sideways.gap : 0, cuttingRadius) + 2;
+  const wallEdge = Math.max(Math.min(wanted, sheetEdge - fontSize * 0.5), cuttingRadius + 1);
+  const wall = clipped(corners, wallEdge, top);
+  const smooth = { run: (wallEdge - cuttingRadius) * 0.06, rise: top * 0.06 };
+  const room = margins.radial > 0 || margins.axial > 0 ? clipped(
+    wallCorners(
+      profile.map((point) => ({
+        r: Math.max(cuttingRadius, point.r - margins.radial),
+        z: point.z + margins.axial
+      })),
+      noise
+    ),
+    wallEdge,
+    top
+  ) : null;
+  const outerBreak = zigzag(wallEdge, wall[wall.length - 1]?.z ?? 0, 0, fontSize * 0.3);
+  const wallAtCut = Math.min(profile[1]?.z ?? 0, top);
+  const hatch = fontSize * 0.85;
+  const readout = (key, r, z, text, tone) => {
+    const width = (text.length + 1) * fontSize * 0.6;
+    const one = { x: frame.toX(r, z), y: frame.toY(r, z) };
+    const two = {
+      x: frame.toX(r + width, z + fontSize * 1.45),
+      y: frame.toY(r + width, z + fontSize * 1.45)
+    };
+    const box = {
+      x: Math.min(one.x, two.x),
+      y: Math.min(one.y, two.y),
+      width: Math.abs(one.x - two.x),
+      height: Math.abs(one.y - two.y)
+    };
+    return /* @__PURE__ */ jsxs("g", { "data-readout": key, children: [
+      /* @__PURE__ */ jsx(
+        "rect",
+        {
+          x: box.x,
+          y: box.y,
+          width: box.width,
+          height: box.height,
+          rx: fontSize * 0.2,
+          fill: sheet.ground,
+          fillOpacity: 0.9
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "text",
+        {
+          x: box.x + box.width / 2,
+          y: box.y + box.height / 2 + fontSize * 0.35,
+          fontSize,
+          textAnchor: "middle",
+          fill: tone,
+          fontFamily: "ui-monospace, monospace",
+          children: text
+        }
+      )
+    ] }, key);
+  };
+  return /* @__PURE__ */ jsxs("g", { "data-clearance": true, children: [
+    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsxs(
+      "pattern",
+      {
+        id: hatchId,
+        width: hatch,
+        height: hatch,
+        patternUnits: "userSpaceOnUse",
+        patternTransform: "rotate(45)",
+        children: [
+          /* @__PURE__ */ jsx("rect", { width: hatch, height: hatch, fill: sheet.ground }),
+          /* @__PURE__ */ jsx(
+            "line",
+            {
+              x1: 0,
+              y1: 0,
+              x2: 0,
+              y2: hatch,
+              stroke: sheet.dimension,
+              strokeWidth: hatch * 0.09
+            }
+          )
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-part": "material",
+        d: `${wallPath(wall, smooth, frame)} ${outerBreak.map(
+          (point) => `L${frame.toX(point.r, point.z).toFixed(2)},${frame.toY(point.r, point.z).toFixed(2)}`
+        ).join(
+          " "
+        )} L${frame.toX(cuttingRadius, 0).toFixed(2)},${frame.toY(cuttingRadius, 0).toFixed(2)} Z`,
+        fill: `url(#${hatchId})`,
+        stroke: "none"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-surface": "material",
+        d: wallPath(wall, smooth, frame),
+        fill: "none",
+        stroke: sheet.ink,
+        strokeWidth: fontSize * 0.06,
+        strokeLinejoin: "round"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "line",
+      {
+        x1: frame.toX(cuttingRadius, 0),
+        y1: frame.toY(cuttingRadius, 0),
+        x2: frame.toX(wallEdge, 0),
+        y2: frame.toY(wallEdge, 0),
+        stroke: sheet.dimension,
+        strokeWidth: fontSize * 0.05
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "polyline",
+      {
+        "data-break": "material",
+        points: polyline(outerBreak, frame),
+        fill: "none",
+        stroke: sheet.dimension,
+        strokeWidth: fontSize * 0.05
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "line",
+      {
+        "data-wall": "cut",
+        x1: frame.toX(cuttingRadius, 0),
+        y1: frame.toY(cuttingRadius, 0),
+        x2: frame.toX(cuttingRadius, wallAtCut),
+        y2: frame.toY(cuttingRadius, wallAtCut),
+        stroke: sheet.centre,
+        strokeWidth: fontSize * 0.08
+      }
+    ),
+    room ? /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-part": "room",
+        d: wallPath(room, smooth, frame),
+        fill: "none",
+        stroke: sheet.dimension,
+        strokeWidth: fontSize * 0.05,
+        strokeLinejoin: "round",
+        strokeDasharray: `${(fontSize * 0.6).toFixed(2)} ${(fontSize * 0.4).toFixed(2)}`
+      }
+    ) : null,
+    deciding ? (() => {
+      const tone = deciding.clears ? PASS : FAIL;
+      const lane = deciding.r + fontSize * 1.6;
+      const low = Math.min(deciding.z, deciding.wall);
+      const high = Math.max(deciding.z, deciding.wall);
+      const inside = high - low >= head * 2.6;
+      const reach = head * 2.2;
+      const text = `${deciding.gap < 0 ? "\u2212" : ""}${formatLength(Math.abs(deciding.gap))} up`;
+      return /* @__PURE__ */ jsxs("g", { "data-clearance-dimension": "axial", children: [
+        /* @__PURE__ */ jsx(
+          "line",
+          {
+            x1: frame.toX(lane, inside ? low : low - reach),
+            y1: frame.toY(lane, inside ? low : low - reach),
+            x2: frame.toX(lane, inside ? high : high + reach),
+            y2: frame.toY(lane, inside ? high : high + reach),
+            stroke: tone,
+            strokeWidth: fontSize * 0.07
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "polygon",
+          {
+            points: arrowhead(lane, low, inside ? TOWARD_TIP : AWAY_FROM_TIP, head, frame),
+            fill: tone
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "polygon",
+          {
+            points: arrowhead(lane, high, inside ? AWAY_FROM_TIP : TOWARD_TIP, head, frame),
+            fill: tone
+          }
+        ),
+        readout("axial", lane + fontSize * 0.5, (low + high) / 2, text, tone)
+      ] });
+    })() : null,
+    sideways ? (() => {
+      const tone = sideways.clears ? PASS : FAIL;
+      const face = sideways.r + sideways.gap;
+      const cutOff = face > wallEdge;
+      const to = Math.min(face, wallEdge);
+      const inside = to - sideways.r >= head * 2.6;
+      const text = `${formatLength(sideways.gap)} across${cutOff ? " \u27E8" : ""}`;
+      return /* @__PURE__ */ jsxs("g", { "data-clearance-dimension": "radial", "data-broken": cutOff ? "true" : "false", children: [
+        /* @__PURE__ */ jsx(
+          "line",
+          {
+            x1: frame.toX(sideways.r, sideways.z),
+            y1: frame.toY(sideways.r, sideways.z),
+            x2: frame.toX(to, sideways.z),
+            y2: frame.toY(to, sideways.z),
+            stroke: tone,
+            strokeWidth: fontSize * 0.07
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "polygon",
+          {
+            points: arrowhead(
+              sideways.r,
+              sideways.z,
+              inside ? TOWARD_MINUS : TOWARD_PLUS,
+              head,
+              frame
+            ),
+            fill: tone
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "polygon",
+          {
+            points: arrowhead(
+              to,
+              sideways.z,
+              inside ? TOWARD_PLUS : TOWARD_MINUS,
+              head,
+              frame
+            ),
+            fill: tone
+          }
+        ),
+        readout("radial", sideways.r, sideways.z + fontSize * 0.4, text, tone)
+      ] });
+    })() : null
+  ] });
+};
+
+// src/clearance/model/describe.ts
+var describeGaps = (gaps, margins, formatLength) => {
+  const deciding = gaps.axial;
+  if (deciding === null) {
+    return null;
+  }
+  const up = deciding.gap < 0 ? `${formatLength(-deciding.gap)} into the wall at the ${deciding.part}` : `${formatLength(deciding.gap)} above the wall at the ${deciding.part}`;
+  const sideways = gaps.radial;
+  const side = sideways === null || sideways.gap <= GAP_TOLERANCE ? "" : ` \xB7 ${formatLength(sideways.gap)} from the wall at the ${sideways.part}`;
+  return `tightest: ${up}${side} \u2014 ${formatLength(margins.axial)} up and ${formatLength(margins.radial)} sideways wanted`;
+};
+export {
+  ClearanceOverlay,
+  NO_MARGINS,
+  clipped,
+  describeGaps,
+  heightAt,
+  lastRise,
+  tightestGaps,
+  wallCorners,
+  wallFaceAt,
+  wallPath,
+  zigzag
+};

package/dist/geometry/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * What this package needs to draw an assembly, and nothing more.
+ *
+ * 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.
+ *
+ * `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`.
+ *
+ * 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>>;
+}
+interface ViewerAssembly {
+    readonly tool: ViewerTool;
+    readonly holder: ViewerHolder | 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.
+     */
+    readonly stickout: number | null;
+}
+
+/**
+ * An assembly as a drawing: its outline in the plane of its own axis.
+ *
+ * A tool, a collet and a holder are all bodies of revolution, so the whole
+ * stack is one polyline of (radius, height) pairs, from the tip up. That is
+ * what a catalog draws, what a lathe would turn, and everything a picture needs
+ * — a renderer mirrors it about the axis and it is a silhouette.
+ *
+ * **Drawn from stated dimensions, and marked where they are not.** Every
+ * segment says which part it is and where its numbers came from, so a renderer
+ * can dash what was derived or assumed. What nobody states is not drawn: a
+ * holder the catalog knows only as a nose diameter and a gauge length is a
+ * cylinder of that size and nothing above it, rather than a body invented to
+ * look like one.
+ *
+ * **And what cannot be drawn honestly is not drawn at all.** There is no
+ * fallback cylinder for a form without a generator. A silent cylinder is how a
+ * made-up shape ships: it renders, it looks plausible, and it is wrong — a
+ * keyseat cutter drawn flat is a featureless sliver two pixels tall, and a
+ * reader has no way to tell that from a measurement. {@link assemblyOutline}
+ * returns `null` instead and the caller says so in words.
+ */
+type OutlinePart = 'tip' | 'flutes' | 'neck' | 'shank' | 'collet' | 'nose' | 'body' | 'flange';
+/** Radius out from the axis and height above the tip, both in millimetres. */
+interface OutlinePoint {
+    readonly r: number;
+    readonly z: number;
+}
+interface OutlineSegment {
+    readonly part: OutlinePart;
+    /** From the lower end up; the last point of one segment is the first of the next. */
+    readonly points: ReadonlyArray<OutlinePoint>;
+    /** Where the dimensions came from — `chosen` for the stickout, which is nobody's but the shop's. */
+    readonly provenance: Provenance | 'chosen';
+}
+interface Outline {
+    readonly segments: ReadonlyArray<OutlineSegment>;
+    /** The tallest point drawn, above the tip. */
+    readonly height: number;
+    /** The widest radius drawn. */
+    readonly radius: number;
+}
+/**
+ * The outline of one assembly at its stickout.
+ *
+ * Flutes to the flute length, a neck where a shoulder is stated, the shank up
+ * to the stickout, and the holder nose above that for its gauge length.
+ *
+ * `null` where there is no honest picture: a form without a generator, or a
+ * tool that states neither a cutting diameter nor a flute length.
+ */
+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 };

package/dist/geometry/index.js

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