brepjs-sheetmetal 0.1.0

package/dist/loftedFlangeFns.d.ts

@@ -0,0 +1,18 @@
+import { Result } from 'brepjs';
+import { LoftedFlangeSpec, SheetMetalPart } from './types.js';
+/**
+ * Author a lofted / ruled transition flange between two parallel OPEN profiles.
+ * The two profiles are lofted (ruled, straight generators) into a transition surface
+ * and thickened to a valid solid; the result is fused onto the part. The developed
+ * pattern is produced by TRIANGULATION (the standard transition development): each
+ * quad between consecutive vertex pairs is split into two triangles laid flat
+ * edge-length-preserving and accumulated into a developed boundary.
+ *
+ * The triangulated development is EXACT (to tolerance) when the ruled surface is
+ * developable — every quad is planar, so the two triangles share their diagonal in
+ * 3D and the flat layout preserves all lengths and angles. When a quad is non-planar
+ * (twisted ruling) the surface is not developable and the flat layout is an
+ * approximation; {@link approximate} is set and the unfold emits a
+ * `DEVELOPMENT_APPROXIMATE` warning.
+ */
+export declare function authorLoftedFlange(part: SheetMetalPart, spec: LoftedFlangeSpec): Result<SheetMetalPart>;

package/dist/materials.d.ts

@@ -0,0 +1,6 @@
+import { MaterialSpec } from './types.js';
+export declare const DEFAULT_K_FACTOR = 0.44;
+export declare const STEEL_GAUGES: Readonly<Record<string, MaterialSpec>>;
+export declare const ALUMINUM_GAUGES: Readonly<Record<string, MaterialSpec>>;
+export declare const MATERIALS: Readonly<Record<string, MaterialSpec>>;
+export declare function getMaterial(name: string): MaterialSpec | undefined;

package/dist/miterFns.d.ts

@@ -0,0 +1,20 @@
+import { Result, Vec3 } from 'brepjs';
+import { SheetMetalPart } from './types.js';
+/** An oriented cutting plane: material on the `+normal` side is removed. */
+export interface MiterPlane {
+    origin: Vec3;
+    normal: Vec3;
+}
+/**
+ * General miter primitive: cut a sheet-metal part by a plane, removing the
+ * material on the `+normal` side. The tool is a half-space block sized to the
+ * part's bounding box, so the cut is exact regardless of part extent.
+ */
+export declare function miterCut(part: SheetMetalPart, plane: MiterPlane): Result<SheetMetalPart>;
+/**
+ * Auto corner-miter between two adjacent flanges. The miter plane bisects the two
+ * flanges' fold-up directions at their shared corner and is offset by half the gap,
+ * so the cut falls on the flat/flange regions and never crosses a bend patch. The
+ * single bisector cut trims both flanges to a clean mitered corner.
+ */
+export declare function autoMiterCorner(part: SheetMetalPart, flangeIdA: string, flangeIdB: string, gap?: number): Result<SheetMetalPart>;

package/dist/nestFns.d.ts

