brepjs-cad 0.1.0

package/dist/cli/main.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+import { n as runMeasure, o as reportOk, r as runPart, s as serializeReport, t as runDiff } from "../diff-ByiVwVrr.js";
+import { exportSTL, isOk } from "brepjs";
+import { Command } from "commander";
+import { existsSync, mkdirSync, watch, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+//#region src/cli/scaffold.ts
+function partTemplate(name) {
+	return `import { box, cut, unwrap } from 'brepjs';
+
+const width = 40;
+const depth = 20;
+const height = 10;
+const holeSize = 6;
+
+// ${name}: a parameterized starter part — edit the consts above, then re-verify.
+export default () => {
+  const body = box(width, depth, height, { centered: true });
+  const hole = box(holeSize, holeSize, height + 2, { centered: true });
+  return unwrap(cut(body, hole));
+};
+`;
+}
+function tsconfigTemplate() {
+	return `${JSON.stringify({
+		compilerOptions: {
+			target: "ES2022",
+			module: "ESNext",
+			moduleResolution: "bundler",
+			strict: true,
+			noEmit: true,
+			skipLibCheck: true
+		},
+		include: ["*.brep.ts"]
+	}, null, 2)}\n`;
+}
+function readmeTemplate(name) {
+	return `# ${name}
+
+A parametric brepjs CAD part. Units are millimetres.
+
+## Verify
+
+\`\`\`sh
+npx brepjs ${name}.brep.ts --json report.json
+\`\`\`
+
+## Iterate
+
+\`\`\`sh
+npx brepjs watch ${name}.brep.ts
+\`\`\`
+
+## Export artifacts
+
+\`\`\`sh
+npx brepjs export ${name}.brep.ts --all --out out/
+\`\`\`
+`;
+}
+function scaffoldPart(name, dir) {
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const targets = [
+		{
+			path: join(dir, `${name}.brep.ts`),
+			content: partTemplate(name)
+		},
+		{
+			path: join(dir, "tsconfig.json"),
+			content: tsconfigTemplate()
+		},
+		{
+			path: join(dir, "README.md"),
+			content: readmeTemplate(name)
+		}
+	];
+	const files = [];
+	for (const t of targets) {
+		if (existsSync(t.path)) {
+			files.push({
+				path: t.path,
+				created: false
+			});
+			continue;
+		}
+		writeFileSync(t.path, t.content);
+		files.push({
+			path: t.path,
+			created: true
+		});
+	}
+	return {
+		dir,
+		files
+	};
+}
+/**
+* Wraps a handler so bursts of rapid calls collapse into a single trailing
+* invocation after `delayMs` of quiet — fs.watch fires twice per save on many
+* platforms, so the model is re-run once rather than per raw event.
+*/
+function debounce(fn, delayMs = 150) {
+	let timer;
+	const cancel = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	};
+	const trigger = () => {
+		cancel();
+		timer = setTimeout(() => {
+			timer = void 0;
+			fn();
+		}, delayMs);
+	};
+	return {
+		trigger,
+		cancel
+	};
+}
+//#endregion
+//#region src/disposeShape.ts
+/**
+* Release a live WASM-backed kernel shape handle returned by `runPart`.
+* No-op for null/undefined or shapes without a disposer, so callers can pass
+* `result.shape` unconditionally. WASM memory accumulates without this.
+*/
+function disposeShape(shape) {
+	const disposer = shape?.[Symbol.dispose];
+	if (typeof disposer === "function") disposer.call(shape);
+}
+//#endregion
+//#region src/cli/exportPart.ts
+function stem(file) {
+	return basename(file).replace(/\.brep\.ts$/, "").replace(/\.ts$/, "");
+}
+async function exportPart(modulePath, formats, outDir) {
+	const wantStl = Boolean(formats.stl);
+	const { shape, report, step, glb } = await runPart(modulePath, {
+		step: Boolean(formats.step),
+		glb: Boolean(formats.glb)
+	});
+	const errors = [];
+	const written = [];
+	if (!(reportOk(report) && shape !== null)) {
+		disposeShape(shape);
+		return {
+			ok: false,
+			report,
+			written,
+			errors: report.errors
+		};
+	}
+	if (!existsSync(outDir)) mkdirSync(outDir, { recursive: true });
+	const base = stem(modulePath);
+	if (formats.step) if (step) {
+		const p = join(outDir, `${base}.step`);
+		writeFileSync(p, Buffer.from(step));
+		written.push(p);
+	} else errors.push("STEP export produced no data");
+	if (formats.glb) if (glb) {
+		const p = join(outDir, `${base}.glb`);
+		writeFileSync(p, Buffer.from(glb));
+		written.push(p);
+	} else errors.push("GLB export produced no data");
+	if (wantStl) {
+		const r = exportSTL(shape);
+		if (isOk(r)) {
+			const p = join(outDir, `${base}.stl`);
+			writeFileSync(p, Buffer.from(await r.value.arrayBuffer()));
+			written.push(p);
+		} else errors.push(`STL export: ${r.error.message}`);
+	}
+	disposeShape(shape);
+	return {
+		ok: errors.length === 0,
+		report,
+		written,
+		errors
+	};
+}
+//#endregion
+//#region src/cli/main.ts
+console.log = (...args) => {
+	process.stderr.write(args.map(String).join(" ") + "\n");
+};
+async function loadSnapshotShoot() {
+	try {
+		return (await import("../snapshot/shoot.js")).shoot;
+	} catch {
+		process.stderr.write("snapshots need puppeteer/Chrome — run: npm i puppeteer\n");
+		process.exitCode = 1;
+		return;
+	}
+}
+var program = new Command();
+program.name("brepjs");
+program.command("verify", { isDefault: true }).argument("<file>", "path to a .brep.ts module with a default-exported part function").option("--step <out>", "write the primary STEP artifact to this path").option("--glb <out>", "write a derived GLB preview to this path").option("--json <out>", "write the JSON report to this path").option("--snapshot <dir>", "render iso/front/top/right PNGs to this dir (requires built viewer)").option("--serve", "after verifying, start a preview server and print a ?dir=&file= deep link (stays running)").action(async (file, opts) => {
+	const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
+	const { report, step, glb } = await runPart(resolve(file), {
+		step: wantStep,
+		glb: Boolean(opts.glb)
+	});
+	const json = serializeReport(report);
+	if (opts.json) writeFileSync(opts.json, json);
+	if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));
+	let stepPath = opts.step;
+	if (wantStep && step) {
+		stepPath = opts.step ?? join(tmpdir(), `brepjs-cad-${basename(file)}.step`);
+		writeFileSync(stepPath, Buffer.from(step));
+	}
+	if (opts.snapshot && stepPath) {
+		const shoot = await loadSnapshotShoot();
+		if (shoot) {
+			const { pngs } = await shoot({
+				file: stepPath,
+				outDir: opts.snapshot
+			});
+			for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
+		}
+	}
+	process.stdout.write(json + "\n");
+	const parsed = JSON.parse(json);
+	if (!opts.serve && parsed.ok !== true) process.exitCode = 1;
+	if (opts.serve && stepPath) {
+		const { serve } = await import("../snapshot/serve.js");
+		const { url } = await serve({ file: stepPath });
+		process.stderr.write(`viewer: ${url}\n`);
+	}
+});
+program.command("measure").argument("<a>", "path to a .brep.ts module").argument("[b]", "optional second module; if given, measures distance between the two parts").action(async (a, b) => {
+	const result = await runMeasure(resolve(a), b === void 0 ? void 0 : resolve(b));
+	process.stdout.write(JSON.stringify({
+		ok: result.errors.length === 0,
+		...result
+	}, null, 2) + "\n");
+	if (result.errors.length > 0) process.exitCode = 1;
+});
+program.command("diff").argument("<a>", "path to the baseline .brep.ts module").argument("<b>", "path to the comparison .brep.ts module").action(async (a, b) => {
+	const result = await runDiff(resolve(a), resolve(b));
+	process.stdout.write(JSON.stringify({
+		ok: result.errors.length === 0,
+		...result
+	}, null, 2) + "\n");
+	if (result.errors.length > 0) process.exitCode = 1;
+});
+program.command("init").argument("<name>", "part name; scaffolds <name>.brep.ts + tsconfig.json + README.md").option("--out <dir>", "target directory (defaults to ./<name>)").action((name, opts) => {
+	const result = scaffoldPart(name, resolve(opts.out ?? name));
+	for (const f of result.files) {
+		const tag = f.created ? "created" : "exists (kept)";
+		process.stderr.write(`${tag}: ${f.path}\n`);
+	}
+	process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+});
+program.command("watch").argument("<file>", "path to a .brep.ts module; re-verifies on each save until Ctrl-C").action((file) => {
+	const path = resolve(file);
+	const run = async () => {
+		try {
+			const { report, shape } = await runPart(path);
+			try {
+				process.stdout.write(serializeReport(report) + "\n");
+			} finally {
+				disposeShape(shape);
+			}
+		} catch (e) {
+			process.stderr.write(`watch run failed: ${e.message}\n`);
+		}
+	};
+	const { trigger } = debounce(run, 150);
+	process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
+	run();
+	const watcher = watch(dirname(path), (_event, filename) => {
+		if (filename === void 0 || filename === null) {
+			trigger();
+			return;
+		}
+		if (basename(path) === filename.toString()) trigger();
+	});
+	const stop = () => {
+		watcher.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", stop);
+	process.on("SIGTERM", stop);
+});
+program.command("export").argument("<file>", "path to a .brep.ts module").option("--step", "write a STEP artifact").option("--glb", "write a GLB artifact").option("--stl", "write an STL artifact").option("--all", "write STEP + GLB + STL").option("--out <dir>", "output directory", ".").action(async (file, opts) => {
+	const formats = opts.all ? {
+		step: true,
+		glb: true,
+		stl: true
+	} : {
+		step: Boolean(opts.step),
+		glb: Boolean(opts.glb),
+		stl: Boolean(opts.stl)
+	};
+	if (!formats.step && !formats.glb && !formats.stl) {
+		process.stderr.write("no formats requested — pass --step/--glb/--stl or --all\n");
+		process.exitCode = 1;
+		return;
+	}
+	const result = await exportPart(resolve(file), formats, resolve(opts.out));
+	for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
+	for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
+	process.stdout.write(JSON.stringify({
+		ok: result.ok,
+		written: result.written,
+		errors: result.errors
+	}, null, 2) + "\n");
+	if (!result.ok) process.exitCode = 1;
+});
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) program.parseAsync();
+//#endregion
+export { loadSnapshotShoot };

package/dist/cli/scaffold.d.ts

@@ -0,0 +1,9 @@
+export interface ScaffoldFile {
+    path: string;
+    created: boolean;
+}
+export interface ScaffoldResult {
+    dir: string;
+    files: ScaffoldFile[];
+}
+export declare function scaffoldPart(name: string, dir: string): ScaffoldResult;

package/dist/cli/watch.d.ts

@@ -0,0 +1,10 @@
+export declare const DEFAULT_DEBOUNCE_MS = 150;
+/**
+ * Wraps a handler so bursts of rapid calls collapse into a single trailing
+ * invocation after `delayMs` of quiet — fs.watch fires twice per save on many
+ * platforms, so the model is re-run once rather than per raw event.
+ */
+export declare function debounce(fn: () => void | Promise<void>, delayMs?: number): {
+    trigger: () => void;
+    cancel: () => void;
+};