@toolpath/dfm 0.3.1 → 0.5.0

package/dist/{feature-record-BUoFFjN6.d.ts → feature-record-CfjgDCJU.d.ts}

@@ -1,99 +1,3 @@
-/** The unit a length is shown in. The Engine's meshes are always millimetres. */
-type Units = 'mm' | 'inch';
-
-/**
- * At or above, above, at or below, below, equal, not equal, or between —
- * equal meaning within half a percent, since figures are measured, and not
- * equal anything further off; between from a low end up to, not including, a
- * high one.
- */
-type DfmOp = 'gte' | 'gt' | 'lte' | 'lt' | 'eq' | 'ne' | 'between';
-/**
- * How a figure is read and typed: a length (mm), an area (mm²), an angle
- * (degrees), a plain ratio, a count, a percentage, yes/no, or — for "any
- * size" — nothing at all.
- */
-type DfmQuantity = 'length' | 'area' | 'angle' | 'ratio' | 'count' | 'percent' | 'flag' | 'presence';
-/** A datasheet's `facts.kind`: which family of measurements the Engine took. */
-type FactsKind = 'Hole' | 'Pocket' | 'Boss' | 'Wall' | 'Face' | 'Three' | 'Chamfer' | 'Profile' | 'Dovetail' | 'Tslot';
-interface DfmMetric {
-    key: string;
-    /** As the rule sentence reads it: "L/D", "depth below top". */
-    label: string;
-    /** The heading it is listed under when choosing. */
-    group: string;
-    quantity: DfmQuantity;
-    /** Which way is worse, for a new rule: deep is bad (≥), a tiny corner is bad (≤). */
-    op: DfmOp;
-    /** What a new rule starts at: millimetres and inches kept apart, so both read as round numbers. */
-    start: Record<Units, number>;
-    /** What it means, in a few plain words. */
-    hint: string;
-    /** The kinds of datasheet that report it; every kind when left out. */
-    kinds?: readonly FactsKind[];
-    /**
-     * Where it sits in the datasheet, first found wins: a chamfer keeps its
-     * cutter band under its surface reading (`facts.three.cd`). Left out for a
-     * measure worked out rather than read (see `dfm-flags.ts`).
-     */
-    path?: readonly string[];
-    /** Whether a rule may name a value below zero: a height, or a signed radius. */
-    signed?: true;
-}
-
-/** How a range holds its low end: at or above it, or above it. */
-type RangeLow = 'gte' | 'gt';
-/** How a range holds its high end: below it, or at or below it. */
-type RangeHigh = 'lt' | 'lte';
-interface DfmRule {
-    /** Stable, so a list can key its rows and a feature can name the rule it broke. */
-    id: string;
-    /** Which features: a value from {@link FEATURE_SUBJECTS}. */
-    subject: string;
-    /** What is measured: a key from {@link FEATURE_METRICS}. */
-    metric: string;
-    op: DfmOp;
-    /** Canonical — mm or a ratio. Ignored by a yes/no metric. The low end of a range. */
-    value: number;
-    /** A range's high end. Only a `between` rule has one. */
-    max?: number;
-    /** How a range holds its low end; ≥ where unsaid. Only a `between` rule has one. */
-    lowOp?: RangeLow;
-    /** How a range holds its high end; < where unsaid. Only a `between` rule has one. */
-    highOp?: RangeHigh;
-    /** `#rrggbb`: what the features that break it are painted. */
-    color: string;
-}
-/**
- * The colours a rule can wear: vivid, and far enough apart in hue and
- * lightness to tell apart on the part at a glance (no two closer than ΔE 37,
- * and none within 50 of the selection's blue). Warm first, since most
- * rules call out trouble; then cool ones for a rule that marks something
- * good.
- */
-declare const RULE_COLORS: readonly {
-    name: string;
-    value: string;
-}[];
-/**
- * Which colour shows where a feature breaks rules of two: the one earliest in
- * the palette, so red over yellow. Colours from outside it come after, in an
- * order of their own, so a tie never falls back on the list.
- */
-declare const compareColors: (a: string, b: string) => number;
-/** The quoting app's two severities, as the colours a rule starts in. */
-declare const CRITICAL_COLOR = "#e5484d";
-declare const WARNING_COLOR = "#ffd60a";
-/**
- * A rule as one plain line: "Holes with L/D ≥ 8", "Holes with 4 ≤ L/D < 8",
- * "Any feature with a sharp inside corner", "Undercut T-slots, any size".
- */
-declare const describeRule: (rule: DfmRule, units: Units) => string;
-/** A new rule for a subject and metric, at the metric's own starting value in the reader's units. */
-declare const makeRule: (subject: string, metricKey: string, units: Units, color?: string) => DfmRule;
-/** Stored rules, the ones that read; null when what is stored is not a list at all. */
-declare const parseRules: (raw: unknown) => DfmRule[] | null;
-
 /**
  * Where a feature is at its tightest (the datasheet's `pinchPoints`, API
  * 1.12.1): one disc per stretch of the feature that reaches its minimum
@@ -232,6 +136,38 @@ interface FeatureSheet {
     noToolFits?: true;
     /** For a hole the model threads: its thread. */
     threading?: FeatureThreading;