@@ -0,0 +1,95 @@
+import { Result } from 'brepjs';
+import { FlatPattern, SheetMetalWarning } from './types.js';
+import { DxfOptions } from './dxfFns.js';
+/** Stock sheet the parts are packed onto (the gross blank, before margin). */
+export interface SheetSpec {
+    width: number;
+    height: number;
+}
+export interface NestOptions {
+    sheet: SheetSpec;
+    /** Clear border kept empty around the sheet edge (per side). Default `0`. */
+    margin?: number | undefined;
+    /** Minimum clear gap between any two placed parts (and the bbox padding used
+     * for the non-overlap test). Default `0`. */
+    spacing?: number | undefined;
+    /** Try a 90° rotation per part and keep whichever orientation fits/packs better. */
+    allowRotation?: boolean | undefined;
+    /**
+     * Packing strategy. Default `"bbox"`: each part is packed as its axis-aligned
+     * bounding box (the original {@link nest} behavior — fast, parts never interlock).
+     * `"nfp"` is true-shape / no-fit-polygon nesting: the actual outline polygons are
+     * packed so concave (L-shaped) parts interlock for higher material utilization.
+     * The NFP packer is a HEURISTIC (bottom-left-fill, largest-first) — not provably
+     * optimal — but it never overlaps parts and never drops a part silently.
+     */
+    strategy?: 'bbox' | 'nfp' | undefined;
+}
+/**
+ * Where a single pattern lands on a sheet. For the bbox strategy `rotationDeg` is
+ * `0` or `90`; the true-shape (nfp) strategy may also emit `180` or `270`. `(x, y)`
+ * is the lower-left of the part's transformed bounding box in sheet coordinates.
+ */
+export interface Placement {
+    /** Index into the `patterns` array passed to {@link nest}. */
+    patternIndex: number;
+    /** Lower-left x of the part's (rotated) bounding box, in sheet coordinates. */
+    x: number;
+    /** Lower-left y of the part's (rotated) bounding box, in sheet coordinates. */
+    y: number;
+    rotationDeg: number;
+}
+export interface NestSheet {
+    placements: Placement[];
+    /**
+     * Σ placed part areas ÷ usable-sheet area, in `(0, 1]`. "Usable" =
+     * `(width − 2·margin) × (height − 2·margin)`. For the `"bbox"` strategy the part
+     * area is its BOUNDING-BOX area (intra-bbox waste of a non-rectangular part is not
+     * credited — a conservative measure). For the `"nfp"` true-shape strategy it is the
+     * actual OUTLINE-POLYGON area, so an L-shaped part credits only its true material,
+     * making the two strategies' utilizations directly comparable on the same parts.
+     */
+    utilization: number;
+}
+export interface NestResult {
+    sheets: NestSheet[];
+    /** Indices of patterns too large for the usable sheet even rotated. */
+    unplaced: number[];
+    warnings: SheetMetalWarning[];
+}
+/** Axis-aligned bounding box of one pattern outline, in developed-plane coords. */
+export interface Bbox {
+    minX: number;
+    minY: number;
+    width: number;
+    height: number;
+}
+/**
+ * Bounding-box nest: arrange developed flat patterns onto stock sheets to reduce
+ * waste. This is BOUNDING-BOX nesting — each part is packed as its axis-aligned
+ * outline bounding box, so parts never interlock and concave parts leave their
+ * bounding-box waste unused. True-shape (no-fit-polygon) nesting is a follow-up.
+ *
+ * Algorithm: a shelf (level) packing heuristic. Parts are sorted largest-first by
+ * bbox height then area, then placed left-to-right into horizontal shelves; a new
+ * shelf opens below when the current row is full, and a NEW sheet opens when the
+ * next shelf would overflow the usable height. With `allowRotation`, each part is
+ * tried both at 0° and 90° and the orientation that fits the current shelf (or,
+ * failing that, fits at all) is kept. A part larger than the usable sheet even
+ * rotated is reported in `unplaced` with a warning — never dropped silently, never
+ * retried in an infinite loop.
+ */
+export declare function nest(patterns: FlatPattern[], options: NestOptions): Result<NestResult>;
+/**
+ * Axis-aligned bounding box of a pattern's OUTER outline wire, read from the wire
+ * vertices (each edge start point) — the same 2D-coordinate read the DXF/SVG writers
+ * use. Only the outer outline is packed; holes ride inside it.
+ */
+export declare function patternBbox(pattern: FlatPattern): Result<Bbox>;
+/**
+ * Emit one fabrication-ready DXF for a single nested sheet: every pattern placed on
+ * `result.sheets[sheetIndex]` is translated and rotated onto the sheet (via the same
+ * bounding boxes the packer used) and written through {@link multiPatternToDXF}.
+ * `patterns` must be the SAME array passed to {@link nest} (placements index into it).
+ */
+export declare function nestToDXF(result: NestResult, patterns: FlatPattern[], sheetIndex: number, options?: DxfOptions): Result<string>;

package/dist/polygonFns.d.ts

