@toolpath/dfm 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+import * as react from 'react';
+import { FC, KeyboardEvent, Ref } from 'react';
+import { D as DfmRule, a as DfmCheck, b as DfmFeature, F as FeatureSheets, U as Units, R as ReachCurve, c as FeatureProfile } from './reach-CfmYU_yQ.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;
+}
+
+/**
+ * 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>;
+
+export { type DfmRules, type Hovered, ReachChart, type ReachChartProps, ReachDrawing, RuleList, type RuleListProps, Swatch, type SwatchProps, isField, listKeys, ruleListKeys };