@toolpath/tool-drawing 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { ViewerAssembly, Outline } 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';
+export { ViewerHolder, ViewerHolderProfile, ViewerTool } from './geometry/index.js';
+import { F as Frame, S as Sheet, T as Theme, P as Padding } from './sheet-DicKQYfF.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-DicKQYfF.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
+export { Provenance, isHolderProfile } from '@toolpath/tool-support';
 
 /**
  * What a drawing of this tool dimensions, and where each dimension goes.
@@ -18,11 +19,20 @@ import { ReactNode } from 'react';
  * axis. Every length is measured **from the tip**, which is where a machinist
  * measures from and where every rule in the sheet measures from.
  *
- * Only stated numbers are dimensioned. A drawing that carries a figure the
+ * Only stated numbers are dimensioned. A drawing that carries a dimension the
  * vendor never published is worse than one that carries fewer — the note under
  * the drawing already names what was assumed, and a dimension line looks like a
  * measurement whatever the note says.
  *
+ * ## Nothing here is lettered
+ *
+ * The drawing writes no numbers on itself (Paul, 2026-09-02). The figures were
+ * six two-line blocks fighting for the margin of a panel that already had the
+ * same six numbers in a table beside it, and the table is where a number can be
+ * read. What is left is the linework, and a way to say which line the reader is
+ * pointing at — so this model says which dimensions exist and where they run,
+ * and never what they are called or how they are written.
+ *
  * ## Sides are `minus` and `plus`, not `left` and `right`
  *
  * This model was written for a drawing that only ran vertically, where the two
@@ -38,6 +48,15 @@ interface LengthDimension {
     /** From the tip, in millimetres — always 0 for now, kept for a dimension that is not. */
     readonly from: number;
     readonly to: number;
