meshfix-wasm 0.1.0

package/dist/worker.d.ts

@@ -0,0 +1,20 @@
+declare function importScripts(...urls: string[]): void;
+declare function createMeshFixCore(opts?: Record<string, unknown>): Promise<any>;
+interface WorkerRequest {
+    id: number;
+    method: string;
+    params: Record<string, unknown>;
+    buffer?: ArrayBuffer;
+}
+interface WorkerResponse {
+    id: number;
+    result?: unknown;
+    error?: {
+        message: string;
+    };
+}
+declare var module: any;
+declare var analyzer: any;
+declare function initModule(coreUrl?: string, wasmUrl?: string): Promise<void>;
+declare function postProgress(requestId: number, step: string, stepIndex: number, totalSteps: number): void;
+declare function handleMessage(method: string, params: Record<string, unknown>, buffer?: ArrayBuffer, requestId?: number): unknown;

package/dist/worker.js

@@ -0,0 +1,220 @@
+"use strict";
+// Classic Web Worker script — NO import/export statements.
+// TypeScript treats files without imports/exports as scripts,
+// so tsc emits no module syntax → valid for importScripts() workers.
+var module = null;
+var analyzer = null;
+async function initModule(coreUrl, wasmUrl) {
+    importScripts(coreUrl || "meshfix-core.js");
+    const opts = {};
+    if (wasmUrl) {
+        opts.locateFile = (path) => {
+            if (path.endsWith(".wasm"))
+                return wasmUrl;
+            return path;
+        };
+    }
+    module = await createMeshFixCore(opts);
+    analyzer = new module.MeshAnalyzer();
+}
+function postProgress(requestId, step, stepIndex, totalSteps) {
+    self.postMessage({ type: "progress", requestId, step, stepIndex, totalSteps });
+}
+function handleMessage(method, params, buffer, requestId) {
+    switch (method) {
+        case "init":
+            // handled separately (async)
+            return null;
+        case "analyze": {
+            const uint8 = new Uint8Array(buffer);
+            const path = "/tmp/input.stl";
+            try {
+                module.FS.writeFile(path, uint8);
+                const ok = analyzer.loadFromFile(path);
+                if (!ok)
+                    throw new Error(analyzer.getLastError() || "Failed to load mesh");
+                return analyzer.getStats();
+            }
+            finally {
+                try {
+                    module.FS.unlink(path);
+                }
+                catch { }
+            }
+        }
+        case "analyzeDetailed": {
+            const uint8 = new Uint8Array(buffer);
+            const path = "/tmp/input.stl";
+            try {
+                module.FS.writeFile(path, uint8);
+                const ok = analyzer.loadFromFile(path);
+                if (!ok)
+                    throw new Error(analyzer.getLastError() || "Failed to load mesh");
+                return analyzer.getAnalysis();
+            }
+            finally {
+                try {
+                    module.FS.unlink(path);
+                }
+                catch { }
+            }
+        }
+        case "analyzeTestShape": {
+            const name = params.name;
+            const ok = analyzer.loadTestShape(name);
+            if (!ok)
+                throw new Error(analyzer.getLastError() || "Failed to create test shape");
+            return analyzer.getStats();
+        }
+        case "analyzeTestShapeDetailed": {
+            const name = params.name;
+            const ok = analyzer.loadTestShape(name);
+            if (!ok)
+                throw new Error(analyzer.getLastError() || "Failed to create test shape");
+            return analyzer.getAnalysis();
+        }
+        case "weldVertices": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            const epsilon = params.epsilon ?? 1e-6;
+            return analyzer.weldVertices(epsilon);
+        }
+        case "removeDegenerates": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            const minArea = params.minArea ?? 1e-10;
+            return analyzer.removeDegenerates(minArea);
+        }
+        case "fixNormals": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            return analyzer.fixNormals();
+        }
+        case "fillHoles": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            const maxEdges = params.maxEdges ?? 100;
+            return analyzer.fillHoles(maxEdges);
+        }
+        case "splitVertices": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            return analyzer.splitVertices();
+        }
+        case "repair": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            const weldEpsilon = params.weldEpsilon ?? 1e-6;
+            const minArea = params.minArea ?? 1e-10;
+            const maxHoleEdges = params.maxHoleEdges ?? 100;
+            const id = requestId;
+            const totalSteps = 5;
+            const verticesBefore = analyzer.getVertexCount();
+            const facesBefore = analyzer.getFaceCount();
+            postProgress(id, "weld", 0, totalSteps);
+            const weld = analyzer.weldVertices(weldEpsilon);
+            // Only remove degenerates if mesh is not watertight — removing
+            // faces from a closed surface tears holes that may not fill cleanly.
+            var midAnalysis = analyzer.getAnalysis();
+            postProgress(id, "removeDegenerates", 1, totalSteps);
+            var removeDegenerates = null;
+            if (!midAnalysis.isWatertight) {
+                removeDegenerates = analyzer.removeDegenerates(minArea);
+            }
+            postProgress(id, "splitVertices", 2, totalSteps);
+            const splitVertices = analyzer.splitVertices();
+            postProgress(id, "fillHoles", 3, totalSteps);
+            const fillHoles = analyzer.fillHoles(maxHoleEdges);
+            postProgress(id, "fixNormals", 4, totalSteps);
+            const fixNormals = analyzer.fixNormals();
+            return {
+                weld,
+                removeDegenerates,
+                splitVertices,
+                fillHoles,
+                fixNormals,
+                verticesBefore,
+                verticesAfter: analyzer.getVertexCount(),
+                facesBefore,
+                facesAfter: analyzer.getFaceCount(),
+            };
+        }
+        case "reanalyze": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            return analyzer.getAnalysis();
+        }
+        case "toRenderData": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            var renderPath = "/tmp/render.bin";
+            try {
+                var ok = analyzer.writeRenderData(renderPath);
+                if (!ok)
+                    throw new Error(analyzer.getLastError() || "Failed to write render data");
+                var data = module.FS.readFile(renderPath);
+                var buf = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                return { buffer: buf };
+            }
+            finally {
+                try {
+                    module.FS.unlink(renderPath);
+                }
+                catch { }
+            }
+        }
+        case "exportMesh": {
+            if (!analyzer.isLoaded())
+                throw new Error("No mesh loaded");
+            var format = params.format || "stl";
+            var exportPath = "/tmp/export." + format;
+            try {
+                var ok = analyzer.exportMesh(exportPath);
+                if (!ok)
+                    throw new Error(analyzer.getLastError() || "Failed to export mesh");
+                var data = module.FS.readFile(exportPath);
+                var buf = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                return { buffer: buf };
+            }
+            finally {
+                try {
+                    module.FS.unlink(exportPath);
+                }
+                catch { }
+            }
+        }
+        case "dispose": {
+            if (analyzer) {
+                analyzer.delete();
+                analyzer = null;
+            }
+            module = null;
+            return null;
+        }
+        default:
+            throw new Error("Unknown method: " + method);
+    }
+}
+self.onmessage = async function (event) {
+    const { id, method, params, buffer } = event.data;
+    try {
+        if (method === "init") {
+            await initModule(params.coreUrl, params.wasmUrl);
+            self.postMessage({ id, result: true });
+        }
+        else {
+            const result = handleMessage(method, params, buffer, id);
+            // Transfer ArrayBuffer back for exportMesh and toRenderData
+            if ((method === "exportMesh" || method === "toRenderData") && result && result.buffer instanceof ArrayBuffer) {
+                self.postMessage({ id, result }, [result.buffer]);
+            }
+            else {
+                self.postMessage({ id, result });
+            }
+        }
+    }
+    catch (e) {
+        const message = e && e.message ? e.message : String(e);
+        self.postMessage({ id, error: { message } });
+    }
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "meshfix-wasm",
+  "version": "0.1.0",
+  "description": "Client-side 3D mesh repair library using WASM",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "install-emsdk": "bash scripts/install-emsdk.sh",
+    "build:wasm": "bash scripts/build-wasm.sh",
+    "build:ts": "tsc",
+    "build": "npm run build:wasm && npm run build:ts",
+    "prepublishOnly": "npm run build",
+    "serve": "npx http-server . -p 8080 -c-1"
+  },
+  "keywords": [
+    "wasm",
+    "webassembly",
+    "mesh",
+    "3d-printing",
+    "stl",
+    "obj",
+    "repair",
+    "geometry",
+    "pmp"
+  ],
+  "author": "Anthony Greco <anthony.greco@gmail.com> (https://justfixstl.com)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthonygreco/meshfix-wasm.git"
+  },
+  "homepage": "https://github.com/anthonygreco/meshfix-wasm",
+  "bugs": {
+    "url": "https://github.com/anthonygreco/meshfix-wasm/issues"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "http-server": "^14.1.1"
+  }
+}