@@ -0,0 +1,48 @@
+import { Result, Wire } from 'brepjs';
+export type Pt2 = [number, number];
+/** A simple (non-self-intersecting) polygon as an ordered, non-closing vertex loop. */
+export type Polygon = Pt2[];
+/**
+ * Ordered vertex loop of a closed outline wire — one vertex per edge start point, the
+ * same 2D read the DXF writer (`outlinePoints`) and the bbox nester (`patternBbox`)
+ * use. The loop is NOT closed (the last vertex is not repeated); edges are taken as
+ * `v[i] → v[(i+1) % n]`.
+ */
+export declare function wireToPolygon(outline: Wire): Result<Polygon>;
+/** Signed area (CCW positive) — used to normalise orientation and reject degenerates. */
+export declare function signedArea(poly: Polygon): number;
+/** Axis-aligned bounds `[minX, minY, maxX, maxY]` of a polygon. */
+export declare function polygonBounds(poly: Polygon): [number, number, number, number];
+/** Rotate every vertex (CCW, degrees, about the origin), then translate by (dx, dy). */
+export declare function transformPolygon(poly: Polygon, dx: number, dy: number, rotationDeg: number): Polygon;
+/** Ray-cast point-in-polygon: points strictly inside return true; behaviour for a
+ * point exactly on the boundary is undefined (the overlap predicate handles edge
+ * contact separately via segment-intersection). */
+export declare function pointInPolygon(poly: Polygon, x: number, y: number): boolean;
+/**
+ * Proper-or-improper segment intersection (`p1p2` vs `p3p4`). Returns true when the
+ * segments cross OR touch (collinear overlap or a shared endpoint), so it is
+ * conservative for the overlap test — never a false negative.
+ */
+export declare function segmentsIntersect(p1: Pt2, p2: Pt2, p3: Pt2, p4: Pt2): boolean;
+/**
+ * Do two simple polygons overlap? True iff any edge of `a` intersects any edge of
+ * `b`, or one polygon fully contains a vertex of the other. This pair of conditions
+ * is exhaustive for simple polygons: a disjoint pair has no crossing edges and no
+ * mutually-contained vertex; a touching-but-non-overlapping pair (shared edge/vertex,
+ * zero interior overlap) is caught by `segmentsIntersect` and so is reported as
+ * overlapping — callers wanting a clearance gap should inflate via {@link polygonsOverlapWithClearance}.
+ *
+ * Centroid containment is NOT sufficient on its own (a concave part's centroid can
+ * lie outside it), so a representative INTERIOR vertex of each polygon is tested for
+ * containment in the other — combined with the edge-crossing test this covers the
+ * nested-without-crossing case.
+ */
+export declare function polygonsOverlap(a: Polygon, b: Polygon): boolean;
+/**
+ * Overlap test honoring a clearance gap: the two polygons must stay at least
+ * `clearance` apart. Implemented by testing raw overlap and, when disjoint, the
+ * minimum edge-to-edge distance against the clearance. `clearance <= 0` is the plain
+ * {@link polygonsOverlap}.
+ */
+export declare function polygonsOverlapWithClearance(a: Polygon, b: Polygon, clearance: number): boolean;

package/dist/reliefFns.d.ts

@@ -0,0 +1,28 @@
+import { Result } from 'brepjs';
+import { ReliefSpec, SheetMetalPart } from './types.js';
+/**
+ * Add a bend relief to a flange: a small slot cut into the PARENT flat at each end
+ * of the bend line that does not reach the parent edge endpoint (a partial/offset
+ * flange). Without it the parent material tears at the corner where the bend
+ * terminates mid-edge. Each slot is `width` (≈ thickness) along the parent edge by
+ * `depth` (≈ developed length + clearance) into the parent flat, cut from the 3D
+ * solid and recorded so {@link unfold} replays the 2D notch.
+ *
+ * A relief is a recorded feature replayed by unfold — exactly the pattern
+ * {@link autoMiterCorner} establishes for corner miters.
+ */
+export declare function addBendRelief(part: SheetMetalPart, flangeId: string, spec?: ReliefSpec): Result<SheetMetalPart>;
+/**
+ * Add a bend relief to every partial-span bend (a flange that does not span its
+ * full parent edge). Full-span flanges are skipped — they have no mid-edge bend
+ * terminus to relieve. Convenience over calling {@link addBendRelief} per flange.
+ */
+export declare function autoBendReliefs(part: SheetMetalPart, spec?: ReliefSpec): Result<SheetMetalPart>;
+/**
+ * Corner relief between two adjacent flanges: a notch cut at their shared corner so
+ * the two upright flanges clear each other once folded — the alternative to a 45°
+ * miter for the same corner {@link autoMiterCorner} handles. The notch is cut from
+ * the solid and recorded as a {@link ReliefFeature}; the corner is also recorded in
+ * `miters` (gap 0) so the collision check treats the interference as resolved.
+ */
+export declare function cornerRelief(part: SheetMetalPart, flangeIdA: string, flangeIdB: string, spec?: ReliefSpec): Result<SheetMetalPart>;