+    /** For an undercut — a T-slot or a dovetail: what its cutter is held to. */
+    undercut?: FeatureUndercut;
+}
+/**
+ * An undercut's own figures, from its `facts`: a T-slot's or a dovetail's.
+ * Millimetres and degrees. Each is left out where the Engine did not measure
+ * it, or where nothing limits it.
+ */
+interface FeatureUndercut {
+    /** T-slot: how far the groove runs back from its opening, radially (`facts.undercutDepth`). */
+    undercutDepth?: number;
+    /**
+     * T-slot: the widest tool that comes down through the opening above it
+     * (`facts.maxEntryCd`), which holds the cutter's shaft. Left out where
+     * nothing above limits it; zero where nothing fits.
+     */
+    maxEntry?: number;
+    /** Dovetail: between the overhanging wall and the tool axis, degrees (`facts.taperDeg`). */
+    taperDeg?: number;
+    /** Dovetail: the widest clearance over the floor, the width the groove cuts at. */
+    floorWidth?: number;
+    /** Dovetail: the clearance through the opening at the top of the groove. */
+    topOpeningWidth?: number;
+    /** Dovetail: the groove's widths vary from place to place — it runs out somewhere. */
+    isExternal?: true;
+    /** T-slot: its walls close on themselves in plan view, so a cutter's head comes down through its opening. */
+    isClosed?: true;
+    /**
+     * The Engine could not measure it (`facts.isInvalidGeometry` or
+     * `facts.cd.measurementFailed`), so its figures offer no cutter.
+     */
+    unmeasured?: true;
 }
 /** A modelled thread, from a hole's `facts.threading`. Millimetres. */
 interface FeatureThreading {
@@ -281,6 +217,163 @@ declare const dfmFeatures: (features: readonly ReportFeature[]) => DfmFeature[];
 /** `through_hole` as `Through hole`. The Engine's feature types are open-ended snake case. */
 declare const featureTypeLabel: (featureType: string) => string;
 
+/** A turning datasheet's `facts.kind`, and `Unknown` for a stretch the Engine could not name. */
+type TurnedFactsKind = 'AxialHole' | 'Face' | 'FaceGroove' | 'FaceProfile' | 'IdGroove' | 'IdProfile' | 'IdThread' | 'OdGroove' | 'OdProfile' | 'OdThread' | 'Unknown';
+/**
+ * `od_groove` as `OD groove`, `axial_hole` as `Axial hole`. The Engine's
+ * turned feature types are open-ended snake case, so a type it adds later
+ * reads as its words.
+ */
+declare const turnedTypeLabel: (featureType: string) => string;
+/** Turning rules: the measures and subjects of the Engine's turned features. */
+declare const TURNING_RULES: RuleVocabulary;
+
+/** The unit a length is shown in. The Engine's meshes are always millimetres. */
+type Units = 'mm' | 'inch';
+
+/**
+ * At or above, above, at or below, below, equal, not equal, or between —
+ * equal meaning within half a percent, since figures are measured, and not
+ * equal anything further off; between from a low end up to, not including, a
+ * high one.
+ */
+type DfmOp = 'gte' | 'gt' | 'lte' | 'lt' | 'eq' | 'ne' | 'between';
+/**
+ * How a figure is read and typed: a length (mm), an area (mm²), an angle
+ * (degrees), a plain ratio, a count, a percentage, yes/no, or — for "any
+ * size" — nothing at all.
+ */
+type DfmQuantity = 'length' | 'area' | 'angle' | 'ratio' | 'count' | 'percent' | 'flag' | 'presence';
+/** A datasheet's `facts.kind`: which family of measurements the Engine took. */
+type FactsKind = 'Hole' | 'Pocket' | 'Boss' | 'Wall' | 'Face' | 'Three' | 'Chamfer' | 'Profile' | 'Dovetail' | 'Tslot';
+/** A datasheet's `facts.kind`, milled or turned. */
+type AnyFactsKind = FactsKind | TurnedFactsKind;
+interface DfmMetric {
+    key: string;
+    /** As the rule sentence reads it: "L/D", "depth below top". */
+    label: string;
+    /** The heading it is listed under when choosing. */
+    group: string;
+    quantity: DfmQuantity;
+    /** Which way is worse, for a new rule: deep is bad (≥), a tiny corner is bad (≤). */
+    op: DfmOp;
+    /** What a new rule starts at: millimetres and inches kept apart, so both read as round numbers. */
+    start: Record<Units, number>;
+    /** What it means, in a few plain words. */
+    hint: string;
+    /** The kinds of datasheet that report it; every kind when left out. */
+    kinds?: readonly AnyFactsKind[];
+    /**
+     * Where it sits in the datasheet, first found wins: a chamfer keeps its
+     * cutter band under its surface reading (`facts.three.cd`). Left out for a
+     * measure worked out rather than read (see `dfm-flags.ts`).
+     */
+    path?: readonly string[];
+    /** Whether a rule may name a value below zero: a height, or a signed radius. */
+    signed?: true;
+}
+interface DfmSubject {
+    value: string;
+    /** Plural, as the rule sentence starts: "Holes", "Undercut T-slots". */
+    label: string;
+    /** "Groups" or "Feature types", for choosing. */
+    group: string;
+    /** The datasheet kinds its features report; every kind when left out. */
+    kinds?: readonly AnyFactsKind[];
+}
+/** Which kind of machining a set of rules is about: a milled part's features, or a turned part's. */
+type RuleProcess = 'milling' | 'turning';
+/**
+ * Everything a set of rules can say, for one process: its measures, its
+ * subjects, the short lists offered first, and how a feature that breaks a
+ * rule is named in a list. Pure data, so the editor, the checker and the
+ * rule-set file read milling and turning rules the same way.
+ */
+interface RuleVocabulary {
+    process: RuleProcess;
+    metrics: readonly DfmMetric[];
+    subjects: readonly DfmSubject[];
+    quickSubjects: readonly string[];
+    quickMetrics: readonly string[];
+    /** What a new or moved rule falls back on when its own measure is unknown: L/D for milling, "any size" for turning. */
+    fallbackMetric: DfmMetric;
+    /**
+     * A feature as a list or the feature panel names it: `{ name: 'Blind hole',
+     * detail: 'from +Z' }`, or for a turned one `{ name: 'OD groove', detail:
+     * 'from both ends' }`. The detail follows "Machined" in the feature panel.
+     */
+    featureLabel: (feature: Pick<DfmFeature, 'featureType' | 'machiningDirection'>) => {
+        name: string;
+        detail: string;
+    };
+    /** The feature panel's heading over what a feature asks of the machining: `Milling considerations`. */
+    considerationsTitle: string;
+    /** What an exported set is saved as. */
+    fileName: string;
+}
+/** Milling rules: the measures and subjects above, which the Engine's milled features report. */
+declare const MILLING_RULES: RuleVocabulary;
+
+/** How a range holds its low end: at or above it, or above it. */
+type RangeLow = 'gte' | 'gt';
+/** How a range holds its high end: below it, or at or below it. */
+type RangeHigh = 'lt' | 'lte';
+interface DfmRule {
+    /** Stable, so a list can key its rows and a feature can name the rule it broke. */
+    id: string;
+    /** Which features: a value from its vocabulary's subjects — `FEATURE_SUBJECTS` for milling. */
+    subject: string;
+    /** What is measured: a key from its vocabulary's metrics — `FEATURE_METRICS` for milling. */
+    metric: string;
+    op: DfmOp;
+    /** Canonical — mm or a ratio. Ignored by a yes/no metric. The low end of a range. */
+    value: number;
+    /** A range's high end. Only a `between` rule has one. */
+    max?: number;
+    /** How a range holds its low end; ≥ where unsaid. Only a `between` rule has one. */
+    lowOp?: RangeLow;
+    /** How a range holds its high end; < where unsaid. Only a `between` rule has one. */
+    highOp?: RangeHigh;
+    /** `#rrggbb`: what the features that break it are painted. */
+    color: string;
+}
+/**
+ * The colours a rule can wear: vivid, and far enough apart in hue and
+ * lightness to tell apart on the part at a glance (no two closer than ΔE 37,
+ * and none within 50 of the selection's blue). Warm first, since most
+ * rules call out trouble; then cool ones for a rule that marks something
+ * good.
+ */
+declare const RULE_COLORS: readonly {
+    name: string;
+    value: string;
+}[];
+/**
+ * Which colour shows where a feature breaks rules of two: the one earliest in
+ * the palette, so red over yellow. Colours from outside it come after, in an
+ * order of their own, so a tie never falls back on the list.
+ */
+declare const compareColors: (a: string, b: string) => number;
+/** The quoting app's two severities, as the colours a rule starts in. */
+declare const CRITICAL_COLOR = "#e5484d";
+declare const WARNING_COLOR = "#ffd60a";
+/**
+ * A rule as one plain line: "Holes with L/D ≥ 8", "Holes with 4 ≤ L/D < 8",
+ * "Any feature with a sharp inside corner", "Undercut T-slots, any size".
+ */
+declare const describeRule: (rule: DfmRule, units: Units, vocabulary?: RuleVocabulary) => string;
+/**
+ * A new rule for a subject and metric, at the metric's own starting value in
+ * the reader's units. A metric the vocabulary does not know is its fallback.
+ */
+declare const makeRule: (subject: string, metricKey: string, units: Units, color?: string, vocabulary?: RuleVocabulary) => DfmRule;
+/**
+ * Stored rules, the ones that read in this vocabulary — a turning rule is
+ * dropped as milling reads it, and the other way round; null when what is
+ * stored is not a list at all.
+ */
+declare const parseRules: (raw: unknown, vocabulary?: RuleVocabulary) => DfmRule[] | null;
+
 /** What the checks read of the part, beyond its features. */
 interface DfmSources {
     /** Each feature's measurements, cut down (`feature-sheet.ts`), by lower-cased tag. */
@@ -432,8 +525,11 @@ interface BrokenRule {
     /** On hover: the rule written out, and why it matters. */
     readonly note?: string;
 }
-/** The rules a feature breaks, as its details list them: one a measure, the worst, palette first. */
-declare const brokenRules: (check: DfmCheck, tag: string, units: Units) => BrokenRule[];
+/**
+ * The rules a feature breaks, as its details list them: one a measure, the
+ * worst, palette first, each written in the vocabulary its rules are in.
+ */
+declare const brokenRules: (check: DfmCheck, tag: string, units: Units, vocabulary?: RuleVocabulary) => BrokenRule[];
 /**
  * The colour a feature is painted on the part: the one earliest in the
  * palette of the rules it breaks, for a required feature. Read from a face
@@ -500,4 +596,4 @@ interface FeatureRecord {
     readonly datasheet: unknown;
 }
 
-export { featureColor as A, type BrokenRule as B, CRITICAL_COLOR as C, type DfmRule as D, featureMeasurements as E, type FeatureSheets as F, featureProfile as G, featureSheet as H, featureTypeLabel as I, isNoReading as J, isSurfaceType as K, makeRule as L, type Measurement as M, maxBallDiameter as N, parseRules as O, PINCH_TOOL_MM as P, peakHeight as Q, type ReachCurve as R, type SurfaceToolKind as S, readPinch as T, type Units as U, readReachCurve as V, WARNING_COLOR as W, runStart as X, trimmedCurve as Y, withSurroundedFaces as Z, type DfmCheck as a, type DfmFeature as b, type FeatureProfile as c, type FeatureRecord as d, type DfmHit as e, type FeaturePinch as f, type FeatureSheet as g, type ClearanceFit as h, type DfmMetric as i, type DfmOp as j, type DfmQuantity as k, type DfmSources as l, type FactsKind as m, type FeatureAcross as n, type FeatureThreading as o, type PinchDisc as p, RULE_COLORS as q, type RangeHigh as r, type RangeLow as s, type ReportFeature as t, type RuleResult as u, brokenRules as v, checkPart as w, compareColors as x, describeRule as y, dfmFeatures as z };
+export { peakHeight as $, type TurnedFactsKind as A, type BrokenRule as B, CRITICAL_COLOR as C, type DfmRule as D, brokenRules as E, type FeatureSheets as F, checkPart as G, compareColors as H, describeRule as I, dfmFeatures as J, featureColor as K, featureMeasurements as L, type Measurement as M, featureProfile as N, featureSheet as O, PINCH_TOOL_MM as P, featureTypeLabel as Q, type RuleVocabulary as R, type SurfaceToolKind as S, TURNING_RULES as T, type Units as U, isNoReading as V, WARNING_COLOR as W, isSurfaceType as X, makeRule as Y, maxBallDiameter as Z, parseRules as _, type DfmCheck as a, readPinch as a0, readReachCurve as a1, runStart as a2, trimmedCurve as a3, turnedTypeLabel as a4, withSurroundedFaces as a5, type DfmFeature as b, type ReachCurve as c, type FeatureProfile as d, type FeatureRecord as e, MILLING_RULES as f, type RuleProcess as g, type DfmHit as h, type FeaturePinch as i, type FeatureSheet as j, type ClearanceFit as k, type DfmMetric as l, type DfmOp as m, type DfmQuantity as n, type DfmSources as o, type DfmSubject as p, type FactsKind as q, type FeatureAcross as r, type FeatureThreading as s, type FeatureUndercut as t, type PinchDisc as u, RULE_COLORS as v, type RangeHigh as w, type RangeLow as x, type ReportFeature as y, type RuleResult as z };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as react from 'react';
 import { ReactNode, FC, KeyboardEvent, Ref, ComponentType, ReactElement, HTMLAttributes } from 'react';
-import { D as DfmRule, a as DfmCheck, b as DfmFeature, F as FeatureSheets, U as Units, R as ReachCurve, c as FeatureProfile, B as BrokenRule, M as Measurement, d as FeatureRecord } from './feature-record-BUoFFjN6.js';
+import { D as DfmRule, a as DfmCheck, b as DfmFeature, F as FeatureSheets, U as Units, R as RuleVocabulary, c as ReachCurve, d as FeatureProfile, B as BrokenRule, M as Measurement, e as FeatureRecord } from './feature-record-CfjgDCJU.js';
+export { f as MILLING_RULES, g as RuleProcess, T as TURNING_RULES } from './feature-record-CfjgDCJU.js';
 
 /**
  * The rules the list shows, and how to change them. The app owns them —
@@ -32,6 +33,12 @@ interface RuleListProps {
     selectedGroup: readonly string[] | null;
     onInspect: (tag: string, group?: readonly string[]) => void;
     onHover: (hovered: Hovered) => void;
+    /**
+     * What the rules can say, and how a broken feature is named: `MILLING_RULES`
+     * where left out, `TURNING_RULES` for a turned part — whose `features` are
+     * its stretches (`turnedStretches`) and whose `sheets` are `{}`.
+     */
+    vocabulary?: RuleVocabulary;
     /**
      * At the end of the footer's row, after Copy LLM prompt: the app's own
      * buttons — a way back to its default rules, say.
@@ -234,6 +241,11 @@ interface FeatureDetailsProps {
     PopOut?: PopOutWindow;
     look?: FeaturePanelLook;
     folds?: FoldStore;
+    /**
+     * Which process the feature is read for: how it is named, the way it is cut
+     * from, and the heading over its considerations. Milling where left out.
+     */
+    vocabulary?: RuleVocabulary;
 }
 /**
  * One feature, as the Engine read it: its name and the way it is machined
@@ -289,6 +301,8 @@ interface CandidateListProps {
     face?: ComparedFaceList;
     look?: FeaturePanelLook;
     folds?: FoldStore;
+    /** How the rows' features are named: milling where left out. */
+    vocabulary?: RuleVocabulary;
 }
 /**
  * Every feature a clicked face belongs to, as rows to choose between: its
@@ -355,6 +369,8 @@ interface FeaturePanelProps {
     className?: string;
     look?: FeaturePanelLook;
     folds?: FoldStore;
+    /** How the candidates are named: milling where left out (see `FeatureDetails`). */
+    vocabulary?: RuleVocabulary;
     /** The active face's feature: its `<FeatureDetails>`. */
     children?: ReactNode;
 }
