minidraco 0.1.0 → 0.1.1

package/README.md

@@ -26,6 +26,13 @@ no-ops). Decoding runs in a pool of module workers (default 4, `setWorkerLimit(n
 `0` to force synchronous main-thread decoding). If workers can't be spawned (SSR, exotic
 bundlers), it falls back to synchronous decoding automatically.
 
+**Serving JS from a CDN origin** (Next.js `assetPrefix`, etc.) works out of the box: browsers
+refuse to construct a Worker from a cross-origin script, so minidraco bootstraps the worker
+through a same-origin blob module that imports the hashed CDN asset (a CORS request — your CDN
+must send `Access-Control-Allow-Origin`, which it already does if you load models or fonts from
+it). If even that fails, decoding falls back to the main thread rather than erroring.
+`setWorkerUrl(url)` exists as a manual override for exotic setups.
+
 Or decode a raw Draco bitstream without Three.js:
 
 ```ts

package/dist/three.d.ts

@@ -154,7 +154,10 @@ declare class MiniDRACOLoader extends Loader<BufferGeometry> {
         entry: WorkerEntry;
     }>;
     _workersBroken: boolean;
+    _workerUrl: string | URL | null;
+    _workerBlobUrl: string | null;
     constructor(manager?: LoadingManager);
+    setWorkerUrl(url: string | URL | null): this;
     setDecoderPath(_path?: string): this;
     setDecoderConfig(_config?: object): this;
     setWorkerLimit(limit: number): this;
@@ -166,7 +169,7 @@ declare class MiniDRACOLoader extends Loader<BufferGeometry> {
     decodeGeometry(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
     _runTask(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
     _workersAvailable(): boolean;
-    _getWorker(): WorkerEntry;
+    _getWorker(): WorkerEntry | null;
     _decodeInWorker(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<RawGeometry>;
     _buildGeometryFromRaw(raw: RawGeometry, taskConfig: TaskConfig): BufferGeometry;
     _decodeBuffer(buffer: ArrayBuffer, taskConfig: TaskConfig): BufferGeometry;

package/dist/three.js

@@ -6714,6 +6714,10 @@ var MiniDRACOLoader = class extends Loader {
   // Set when spawning a worker fails (bundler without module-worker support,
   // file:// pages, …): decoding transparently falls back to the main thread.
   _workersBroken;
+  _workerUrl;
+  // Same-origin blob bootstrap used when the worker asset lives on a CDN
+  // origin (created lazily, revoked on dispose).
+  _workerBlobUrl;
   constructor(manager) {
     super(manager);
     this.defaultAttributeIDs = {
@@ -6733,6 +6737,16 @@ var MiniDRACOLoader = class extends Loader {
     this._taskId = 0;
     this._tasks = /* @__PURE__ */ new Map();
     this._workersBroken = false;
+    this._workerUrl = null;
+    this._workerBlobUrl = null;
+  }
+  // Overrides where the decode worker is loaded from. Normally unnecessary:
+  // the worker resolves through `new URL('./worker.js', import.meta.url)`
+  // (bundlers emit it as a hashed asset), and CDN origins are handled by the
+  // blob bootstrap in _getWorker.
+  setWorkerUrl(url) {
+    this._workerUrl = url;
+    return this;
   }
   // Kept for API compatibility with THREE.DRACOLoader — minidraco has no
   // external decoder files to configure.
@@ -6754,6 +6768,10 @@ var MiniDRACOLoader = class extends Loader {
     for (const entry of this._workers) entry.worker.terminate();
     this._workers = [];
     this._tasks.clear();
+    if (this._workerBlobUrl !== null) {
+      URL.revokeObjectURL(this._workerBlobUrl);
+      this._workerBlobUrl = null;
+    }
     return this;
   }
   load(url, onLoad, onProgress, onError) {
@@ -6817,8 +6835,24 @@ var MiniDRACOLoader = class extends Loader {
     return this.workerLimit > 0 && typeof Worker !== "undefined" && !this._workersBroken;
   }
   _getWorker() {
+    if (this._workersBroken) return null;
     if (this._workers.length < this.workerLimit) {
-      const worker = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+      const workerUrl = this._workerUrl ?? new URL("./worker.js", import.meta.url);
+      let worker;
+      try {
+        worker = new Worker(workerUrl, { type: "module" });
+      } catch {
+        try {
+          if (this._workerBlobUrl === null) {
+            const bootstrap = `import ${JSON.stringify(String(workerUrl))};`;
+            this._workerBlobUrl = URL.createObjectURL(new Blob([bootstrap], { type: "text/javascript" }));
+          }
+          worker = new Worker(this._workerBlobUrl, { type: "module" });
+        } catch {
+          this._workersBroken = true;
+          return null;
+        }
+      }
       const entry = { worker, pending: 0 };
       worker.onmessage = (event) => {
         const { id, ok, indices, attributes, error } = event.data;
@@ -6852,6 +6886,9 @@ var MiniDRACOLoader = class extends Loader {
   }
   _decodeInWorker(buffer, taskConfig) {
     const entry = this._getWorker();
+    if (entry === null) {
+      return Promise.reject(new Error("MiniDRACOLoader: worker unavailable"));
+    }
     const id = this._taskId++;
     return new Promise((resolve, reject) => {
       this._tasks.set(id, { resolve, reject, entry });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minidraco",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A fast pure-TypeScript Draco mesh decoder, drop-in DRACOLoader replacement for Three.js.",
   "license": "MIT",
   "files": [
@@ -33,5 +33,10 @@
   },
   "peerDependencies": {
     "three": ">=0.170"
+  },
+  "peerDependenciesMeta": {
+    "three": {
+      "optional": true
+    }
   }
 }