package/dist/reportFns.d.ts

@@ -0,0 +1,19 @@
+import { Result } from 'brepjs';
+import { BendReport, SheetMetalPart, UnfoldResult } from './types.js';
+/**
+ * Build the bend-table JSON report directly from an authored part. Walks the
+ * same tree layout the unfold consumes so the per-bend values and the total flat
+ * size agree with the flat pattern. `allowance` is the consumed neutral-axis arc
+ * length (the bend allowance); `flatLength` is the straight flange leg past the
+ * bend — distinct values a downstream nesting/cut-list tool needs separately.
+ */
+export declare function buildReport(part: SheetMetalPart): Result<BendReport>;
+/**
+ * Project the report already computed by `unfold` into the standalone
+ * `BendReport` shape, defensively re-validating its numeric fields. This keeps
+ * the report a pure function of a previously-unfolded result without re-walking
+ * the tree.
+ */
+export declare function reportFromUnfold(result: UnfoldResult): Result<BendReport>;
+/** Serialize a `BendReport` to a stable, pretty-printed JSON string. */
+export declare function reportToJSON(report: BendReport): string;

package/dist/tabFns.d.ts

@@ -0,0 +1,33 @@
+import { Result } from 'brepjs';
+import { TabSpec, SheetMetalPart } from './types.js';
+/**
+ * Fuse a rectangular tab onto a named flat region's edge — additive material (the
+ * counterpart of a cutout). The tab is built as a region-local rectangle just past
+ * the chosen `side`, placed onto the correct folded face via the region's world
+ * {@link FlatFrame}, extruded through the sheet thickness and fused to the solid. The
+ * same local rectangle, mapped through the region's developed {@link Frame2}, is
+ * recorded as a {@link TabFeature} so {@link unfold} extends the OUTER outline by the
+ * protrusion (tabs add material, so the developed area grows). Guards a valid,
+ * single-bodied solid.
+ */
+export declare function addTab(part: SheetMetalPart, spec: TabSpec): Result<SheetMetalPart>;
+/** The mating-slot placement for a {@link tabAndSlot} joint. */
+export interface SlotPlacement {
+    region: string;
+    x: number;
+    y: number;
+    clearance?: number | undefined;
+    /** In-plane rotation of the slot (deg, CCW) in the mating region's local frame.
+     * Default 0 = slot length along the region's +x (bend-axis) direction; set this
+     * when the tab meets the slot region at a non-default orientation. */
+    angleDeg?: number | undefined;
+}
+/**
+ * Self-fixturing tab-and-slot joint: fuse a tab on one region and punch a matching
+ * SLOT CUTOUT on the mating region, sized so the tab's cross-section
+ * (`width × thickness`) inserts into the slot. The slot is `tab.width + clearance`
+ * long by `thickness + clearance` wide, centred at the mating region's local
+ * `(x, y)`. The slot is always strictly larger than the tab cross-section, so the
+ * joint mates (verified numerically by callers). Clearance defaults to `0.1` mm.
+ */
+export declare function tabAndSlot(part: SheetMetalPart, tab: TabSpec, slot: SlotPlacement): Result<SheetMetalPart>;