@@ -370,4 +386,4 @@ interface FeaturePanelProps {
  */
 declare const FeaturePanel: FC<FeaturePanelProps>;
 
-export { CandidateList, type CandidateListProps, type CandidateRow, type ComparedFace, type ComparedFaceList, ComparisonTable, type ComparisonTableProps, type DfmRules, FeatureDetails, type FeatureDetailsProps, type FeatureIdentity, FeaturePanel, type FeaturePanelLook, type FeaturePanelProps, type FoldStore, type Hovered, type InspectedFace, type Loadable, type PopOutId, type PopOutWindow, type PopOutWindowProps, ReachChart, type ReachChartProps, ReachDrawing, RuleList, type RuleListProps, Swatch, type SwatchProps, candidateListKeys, isField, listKeys, ruleListKeys, storageFolds };
+export { CandidateList, type CandidateListProps, type CandidateRow, type ComparedFace, type ComparedFaceList, ComparisonTable, type ComparisonTableProps, type DfmRules, FeatureDetails, type FeatureDetailsProps, type FeatureIdentity, FeaturePanel, type FeaturePanelLook, type FeaturePanelProps, type FoldStore, type Hovered, type InspectedFace, type Loadable, type PopOutId, type PopOutWindow, type PopOutWindowProps, ReachChart, type ReachChartProps, ReachDrawing, RuleList, type RuleListProps, RuleVocabulary, Swatch, type SwatchProps, candidateListKeys, isField, listKeys, ruleListKeys, storageFolds };