@toolpath/dfm 0.5.0 → 1.0.0

package/dist/index.d.ts

@@ -1,389 +1 @@
-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 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 —
- * where they are kept, and what they start as — so the list works on any
- * store and ships no rules of its own.
- */
-interface DfmRules {
-    rules: readonly DfmRule[];
-    /** Adds a rule at the end of the list. */
-    add: (rule: DfmRule) => void;
-    /** Replaces the rule with the same id. */
-    update: (rule: DfmRule) => void;
-    remove: (id: string) => void;
-    /** Puts an imported set in place of the list. */
-    replace: (rules: readonly DfmRule[]) => void;
-}
-/** The feature, or group of holes, the pointer is over in a list; null for none. */
-type Hovered = string | readonly string[] | null;
-interface RuleListProps {
-    rules: DfmRules;
-    /** The part checked against the rules; null while the analysis runs. */
-    check: DfmCheck | null;
-    features: readonly DfmFeature[] | null;
-    sheets: FeatureSheets | null;
-    units: Units;
-    /** The feature being inspected, marked in the lists. */
-    selected: string | null;
-    /** The group of holes being inspected, if one is. */
-    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.
-     */
-    actions?: ReactNode;
-}
-
-/**
- * The rule list's keys: put them on the whole panel that holds the list, so
- * the arrow keys work from its header and buttons too.
- */
-declare const ruleListKeys: (event: react.KeyboardEvent<HTMLElement>) => void;
-/**
- * The rules, one row each, each written as the sentence it is — "Holes with
- * L/D ≥ 8" — whose words are its fields: change the features, the measure,
- * the comparison or the number in place, with no form to open. The sentence
- * wraps rather than cuts off, so the whole rule always reads.
- *
- * Beside it, the rule's colour and how many required features break it; the
- * count opens to those features, identical holes gathered into one row as
- * the quoting app gathers them. Choosing one inspects it.
- *
- * Up and down walk the rules and the features of any that are open, a
- * feature highlighting as it is reached; right opens a rule (or a group of
- * holes) and left shuts it, or from a feature goes back up. Tab moves
- * through a rule's words.
- *
- * The rules come from the app, which keeps them and decides what they start as.
- */
-declare const RuleList: FC<RuleListProps>;
-
-interface SwatchProps {
-    color: string;
-    label?: string;
-    onClick?: () => void;
-    onKeyDown?: (event: KeyboardEvent<HTMLButtonElement>) => void;
-    /** The list the swatch is a row of, for the arrow keys (see `list-keys.ts`). */
-    listItem?: string;
-    className?: string;
-    ref?: Ref<HTMLButtonElement>;
-}
-/** A rule's colour, as a dot, one that can be clicked where it can be changed. */
-declare const Swatch: FC<SwatchProps>;
-
-/**
- * Arrow keys through a list, for every list on the page: the rules, a rule's
- * features, a face's candidate features, the colour swatches.
- *
- * A list's rows are the elements marked `data-list-item` with the list's
- * name, found afresh on each key in the order they are drawn, so rows that
- * are shut or not mounted are passed over. Up and down (left and right, for
- * a row of swatches) move one row, Home and End to either end. A row marked
- * `data-follow` is chosen as it is reached, as a click would — for rows
- * whose choosing only highlights, so walking the list shows each in turn.
- * From outside the rows (a panel's header, its buttons), the first key goes
- * to the chosen row (`aria-pressed`) — or on from it, for a followed row,
- * which is already showing — else to the end it points toward.
- *
- * Keys typed into a field are the field's: a select's own arrows, a number
- * being edited.
- */
-declare const listKeys: (name: string, orientation?: "vertical" | "horizontal") => (event: KeyboardEvent<HTMLElement>) => void;
-/** A control that uses the arrow keys itself. A colour well does not. */
-declare const isField: (target: EventTarget | null) => boolean;
-
-interface ReachChartProps {
-    /** The feature's reach curve, whole: the chart trims it past full height itself. */
-    curve: ReachCurve;
-    units: Units;
-    /**
-     * The feature beside its walls: drawn to its own width where known, though
-     * the width is not written on the drawing, because the curve is read out
-     * from the wall and the feature across is no part of it. Its depth is
-     * marked, being on the same scale as the walls' heights; a through feature
-     * has no floor.
-     */
-    feature: FeatureProfile;
-}
-
-/**
- * The section alone, as a panel shows it: dimensioned, as wide as the panel
- * gives it.
- */
-declare const ReachChart: FC<ReachChartProps>;
-/** A larger window's contents: the section, large, with what it is and how to read it. */
-declare const ReachDrawing: FC<ReachChartProps>;
-
-/**
- * Where the feature panel keeps which of its sections are open, so a section
- * put away stays away from one feature to the next, and from one visit to the
- * next. The app supplies it: the package stores nothing of its own.
- *
- * Sections are named by fixed ids — `rules`, `measurements`, `milling`,
- * `reach`, `datasheet`, `raw`, `comparison`, `candidates`, and `candidates-A`,
- * `candidates-B`… while comparing faces.
- */
-interface FoldStore {
-    /** Whether a section was left open; undefined for one never folded, which then opens as it starts. */
-    read: (id: string) => boolean | undefined;
-    write: (id: string, open: boolean) => void;
-}
-/**
- * A fold store over a `Storage` — `localStorage`, `sessionStorage` — under a
- * key prefix of the app's: `toolpath.fold.` keeps `toolpath.fold.reach` as
- * `open` or `shut`. A storage that is missing, or that refuses (a private
- * window, say), leaves the sections folding for as long as they are mounted.
- */
-declare const storageFolds: (storage: Pick<Storage, "getItem" | "setItem"> | null | undefined, prefix: string) => FoldStore;
-
-/**
- * How the feature panel looks where two apps want it to differ. Every field
- * left out takes the first value, which is the CAD viewer's look.
- */
-interface FeaturePanelLook {
-    /**
-     * A broken rule: `sentence` — the rule written out, the figure that broke it
-     * in grey; or `result` — a short label, the figure in the rule's colour, and
-     * the line it crossed, faded.
-     */
-    rules?: 'sentence' | 'result';
-    /** The chosen candidate: `grey` and bold, or an `info` blue border and tint. */
-    selected?: 'grey' | 'info';
-    /** Secondary text: `pale` grey, or a `strong` grey that reads at full contrast. */
-    muted?: 'pale' | 'strong';
-}
-
-/** What the panel needs to name a feature: its tag, its type, and the way it is machined from. */
-type FeatureIdentity = Pick<DfmFeature, 'tag' | 'featureType' | 'machiningDirection'>;
-/**
- * Something the app reads for the panel, and how far it has got: the panel
- * says what it is waiting on, or what went wrong, in place of the section.
- */
-type Loadable<T> = {
-    readonly status: 'loading';
-} | {
-    readonly status: 'error';
-    /** In the app's own words: the API's answer, or that it asked to wait. */
-    readonly message: string;
-    /** Reads it again; left out, there is no Retry. */
-    readonly retry?: () => void;
-    /** No Retry before this, in `Date.now()` milliseconds: what a 429's `Retry-After` asks. */
-    readonly retryAt?: number;
-} | {
-    readonly status: 'ready';
-    readonly value: T;
-};
-/** Which of a feature's sections pops out into a window of its own. */
-type PopOutId = 'reach' | 'datasheet' | 'raw';
-/**
- * The app's window for a section popped out of the panel. The panel decides
- * when one is open and what is in it; the app draws the frame — moved and
- * sized as its page allows — and calls `onClose`. Define it once, at module
- * level: one written inline remounts the window on every render. Render it
- * through a portal to the page's body: the panel blurs what is behind it,
- * which makes the panel the box a `fixed` window inside it is placed in.
- */
-interface PopOutWindowProps {
-    id: PopOutId;
-    title: string;
-    /** Under the title: the feature it is of. */
-    subtitle: ReactNode;
-    icon: ReactElement;
-    /** In the header, before the close button: a copy button, say. */
-    action?: ReactNode;
-    onClose: () => void;
-    children: ReactNode;
-}
-type PopOutWindow = ComponentType<PopOutWindowProps>;
-
-interface FeatureDetailsProps {
-    feature: FeatureIdentity;
-    /** Lengths in the reach chart; every other figure comes in written. */
-    units: Units;
-    /** The colour of the feature's machining direction, as the part shows it: any CSS colour. */
-    directionColor: string;
-    /** The feature beside its walls, for the reach chart: `featureProfile` of its sheet. */
-    profile: FeatureProfile;
-    /** In place of the feature's type: `Through hole ⌀ 6.35`. */
-    label?: ReactNode;
-    /** A feature the plan cannot do without: shows the REQUIRED pill. Left out, no pill. */
-    required?: boolean;
-    /** Turns the camera to the feature: shows a "Show this feature" button. */
-    onFrame?: () => void;
-    /** Right of the name: the app's own buttons. */
-    actions?: ReactNode;
-    /** At the end of the "Machined from" line: a folder badge, say. */
-    status?: ReactNode;
-    /** Under the title, before the sections: a sentence of the app's, its own action. */
-    children?: ReactNode;
-    /** The rules it breaks, as rows: see `brokenRules`. */
-    rules: readonly BrokenRule[];
-    /** Its measurements and milling considerations: `featureMeasurements`. */
-    measurements: Loadable<readonly Measurement[]>;
-    /** Its raw report entry and datasheet, for the reach chart. Null where the app has none. */
-    record: Loadable<FeatureRecord | null>;
-    /**
-     * The app's window, to pop the reach, the datasheet fields and the raw
-     * record out into, larger. Left out, there are no pop-out buttons.
-     */
-    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
- * from, then the rules it breaks, what was measured of it, what that asks of
- * the milling, and its reach.
- *
- * Then, shut until opened, every field of its datasheet and its raw API record,
- * to read or copy.
- *
- * Each section folds away under its heading. A section waiting on something
- * the app reads says so, and one whose read failed says why, with a Retry.
- */
-declare const FeatureDetails: FC<FeatureDetailsProps>;
-
-/**
- * Up, down, Home and End through the candidates: put them on whatever holds
- * the list — the whole panel, or just the list — as `ruleListKeys` is put on
- * the rules. Each row is chosen as it is reached.
- */
-declare const candidateListKeys: (event: react.KeyboardEvent<HTMLElement>) => void;
-/** One feature a face could have meant, as its row says it. */
-interface CandidateRow {
-    readonly feature: FeatureIdentity;
-    /** In place of the feature's type: `Blind hole ⌀ 6.35 × 4`. */
-    readonly label?: ReactNode;
-    /** The dot before it: the colour it is painted, or its direction's. Left out, a gap keeps the rows aligned. */
-    readonly color?: string;
-    /** How many rules it breaks: `2 rules`. */
-    readonly ruleCount?: number;
-    readonly required?: boolean;
-    /** Right-aligned in the row: the folder it is in, say. */
-    readonly detail?: ReactNode;
-    /** A second line under it: a note on how it overlaps another. */
-    readonly note?: ReactNode;
-    /** Beside the row, outside its button: the app's own action on it. */
-    readonly action?: ReactNode;
-}
-/** When comparing faces, which face this list is: its letter, and how to stop comparing it. */
-interface ComparedFaceList {
-    readonly index: number;
-    /** The face being read: its letter is filled. */
-    readonly active: boolean;
-    readonly onStop?: () => void;
-}
-interface CandidateListProps {
-    /** In the app's order: the first is what a click meant first. */
-    rows: readonly CandidateRow[];
-    selected: string | null;
-    onSelect: (tag: string) => void;
-    /** A row under the pointer, and leaving it: left out, the rows preview nothing. */
-    onHover?: (tag: string | null) => void;
-    /** While comparing faces: this list's face. */
-    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
- * colour, its name and the way it is machined from, how many rules it breaks,
- * whether it is required, and whatever the app adds. The keys walk them, each
- * chosen as it is reached; see {@link candidateListKeys}.
- */
-declare const CandidateList: FC<CandidateListProps>;
-
-/** One compared face: the feature it is read as, and what that feature is and measures. */
-interface ComparedFace {
-    /** Null for a face no feature owns. */
-    readonly feature: FeatureIdentity | null;
-    /** Its machining direction's colour, as the part shows it. */
-    readonly directionColor: string;
-    /** Whether it is required. Left out on every face, the Required row goes. */
-    readonly required?: boolean;
-    readonly rules: readonly BrokenRule[];
-    readonly measurements: readonly Measurement[];
-}
-interface ComparisonTableProps {
-    faces: readonly ComparedFace[];
-    /** The face being read, whose column head is marked. */
-    active: number;
-    /** A column head chosen: that face's feature, to read. */
-    onSelect: (tag: string, face: number) => void;
-    onHover?: (tag: string | null) => void;
-    look?: FeaturePanelLook;
-    folds?: FoldStore;
-}
-/**
- * What each compared face was read as, side by side: a column per face, its
- * feature at the head, and a row for each thing any of them has — its type,
- * the way it is machined from, whether it is required, the rules it breaks,
- * then every measurement. Rows where the readings disagree stand out; the rest
- * are greyed.
- */
-declare const ComparisonTable: FC<ComparisonTableProps>;
-
-/** One face being inspected: the features it could mean, and the one being read. */
-interface InspectedFace {
-    /** The face clicked; null for a feature chosen from a list, which has no candidates to show. */
-    readonly region: number | null;
-    /** In the app's order: see `CandidateList`. */
-    readonly rows: readonly CandidateRow[];
-    readonly selected: string | null;
-}
-interface FeaturePanelProps {
-    /** One face, or several while comparing. */
-    faces: readonly InspectedFace[];
-    /** Which face's feature the details are of. */
-    active: number;
-    /** A group of identical holes chosen together: how many, for the title. */
-    group?: number;
-    /** What each compared face was read as: the comparison table, while comparing. */
-    comparison?: readonly ComparedFace[];
-    onSelect: (tag: string, face: number) => void;
-    /** Takes a face out of the comparison. */
-    onDropFace?: (face: number) => void;
-    onHover?: (tag: string | null) => void;
-    onClose: () => void;
-    /** Spread on the header: an app's drag handle, say. */
-    headerProps?: HTMLAttributes<HTMLElement>;
-    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;
-}
-/**
- * The feature panel as a card: what a click on the part found — every feature
- * the face belongs to, then the details of the one being read — or, with
- * several faces shift-clicked, each face's candidates under a letter and a
- * comparison of what each was read as.
- *
- * It fills what it is put in: where the card sits, and whether it moves, is
- * the app's. Escape calls `onClose`, and the arrow keys walk the candidates
- * from anywhere in it.
- */
-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, RuleVocabulary, Swatch, type SwatchProps, candidateListKeys, isField, listKeys, ruleListKeys, storageFolds };
+export { BrokenRule, CRITICAL_COLOR, ClearanceFit, DfmCheck, DfmFeature, DfmHit, DfmMetric, DfmOp, DfmQuantity, DfmRule, DfmSources, DfmSubject, FILE_KIND, FaceTriangles, FactsKind, FeatureAcross, FeaturePinch, FeatureProfile, FeatureRecord, FeatureRow, FeatureSheet, FeatureSheets, FeatureThreading, FeatureUndercut, MAX_DATASHEET_FIELDS, MILLING_RULES, Measurement, OPS, PINCH_TOOL_MM, PRESENCE_METRIC, PinchDisc, PinchMark, PlacedTool, QUICK_SUBJECTS, RANGE_HIGHS, RANGE_LOWS, RULE_COLORS, RangeHigh, RangeLow, ReachCurve, ReportFeature, RuleProcess, RuleResult, RuleSetFile, RuleVocabulary, SurfaceToolKind, TURNING_RULES, TurnedFactsKind, TurnedReportFeature, TurnedStretch, Units, Vec3, WARNING_COLOR, brokenRules, checkPart, checkTurnedPart, compareColors, datasheetFields, describeRule, dfmFeatures, directionLabel, featureColor, featureMeasurements, featureProfile, featureRows, featureSheet, featureTypeLabel, formatMeasured, fromField, highOf, hitFigure, isNoReading, isSurfaceType, lengthValue, llmRulePrompt, lowOf, makeRule, maxBallDiameter, metricInfo, metricsForSubject, opSymbol, parseRuleSetFile, parseRules, peakHeight, pinchLabel, pinchMark, placePinchTool, quantityUnit, readPinch, readReachCurve, runStart, sameDepth, serializeRuleSet, subjectLabel, toField, trimmedCurve, turnedStretches, turnedTypeLabel, unitLabel, upperOf, withMetric, withOp, withSubject, withSurroundedFaces } from './model/index.js';