brepjs-sheetmetal 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,10 @@
 # brepjs-sheetmetal
 
-> Experimental, unpublished satellite package.
+> Experimental satellite package, published to npm. Early-stage — the API may change.
+
+```bash
+npm install brepjs-sheetmetal
+```
 
 A sheet-metal CAD domain for [brepjs](https://github.com/andymai/brepjs). It authors parametric
 sheet-metal parts (flange/bend features), auto-miters corners, folds to 3D, and unfolds to a flat

package/dist/brepjs-sheetmetal.cjs

@@ -6135,6 +6135,68 @@ function wireToPolygon(outline) {
 	if (poly.length < 3) return (0, brepjs.err)((0, brepjs.validationError)("EMPTY_OUTLINE", "outline polygon has fewer than 3 vertices"));
 	return (0, brepjs.ok)(poly);
 }
+/**
+* Read a wire as an OPEN polyline: every edge start plus the final edge's end,
+* so the last vertex of a non-closing path (a form cut) isn't dropped the way
+* {@link wireToPolygon} drops it for closed loops.
+*
+* Arc edges are linearised to their endpoints — the same assumption
+* {@link wireToPolygon} and the DXF writer make. Form cuts are straight-sided
+* today (louver/lance slits), so this is exact; a future curved form-feature cut
+* would render as straight chords in the overlay until arc tessellation is added.
+*/
+function wireToOpenPolyline(wire) {
+	const edges = (0, brepjs.getEdges)(wire);
+	if (edges.length === 0) return [];
+	const pts = edges.map((edge) => {
+		const p = (0, brepjs.curveStartPoint)(edge);
+		return [p[0], p[1]];
+	});
+	const lastEdge = edges[edges.length - 1];
+	if (lastEdge) {
+		const e = (0, brepjs.curveEndPoint)(lastEdge);
+		pts.push([e[0], e[1]]);
+	}
+	return pts;
+}
+/**
+* Reduce a {@link FlatPattern} to serializable 2D polylines (outline, holes, bend
+* lines) for a developed-pattern overlay. Best-effort: a wire that fails to read
+* is dropped rather than throwing, so a partial pattern still yields what it can.
+* Arc edges are approximated by endpoints, the same assumption {@link wireToPolygon}
+* and the DXF writer make.
+*/
+function flatPatternToPolylines(pattern) {
+	const outlineResult = wireToPolygon(pattern.outline);
+	const outline = (0, brepjs.isOk)(outlineResult) ? outlineResult.value : [];
+	const holes = [];
+	for (const hole of pattern.holes) {
+		const holeResult = wireToPolygon(hole);
+		if ((0, brepjs.isOk)(holeResult)) holes.push(holeResult.value);
+	}
+	return {
+		outline,
+		holes,
+		bendLines: pattern.bendLines.map((bend) => {
+			const start = (0, brepjs.curveStartPoint)(bend.line);
+			const end = (0, brepjs.curveEndPoint)(bend.line);
+			return {
+				from: [start[0], start[1]],
+				to: [end[0], end[1]],
+				direction: bend.direction
+			};
+		}),
+		formCuts: pattern.formCuts.map(wireToOpenPolyline).filter((p) => p.length >= 2),
+		formHinges: pattern.formHinges.map((hinge) => {
+			const start = (0, brepjs.curveStartPoint)(hinge);
+			const end = (0, brepjs.curveEndPoint)(hinge);
+			return {
+				from: [start[0], start[1]],
+				to: [end[0], end[1]]
+			};
+		})
+	};
+}
 /** Signed area (CCW positive) — used to normalise orientation and reject degenerates. */
 function signedArea(poly) {
 	let a = 0;
@@ -7271,6 +7333,7 @@ exports.emboss = emboss;
 exports.featureTree = featureTree;
 exports.fitCylinder = fitCylinder;
 exports.flatPatternToDXF = flatPatternToDXF;
+exports.flatPatternToPolylines = flatPatternToPolylines;
 exports.fold = fold;
 exports.foldFlat = foldFlat;
 exports.foldPart = fold$1;

package/dist/brepjs-sheetmetal.js

@@ -1,4 +1,4 @@
-import { box, curveEndPoint, curveStartPoint, cut, cylinder, err, extrude, face, faceCenter, fuse, getBounds, getEdges, getFaces, getSolids, getSurfaceType, intersect, isErr, isPlanarWire, isSolid, isValid, line, measureArea, measureVolume, normalAt, ok, pointOnSurface, rotate, sharedEdges, translate, validationError, vecAdd, vecCross, vecDot, vecLength, vecNormalize, vecScale, vecSub, wire, wireLoop } from "brepjs";
+import { box, curveEndPoint, curveStartPoint, cut, cylinder, err, extrude, face, faceCenter, fuse, getBounds, getEdges, getFaces, getSolids, getSurfaceType, intersect, isErr, isOk, isPlanarWire, isSolid, isValid, line, measureArea, measureVolume, normalAt, ok, pointOnSurface, rotate, sharedEdges, translate, validationError, vecAdd, vecCross, vecDot, vecLength, vecNormalize, vecScale, vecSub, wire, wireLoop } from "brepjs";
 //#region src/materials.ts
 var DEFAULT_K_FACTOR = .44;
 function gauge(name, thickness, kFactor = DEFAULT_K_FACTOR) {
@@ -6134,6 +6134,68 @@ function wireToPolygon(outline) {
 	if (poly.length < 3) return err(validationError("EMPTY_OUTLINE", "outline polygon has fewer than 3 vertices"));
 	return ok(poly);
 }
+/**
+* Read a wire as an OPEN polyline: every edge start plus the final edge's end,
+* so the last vertex of a non-closing path (a form cut) isn't dropped the way
+* {@link wireToPolygon} drops it for closed loops.
+*
+* Arc edges are linearised to their endpoints — the same assumption
+* {@link wireToPolygon} and the DXF writer make. Form cuts are straight-sided
+* today (louver/lance slits), so this is exact; a future curved form-feature cut
+* would render as straight chords in the overlay until arc tessellation is added.
+*/
+function wireToOpenPolyline(wire) {
+	const edges = getEdges(wire);
+	if (edges.length === 0) return [];
+	const pts = edges.map((edge) => {
+		const p = curveStartPoint(edge);
+		return [p[0], p[1]];
+	});
+	const lastEdge = edges[edges.length - 1];
+	if (lastEdge) {
+		const e = curveEndPoint(lastEdge);
+		pts.push([e[0], e[1]]);
+	}
+	return pts;
+}
+/**
+* Reduce a {@link FlatPattern} to serializable 2D polylines (outline, holes, bend
+* lines) for a developed-pattern overlay. Best-effort: a wire that fails to read
+* is dropped rather than throwing, so a partial pattern still yields what it can.
+* Arc edges are approximated by endpoints, the same assumption {@link wireToPolygon}
+* and the DXF writer make.
+*/
+function flatPatternToPolylines(pattern) {
+	const outlineResult = wireToPolygon(pattern.outline);
+	const outline = isOk(outlineResult) ? outlineResult.value : [];
+	const holes = [];
+	for (const hole of pattern.holes) {
+		const holeResult = wireToPolygon(hole);
+		if (isOk(holeResult)) holes.push(holeResult.value);
+	}
+	return {
+		outline,
+		holes,
+		bendLines: pattern.bendLines.map((bend) => {
+			const start = curveStartPoint(bend.line);
+			const end = curveEndPoint(bend.line);
+			return {
+				from: [start[0], start[1]],
+				to: [end[0], end[1]],
+				direction: bend.direction
+			};
+		}),
+		formCuts: pattern.formCuts.map(wireToOpenPolyline).filter((p) => p.length >= 2),
+		formHinges: pattern.formHinges.map((hinge) => {
+			const start = curveStartPoint(hinge);
+			const end = curveEndPoint(hinge);
+			return {
+				from: [start[0], start[1]],
+				to: [end[0], end[1]]
+			};
+		})
+	};
+}
 /** Signed area (CCW positive) — used to normalise orientation and reject degenerates. */
 function signedArea(poly) {
 	let a = 0;
@@ -7230,4 +7292,4 @@ function fromSolid(solid, opts) {
 	return new ForeignSolidHandle(solid, opts);
 }
 //#endregion
-export { ALUMINUM_GAUGES, DEFAULT_K_FACTOR, ForeignSolidHandle, MATERIALS, ROOT_FLAT_ID, STEEL_GAUGES, SheetMetalBuilder, SheetMetalError, SheetMetalPartHandle, addBendRelief, addBendTable, addCutout, addForm, addHole, addPolygonCutout, addSlot, addTab, allowance, author, authorContourFlange, authorLoftedFlange, authorPart, autoBendReliefs, autoMiterCorner, autoReliefs, baseEdgeRef, bendAllowance, bendRelief, bendTable, buildFeatureGraph, buildFeatureTree, buildReport, contourFlange, cornerRelief, developed, developedLength, emboss, featureTree, fitCylinder, flatPatternToDXF, fold, foldFlat, fold$1 as foldPart, foldWithWarnings, fromPart, fromSolid, getBendTable, getMaterial, hem, jog, loftedFlange, louver, miter, miterCorner, miterCut, multiPatternToDXF, nest, nestToDXF, neutralRadius, partToFlatInput, patternBbox, patternToFlatInput, pointInPolygon, polygonBounds, polygonsOverlap, polygonsOverlapWithClearance, registerBendTable, relieveCorner, report, reportFrom, reportFromUnfold, reportJSON, reportToJSON, resolveAllowance, resolveBendAllowance, segmentsIntersect, sheetMetal, signedArea, tabAndSlot, toDXF, transformPolygon, unfold, unfoldForeignSolid, unfold$1 as unfoldPart, unfoldSolid, validate, validatePart, wireToPolygon };
+export { ALUMINUM_GAUGES, DEFAULT_K_FACTOR, ForeignSolidHandle, MATERIALS, ROOT_FLAT_ID, STEEL_GAUGES, SheetMetalBuilder, SheetMetalError, SheetMetalPartHandle, addBendRelief, addBendTable, addCutout, addForm, addHole, addPolygonCutout, addSlot, addTab, allowance, author, authorContourFlange, authorLoftedFlange, authorPart, autoBendReliefs, autoMiterCorner, autoReliefs, baseEdgeRef, bendAllowance, bendRelief, bendTable, buildFeatureGraph, buildFeatureTree, buildReport, contourFlange, cornerRelief, developed, developedLength, emboss, featureTree, fitCylinder, flatPatternToDXF, flatPatternToPolylines, fold, foldFlat, fold$1 as foldPart, foldWithWarnings, fromPart, fromSolid, getBendTable, getMaterial, hem, jog, loftedFlange, louver, miter, miterCorner, miterCut, multiPatternToDXF, nest, nestToDXF, neutralRadius, partToFlatInput, patternBbox, patternToFlatInput, pointInPolygon, polygonBounds, polygonsOverlap, polygonsOverlapWithClearance, registerBendTable, relieveCorner, report, reportFrom, reportFromUnfold, reportJSON, reportToJSON, resolveAllowance, resolveBendAllowance, segmentsIntersect, sheetMetal, signedArea, tabAndSlot, toDXF, transformPolygon, unfold, unfoldForeignSolid, unfold$1 as unfoldPart, unfoldSolid, validate, validatePart, wireToPolygon };

package/dist/index.d.ts

@@ -26,8 +26,8 @@ export { flatPatternToDXF, multiPatternToDXF } from './dxfFns.js';
 export type { DxfOptions, PlacedPattern, Transform2 } from './dxfFns.js';
 export { patternBbox } from './nestFns.js';
 export type { NestOptions, NestResult, NestSheet, Placement, SheetSpec, Bbox, } from './nestFns.js';
-export { wireToPolygon, polygonsOverlap, polygonsOverlapWithClearance, segmentsIntersect, pointInPolygon, transformPolygon, polygonBounds, signedArea, } from './polygonFns.js';
-export type { Polygon, Pt2 } from './polygonFns.js';
+export { wireToPolygon, flatPatternToPolylines, polygonsOverlap, polygonsOverlapWithClearance, segmentsIntersect, pointInPolygon, transformPolygon, polygonBounds, signedArea, } from './polygonFns.js';
+export type { Polygon, Pt2, FlatPatternPolylines, FlatPatternBendLine, } from './polygonFns.js';
 export { buildReport, reportFromUnfold, reportToJSON } from './reportFns.js';
 export { validatePart } from './validateFns.js';
 export { author, unfold as unfoldPart, unfoldSolid, fold as foldPart, miter, miterCorner, bendRelief, autoReliefs, relieveCorner, toDXF, report, reportFrom, reportJSON, validate, allowance, developed, addBendTable, bendTable, resolveAllowance, contourFlange, loftedFlange, nest, nestToDXF, } from './api.js';

package/dist/polygonFns.d.ts

@@ -1,4 +1,5 @@
 import { Result, Wire } from 'brepjs';
+import { FlatPattern } from './types.js';
 export type Pt2 = [number, number];
 /** A simple (non-self-intersecting) polygon as an ordered, non-closing vertex loop. */
 export type Polygon = Pt2[];
@@ -9,6 +10,36 @@ export type Polygon = Pt2[];
  * `v[i] → v[(i+1) % n]`.
  */
 export declare function wireToPolygon(outline: Wire): Result<Polygon>;
+/** A bend line in the developed plane: a segment plus its fold direction. */
+export interface FlatPatternBendLine {
+    from: Pt2;
+    to: Pt2;
+    direction: 'up' | 'down';
+}
+/** A flat pattern reduced to serializable 2D polylines for a developed-view overlay. */
+export interface FlatPatternPolylines {
+    /** Closed outer boundary as an ordered, non-closing vertex loop. */
+    outline: Polygon;
+    /** Interior cutout loops (holes / slots / polygon cutouts). */
+    holes: Polygon[];
+    /** Bend lines, each with its fold direction. */
+    bendLines: FlatPatternBendLine[];
+    /** Open form-feature cut paths in the blank (e.g. louver/lance three-sided cuts). */
+    formCuts: Polygon[];
+    /** Form-feature hinge lines (the uncut fold edge a louver/lance forms up along). */
+    formHinges: {
+        from: Pt2;
+        to: Pt2;
+    }[];
+}
+/**
+ * Reduce a {@link FlatPattern} to serializable 2D polylines (outline, holes, bend
+ * lines) for a developed-pattern overlay. Best-effort: a wire that fails to read
+ * is dropped rather than throwing, so a partial pattern still yields what it can.
+ * Arc edges are approximated by endpoints, the same assumption {@link wireToPolygon}
+ * and the DXF writer make.
+ */
+export declare function flatPatternToPolylines(pattern: FlatPattern): FlatPatternPolylines;
 /** 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. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs-sheetmetal",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Sheet-metal CAD domain for brepjs — flange authoring, auto-miter, fold/unfold flat patterns",
   "keywords": [
     "sheet-metal",
@@ -12,6 +12,11 @@
   ],
   "author": "Andy Aragon",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andymai/brepjs",
+    "directory": "packages/brepjs-sheetmetal"
+  },
   "type": "module",
   "sideEffects": false,
   "engines": {