@toolpath/dfm 0.0.0-stage → 0.1.0

package/dist/model/index.d.ts

@@ -0,0 +1,109 @@
+import { d as DfmHit, U as Units, b as DfmFeature, F as FeatureSheets, e as FeatureSheet, D as DfmRule } from '../reach-CfmYU_yQ.js';
+export { C as CRITICAL_COLOR, f as ClearanceFit, a as DfmCheck, g as DfmMetric, h as DfmOp, i as DfmQuantity, j as DfmSources, k as FactsKind, l as FeatureAcross, m as FeaturePinch, c as FeatureProfile, n as FeatureThreading, P as PINCH_TOOL_MM, o as PinchDisc, p as RULE_COLORS, q as RangeHigh, r as RangeLow, R as ReachCurve, s as ReportFeature, t as RuleResult, W as WARNING_COLOR, u as checkPart, v as compareColors, w as describeRule, x as dfmFeatures, y as featureProfile, z as featureSheet, A as featureTypeLabel, B as isNoReading, E as makeRule, G as parseRules, H as peakHeight, I as readPinch, J as readReachCurve, K as runStart, L as trimmedCurve, M as withSurroundedFaces } from '../reach-CfmYU_yQ.js';
+
+/** The figure that broke a rule, bare: `7.5`, `0.05"`. Empty for a yes/no or "any size". */
+declare const hitFigure: (hit: DfmHit, units: Units) => string;
+
+/** One row of a feature's details. */
+interface Measurement {
+    /** Stable, so a list can key its rows. */
+    readonly key: string;
+    readonly label: string;
+    readonly value: string;
+    /** The same number in the other unit. Absent on a ratio or a count. */
+    readonly alt?: string;
+    /**
+     * How it was worked out from the datasheet, a line at a time: the fields it
+     * reads, by their path in the raw record, and the arithmetic, in the
+     * Engine's millimetres.
+     */
+    readonly derivation: readonly string[];
+    /**
+     * A machining consideration rather than a measurement of the feature's own
+     * shape: the tool that cuts it, and how far it has to reach. The panel lists
+     * these under their own heading, for every kind of feature.
+     */
+    readonly milling?: true;
+    /** A row that stands for a tool the viewer can draw on the part, by its kind. */
+    readonly tool?: SurfaceToolKind;
+}
+/** Which of a surface's finishing tools: a ball nose, or a bull nose with a flat between its corners. */
+type SurfaceToolKind = 'ball' | 'bull';
+/** Whether a feature type is read as a surface: see `SURFACE_TYPES`. */
+declare const isSurfaceType: (featureType: string) => boolean;
+/**
+ * The biggest ball nose a surface admits, mm: a ball's corner radius is half
+ * its diameter, so it is held under the tool fit's diameter and corner radius
+ * at once. None where the surface reports no fit, or admits no corner at all.
+ */
+declare const maxBallDiameter: (sheet: Pick<FeatureSheet, "fitToolDiameter" | "fitCornerRadius">) => number | undefined;
+/**
+ * The rows a feature gets, in {@link ROW_ORDER}: its own geometry first, then
+ * where it sits in the part and the reach that makes, then the tools a
+ * surface admits. A row is left out rather than shown empty: "—" against a
+ * field this kind never reports reads as a measurement that failed.
+ */
+declare const featureMeasurements: ({ features, feature, sheets, units, }: {
+    features: readonly DfmFeature[];
+    feature: DfmFeature;
+    sheets: FeatureSheets;
+    units: Units;
+}) => Measurement[];
+
+/** Whether two depths are one depth, as the quoting app counts them: within a twentieth, or a hundredth of a mm. */
+declare const sameDepth: (a: number, b: number) => boolean;
+
+/**
+ * A set of DFM rules as a file: what Export writes, Import reads, and what
+ * an LLM is asked to produce. One JSON object, so a shop can keep a set per
+ * customer or material, send one to a colleague, or have one written for
+ * them from a conversation.
+ *
+ * Values are canonical, as the rules are stored: millimetres, square
+ * millimetres, degrees, plain ratios. A file says so in `units`, so a reader
+ * is never left guessing, and so a later version can accept inches.
+ */
+interface RuleSetFile {
+    /** What this file is. Always `toolpath-dfm-rules`. */
+    kind: typeof FILE_KIND;
+    /** The file format's version, for a later reader. */
+    version: 1;
+    /** What the set is for: "Aluminium prototypes", "Acme Corp sheet work". */
+    name?: string;
+    description?: string;
+    /** The unit every length in `rules` is in. Only millimetres are written or read today. */
+    units: 'mm';
+    rules: DfmRule[];
+}
+declare const FILE_KIND = "toolpath-dfm-rules";
+/** The rules as a file, pretty-printed. */
+declare const serializeRuleSet: (rules: readonly DfmRule[], meta?: {
+    name?: string;
+    description?: string;
+}) => string;
+/**
+ * The rules in a file, or the reason it cannot be read. Lenient about the
+ * wrapper — a bare array of rules is accepted, and so is an object with a
+ * `rules` list and nothing else, since an LLM may well hand back either —
+ * strict about every rule, which `parseRules` checks field by field. Rules
+ * without an id, or whose ids collide, are given fresh ones. A file that says
+ * its lengths are in anything but millimetres is refused rather than read as
+ * millimetres; one that does not say is read as millimetres.
+ */
+declare const parseRuleSetFile: (text: string) => {
+    rules: DfmRule[];
+    skipped: number;
+    name?: string;
+} | {
+    error: string;
+};
+/**
+ * A prompt that lets any LLM interview a user and write a rule set this
+ * viewer reads. Built from the metric and subject tables themselves, so it
+ * never drifts from what the parser accepts: every subject value, every
+ * metric key with its unit and meaning and the kinds of feature that report
+ * it, every comparison, and the palette.
+ */
+declare const llmRulePrompt: (current?: readonly DfmRule[]) => string;
+
+export { DfmFeature, DfmHit, DfmRule, FILE_KIND, FeatureSheet, FeatureSheets, type Measurement, type RuleSetFile, type SurfaceToolKind, Units, featureMeasurements, hitFigure, isSurfaceType, llmRulePrompt, maxBallDiameter, parseRuleSetFile, sameDepth, serializeRuleSet };