+    /**
+     * The other codes this same line answers to.
+     *
+     * Two codes are one span more often than they look — see
+     * {@link oneLinePerSpan} — and the line is drawn once, under `code`, rather
+     * than as two of exactly the same length in two lanes. Pointing at any of
+     * these names lights it.
+     */
+    readonly aliases?: ReadonlyArray<string>;
     /**
      * Which line out from the stack this one runs in, 0 nearest.
      *
@@ -56,17 +75,18 @@ interface WidthDimension {
     readonly at: number;
 }
 /**
- * An angle called out with a leader rather than measured between two lines.
+ * An angle between two faces, drawn as the two faces extended.
  *
  * **A drill is its point** (Paul, 2026-09-01: "shouldn't a 2d rep of a drill be
  * showing me a tip angle?"). On a ⌀1 drill the cone is three tenths of a
- * millimetre tall — drawn to scale it is invisible, and the number is the only
- * way the drawing says 140° rather than 118°.
+ * millimetre tall — drawn to scale it is invisible — so the drawing runs the
+ * point's two flanks out past the tool and arcs between them, which is what a
+ * sheet does with an angle too small to letter between its own faces.
  */
 interface AngleDimension {
     readonly code: string;
     readonly degrees: number;
-    /** Where the leader points: a radius from the axis and a height above the tip. */
+    /** Halfway up the cone's own flank: a radius from the axis and a height above the tip. */
     readonly at: {
         readonly r: number;
         readonly z: number;
@@ -88,140 +108,54 @@ interface ToolDimensions {
  * out of it.
  */
 declare const dimensionsFor: (assembly: ViewerAssembly) => ToolDimensions;
-declare const dimensionLabel: (code: string) => string;
-/**
- * How a length is written out.
- *
- * A function rather than a unit, because a unit system is the application's:
- * this package has no opinion on whether a shop reads millimetres or inches,
- * and owning one would mean owning its rounding too. Millimetres in, a string
- * out; the default is only so the package draws something on its own.
- */
-type FormatLength = (millimetres: number) => string;
-declare const formatMillimetres: FormatLength;
-/** One label's box on the drawing, before anything has been moved. */
-interface LabelBox {
-    readonly key: string;
-    /** The inboard edge across the axis, and how far the box reaches outward. */
-    readonly across: number;
-    readonly width: number;
-    /** The end nearest the tip, and how far the box reaches along the axis. */
-    readonly along: number;
-    readonly height: number;
-}
-/**
- * The same labels, moved apart until none covers another.
- *
- * **Because a dimension is only worth drawing if it can be read** (Paul,
- * 2026-09-01). A tool 50 mm long with 4 mm of flute puts its flute length, its
- * relief and its cutting diameter inside the bottom tenth of the drawing, and
- * three figures land on each other however carefully each one is placed. Each
- * label carries a box, so the boxes can be stacked: the one nearest the tip
- * keeps its place, and anything that would cover it moves **away from the
- * tip**, which is where the drawing has room.
- *
- * Pure arithmetic over rectangles — no measuring of text and no reading of the
- * DOM, so it runs the same on a server as in a browser.
- *
- * **Along the axis, not up the screen.** The original moved a clash "up",
- * which was the same direction only because the tool was always drawn
- * standing. Away from the tip is what that meant, and it is what holds when
- * the tool is laid on its side.
- */
-declare const stackLabels: (boxes: ReadonlyArray<LabelBox>, gap?: number, 
-/**
- * Boxes that cannot move: the drawing's own lines, so a figure rises clear
- * of an extension line rather than sitting on it (Paul, 2026-09-01 — the
- * figures moved in beside their own lanes, and the lines outboard of them
- * cross those bands).
- */
-fixed?: ReadonlyArray<LabelBox>) => Map<string, number>;
+/** Which flank of the tool a lane runs on. */
+type Side = 'minus' | 'plus';
 /**
- * Where every figure on the drawing stands.
+ * One length's lane: which flank it runs on, and how far out along it.
  *
- * **Each figure beside its own line, in the band just outboard of it** (Paul,
- * 2026-09-01: "I'd love to put SFDM, LCF and shoulder dia closer to the part —
- * like, inside the below holder and OAL lines"). One column in the far margin
- * put the number for a dimension at the tool's edge as far from it as the
- * number for the overall length, and the eye has to travel the width of the
- * sheet to pair them up. So the margin is a series of bands: the widths sit in
- * the first, just past their arrows, and each length's figure sits in the band
- * outboard of its own lane.
- *
- * A band is only as wide as the widest figure in it, because the room it takes
- * comes out of the tool.
+ * {@link LengthDimension.lane} numbers the lanes across the whole drawing,
+ * shortest innermost. Where both flanks are offered they alternate, so each
+ * flank carries its own run of lanes starting at 0 — and it is that per-flank
+ * number, not the global one, that says how far out the line is drawn.
  */
-/** Which flank of the tool a figure stands off. */
-type Side = 'minus' | 'plus';
-/** The type a figure is set in, given the drawing's own size. */
-declare const figureType: (fontSize: number) => number;
-/** One figure, and the band it stands in. */
-interface DimensionFigure {
+interface DimensionLane {
     readonly code: string;
     readonly side: Side;
-    /** 0 is the band nearest the tool — the widths'; band `i + 1` is outboard of lane `i`. */
-    readonly band: number;
-    /** The lane this figure's dimension runs in on its own side, or null for a width. */
-    readonly lane: number | null;
-    readonly lines: ReadonlyArray<string>;
-    /** How far the figure reaches perpendicular to the tool axis. Bands are sized by this. */
-    readonly across: number;
-    /** How far it reaches parallel to the tool axis. The stacker moves figures along this. */
-    readonly along: number;
+    readonly lane: number;
+}
+interface LaneLayout {
+    readonly lanes: ReadonlyArray<DimensionLane>;
+    /** How many lanes each flank carries, which is the room that flank needs. */
+    readonly count: Readonly<Record<Side, number>>;
 }
 /**
- * How tall a block of this many lines is, set at that type size.
+ * Which flank each length runs on, and its lane on that flank.
  *
- * The renderer sets type at {@link figureType} and leads it at 1.15, with half
- * a line of padding above and below; this is that sum, and the two have to
- * agree or a figure's box is not the size of the figure in it.
+ * **The drawing carries no figures**, so this is the whole of the layout: a
+ * lane is a place for a line, and a line needs nothing but room for itself.
+ * What replaced the bands is a plain ladder — the numbers live in the
+ * consumer's own table, and the drawing lights the line the reader is pointing
+ * at (Paul, 2026-09-02).
  */
-declare const figureHeight: (lines: number, type: number) => number;
-interface DimensionLayout {
-    readonly figures: ReadonlyArray<DimensionFigure>;
-    /** Per side, the width of every band, nearest the tool first. */
-    readonly bands: Readonly<Record<Side, ReadonlyArray<number>>>;
-}
-/** The room a side's bands take, measured out from the edge of the stack. */
-interface BandRoom {
+declare const laneLayout: (model: ToolDimensions, sides?: "one" | "both") => LaneLayout;
+/** The room one flank's lines take, measured out from the edge of the stack. */
+interface LaneRoom {
     /** How far the width dimensions' arrows reach past the tool. */
     readonly arrow: number;
-    /** The clearance between a band and the line beside it. */
+    /** The clearance between the arrows and the first lane. */
     readonly gap: number;
+    /** From one lane to the next. */
+    readonly step: number;
 }
-/** Where a band's inboard edge is: the offset a figure in it reads outward from. */
-declare const bandOffset: (bands: ReadonlyArray<number>, band: number, room: BandRoom) => number;
-/** Where a lane's line runs: just outboard of the band that carries its figure. */
-declare const laneOffset: (bands: ReadonlyArray<number>, lane: number, room: BandRoom) => number;
-/** Everything one side needs, out to the far edge of its last band. */
-declare const bandRoom: (bands: ReadonlyArray<number>, room: BandRoom) => number;
+/** Where a lane's line runs, out from the edge of the stack. */
+declare const laneOffset: (lane: number, room: LaneRoom) => number;
 /**
- * Every figure, on the side and in the band it belongs to.
+ * Everything one flank needs, out to its outermost line.
  *
- * The sides alternate — lengths by lane, widths by their own order — so
- * neither margin runs away with the whole drawing while the other stands
- * empty. Where the drawing has something beside it, everything stays on the
- * one flank.
+ * Never less than the arrows, because a width is dimensioned from outside on
+ * **both** flanks whether or not a length runs up either of them.
  */
-declare const dimensionLayout: (model: ToolDimensions, format: FormatLength, fontSize: number, sides?: "one" | "both", 
-/**
- * **Whether horizontal text runs parallel to the tool axis.**
- *
- * The one fact about the drawing's orientation that this model cannot do
- * without, and it is here rather than in the renderer so that it is stated
- * once, in a pure function, with a test on it.
- *
- * Everything else in this package is orientation-agnostic because a
- * millimetre is a millimetre whichever way the axis runs. Type is the
- * exception: **text does not rotate.** A figure two lines deep and twelve
- * characters wide is wide on the screen either way, so when the tool is laid
- * along the screen's width that figure reaches mostly *along* the tool, and
- * when the tool stands up it reaches *across* it. The bands are sized on the
- * across measure, so which of the two the type contributes decides how much
- * room the margins take — and getting it backwards pads the wrong axis by a
- * factor of about five.
- */
-textAlongAxis?: boolean) => DimensionLayout;
+declare const laneRoom: (lanes: number, room: LaneRoom) => number;
 
 /**
  * What `<ToolDrawing>` hands the things drawn inside it.
@@ -282,6 +216,10 @@ interface ToolDrawingProps {
     /**
      * Draw the dimensions: every stated length and width, on the tool.
      *
+     * Lines only — the drawing letters none of them (Paul, 2026-09-02). Which
+     * line is which is said by {@link ToolDrawingProps.highlight}, from the
+     * consumer's own table of numbers.
+     *
      * Off by default, because the drawing is also used small — on a card beside
      * a list, where a dimension line is noise. The panel that has room turns it
      * on (Paul, 2026-09-01).
@@ -297,12 +235,25 @@ interface ToolDrawingProps {
      */
     readonly dimensionSides?: 'one' | 'both';
     /**
-     * How a length is written out. Millimetres in, a string out.
+     * The dimension or dimensions drawn in the sheet's accent, by ISO 13399 code
+     * — `DC`, `LCF`, `OAL`, `SFDM`, `LBH`, `stickout`, `SIG`, and the two
+     * `shoulder-` codes.
+     *
+     * **The drawing letters nothing**, so this is how a reader is told which
+     * line is which (Paul, 2026-09-02): the consumer's own table of numbers
+     * lights the line for the number under the reader's pointer. A code that
+     * this tool does not dimension highlights nothing, which is what should
+     * happen when the table carries a number the drawing has no line for.
+     */
+    readonly highlight?: string | ReadonlyArray<string> | null;
+    /**
+     * The code under the pointer, and `null` when it leaves — so the table can
+     * be lit from the drawing as well as the other way about.
      *
-     * The application's, because the unit a shop reads in is the application's
-     * and owning one would mean owning its rounding too.
+     * Passing it puts hit targets on the lines; leaving it off draws none, and
+     * the drawing stays inert.
      */
-    readonly formatLength?: FormatLength;
+    readonly onDimensionHover?: (code: string | null) => void;
     /**
      * Extra room for chrome around the drawing, in pixels, on top of whatever
      * the dimension bands ask for.
@@ -348,6 +299,6 @@ interface ToolDrawingProps {
     readonly children?: ReactNode;
     readonly className?: string;
 }
-declare const ToolDrawing: ({ assembly, theme, caption, dimensions, dimensionSides, formatLength, padding, collisions, verdict, children, className, }: ToolDrawingProps) => react.JSX.Element;
+declare const ToolDrawing: ({ assembly, theme, caption, dimensions, dimensionSides, highlight, onDimensionHover, padding, collisions, verdict, children, className, }: ToolDrawingProps) => react.JSX.Element;
 
-export { type AngleDimension, type BandRoom, type DimensionFigure, type DimensionLayout, type DrawingContext, type FormatLength, Frame, type LabelBox, type LengthDimension, Padding, Sheet, type Side, Theme, type ToolDimensions, ToolDrawing, type ToolDrawingProps, ViewerAssembly, type WidthDimension, bandOffset, bandRoom, dimensionLabel, dimensionLayout, dimensionsFor, figureHeight, figureType, formatMillimetres, laneOffset, stackLabels, useDrawingContext };
+export { type AngleDimension, type DimensionLane, type DrawingContext, Frame, type LaneLayout, type LaneRoom, type LengthDimension, Padding, Sheet, type Side, Theme, type ToolDimensions, ToolDrawing, type ToolDrawingProps, ViewerAssembly, type WidthDimension, dimensionsFor, laneLayout, laneOffset, laneRoom, useDrawingContext };