@toolpath/dfm 0.0.0-stage → 0.2.0

package/dist/model/index.d.ts

@@ -0,0 +1,128 @@
+import { e as DfmHit, U as Units, f as FeaturePinch, g as FeatureSheet, D as DfmRule } from '../feature-record-BUoFFjN6.js';
+export { B as BrokenRule, C as CRITICAL_COLOR, h as ClearanceFit, a as DfmCheck, b as DfmFeature, i as DfmMetric, j as DfmOp, k as DfmQuantity, l as DfmSources, m as FactsKind, n as FeatureAcross, c as FeatureProfile, d as FeatureRecord, F as FeatureSheets, o as FeatureThreading, M as Measurement, P as PINCH_TOOL_MM, p as PinchDisc, q as RULE_COLORS, r as RangeHigh, s as RangeLow, R as ReachCurve, t as ReportFeature, u as RuleResult, S as SurfaceToolKind, W as WARNING_COLOR, v as brokenRules, w as checkPart, x as compareColors, y as describeRule, z as dfmFeatures, A as featureColor, E as featureMeasurements, G as featureProfile, H as featureSheet, I as featureTypeLabel, J as isNoReading, K as isSurfaceType, L as makeRule, N as maxBallDiameter, O as parseRules, Q as peakHeight, T as readPinch, V as readReachCurve, X as runStart, Y as trimmedCurve, Z as withSurroundedFaces } from '../feature-record-BUoFFjN6.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;
+
+/** 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 feature's pinch discs as the widest tool that fits stands in them: the
+ * datasheet's discs a tool can stand in, in its tool frame, mm, with how deep
+ * the feature runs and the corner the tool has.
+ */
+interface PinchMark extends FeaturePinch {
+    /**
+     * The radius on the tool's corner, mm: a filleted pocket's floor fillet,
+     * which a bull nose of that radius cuts. Absent for a flat-bottomed tool.
+     */
+    readonly corner?: number;
+}
+/**
+ * The pinch discs worth drawing a tool in: none for a feature with no discs,
+ * only a sharp corner's (no tool at all), or tools wider than
+ * {@link MAX_DRAWN_TOOL_MM}. A walled feature's floor fillet rounds the tool's
+ * corner; a surface's fillet radius is its own shape, and does not.
+ */
+declare const pinchMark: (datasheet: unknown, sheet: FeatureSheet | undefined, featureType: string) => PinchMark | null;
+/**
+ * What a pinch mark's tool is labelled: its diameter at the tightest disc —
+ * "≤" where the clearance was measured at one tolerance only — and, quieter,
+ * the kind of tool and how many places are that tight.
+ */
+declare const pinchLabel: (mark: PinchMark, units: Units) => {
+    label: string;
+    note: string;
+};
+
+/** A direction or a point. */
+interface Vec3 {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+/** A feature's faces as triangles: nine numbers each for the corners, three for the outward normal. */
+interface FaceTriangles {
+    readonly positions: ArrayLike<number>;
+    readonly normals: ArrayLike<number>;
+}
+/** The widest tool a feature admits, placed on the part: what to draw, in the drawn coordinates. */
+interface PlacedTool {
+    /** The centre of the tool's bottom, on the feature's floor. */
+    readonly base: Vec3;
+    /** Up the tool. */
+    readonly axis: Vec3;
+    readonly diameter: number;
+    readonly height: number;
+    /** The radius on its corner: a filleted floor's, no more than the tool's own radius. */
+    readonly cornerRadius: number;
+    /** Across the tool, toward where it touches the wall. */
+    readonly across: Vec3;
+}
+/**
+ * The widest tool a feature admits, standing on its tightest pinch disc, ready
+ * to draw: the datasheet's frame found against the feature's faces, the disc
+ * placed in it, and the tool turned toward the wall that pinches it.
+ *
+ * `origin` is where the CAD file's own zero sits in the coordinates the part
+ * is drawn in — moved by whatever centred it — since a datasheet is in the
+ * file's coordinates and the triangles and the answer are in the drawn ones.
+ * Null for a feature with no faces or no discs.
+ */
+declare const placePinchTool: (mark: PinchMark, triangles: FaceTriangles, direction: Vec3, origin?: Vec3) => PlacedTool | null;
+
+/**
+ * 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 { DfmHit, DfmRule, FILE_KIND, type FaceTriangles, FeaturePinch, FeatureSheet, type PinchMark, type PlacedTool, type RuleSetFile, Units, type Vec3, hitFigure, llmRulePrompt, parseRuleSetFile, pinchLabel, pinchMark, placePinchTool, sameDepth, serializeRuleSet };