minidraco 0.8.0 → 0.9.0

package/dist/pool.js

@@ -8,9 +8,9 @@ var WorkerPool = class {
   // Pool size; the loader keeps it in sync with setWorkerLimit().
   limit;
   Ga;
-  C = [];
+  D = [];
   Ec = 0;
-  ba = /* @__PURE__ */ new Map();
+  da = /* @__PURE__ */ new Map();
   // Tasks queued during the current microtask; flushed as one batched message
   // per worker (a 488-primitive scene costs 4 postMessages, not 488).
   Ha = [];
@@ -30,18 +30,18 @@ var WorkerPool = class {
   // at startup (see worker.ts), so spawning early lets that overlap the model
   // download instead of the first decode burst.
   spawnAll() {
-    while (this.C.length < this.limit && this.ac() !== null) {
+    while (this.D.length < this.limit && this.ac() !== null) {
     }
   }
   dispose() {
-    for (const entry of this.C) entry.worker.terminate();
-    this.C = [];
+    for (const entry of this.D) entry.worker.terminate();
+    this.D = [];
     const error = decodeError("MinidracoLoader: disposed while decoding");
     for (const task of this.Ha) task.reject(error);
     this.Ha = [];
     this.Ya = false;
-    for (const [, task] of this.ba) task.reject(error);
-    this.ba.clear();
+    for (const [, task] of this.da) task.reject(error);
+    this.da.clear();
     if (this.oa !== null) {
       URL.revokeObjectURL(this.oa);
       this.oa = null;
@@ -59,7 +59,7 @@ var WorkerPool = class {
   }
   ac() {
     if (this.broken) return null;
-    if (this.C.length < this.limit) {
+    if (this.D.length < this.limit) {
       const workerUrl = this.Ga ?? new URL("./worker.js", import.meta.url);
       let worker;
       try {
@@ -79,9 +79,9 @@ var WorkerPool = class {
       const entry = { worker, pending: 0 };
       worker.onmessage = (event) => {
         for (const { id, ok, indices, attributes, error } of event.data.results) {
-          const task = this.ba.get(id);
+          const task = this.da.get(id);
           if (!task) continue;
-          this.ba.delete(id);
+          this.da.delete(id);
           task.entry.pending--;
           if (ok) {
             task.resolve({ indices, attributes });
@@ -92,18 +92,18 @@ var WorkerPool = class {
       };
       worker.onerror = (event) => {
         this.broken = true;
-        for (const [id, task] of this.ba) {
+        for (const [id, task] of this.da) {
           if (task.entry.worker === worker) {
-            this.ba.delete(id);
+            this.da.delete(id);
             task.reject(new Error(`MinidracoLoader worker failed: ${event.message ?? "unknown error"}`));
           }
         }
       };
-      this.C.push(entry);
+      this.D.push(entry);
       return entry;
     }
-    let best = this.C[0];
-    for (const entry of this.C) if (entry.pending < best.pending) best = entry;
+    let best = this.D[0];
+    for (const entry of this.D) if (entry.pending < best.pending) best = entry;
     return best;
   }
   Fc() {
@@ -111,9 +111,9 @@ var WorkerPool = class {
     const batch = this.Ha;
     if (batch.length === 0) return;
     this.Ha = [];
-    while (this.C.length < Math.min(this.limit, batch.length) && this.ac() !== null) {
+    while (this.D.length < Math.min(this.limit, batch.length) && this.ac() !== null) {
     }
-    if (this.broken || this.C.length === 0) {
+    if (this.broken || this.D.length === 0) {
       const error = new Error("MinidracoLoader: worker unavailable");
       for (const task of batch) task.reject(error);
       return;
@@ -122,7 +122,7 @@ var WorkerPool = class {
     let totalBytes = 0;
     for (const task of batch) totalBytes += task.buffer.byteLength;
     const averageBytes = totalBytes / batch.length;
-    const buckets = this.C.map((entry) => ({
+    const buckets = this.D.map((entry) => ({
       entry,
       tasks: [],
       bytes: entry.pending * averageBytes
@@ -136,7 +136,7 @@ var WorkerPool = class {
     for (const { entry, tasks } of buckets) {
       if (tasks.length === 0) continue;
       entry.pending += tasks.length;
-      for (const task of tasks) this.ba.set(task.id, { resolve: task.resolve, reject: task.reject, entry });
+      for (const task of tasks) this.da.set(task.id, { resolve: task.resolve, reject: task.reject, entry });
       entry.worker.postMessage({
         tasks: tasks.map((task) => ({
           id: task.id,

package/dist/three.d.ts

@@ -49,6 +49,7 @@ declare class PointAttribute extends GeometryAttribute {
     constructor(geometryAttribute?: GeometryAttribute);
     init(attributeType: number, numComponents: number, dataType: number, normalized: boolean, numAttributeValues: number): void;
     reset(numAttributeValues: number): boolean;
+    resetWithData(data: Uint8Array, numAttributeValues: number): void;
     resetLazy(numAttributeValues: number): void;
     setLazyInteger(values: Int32Array | null): void;
     setLazyQuantized(values: Int32Array | null, minValues: number[], delta: number, bounded: boolean): void;
@@ -67,8 +68,8 @@ declare class PointAttribute extends GeometryAttribute {
     extractTo<C extends new (length: number) => ExtractTypedArray>(OutputTypedArray: C, numPoints: number): InstanceType<C>;
     _lazyMap(numPoints: number): Uint32Array;
     _lazyFloatValues(): Int32Array;
-    _extractQuantized(out: ExtractTypedArray, numPoints: number): void;
-    _extractOctahedron(out: ExtractTypedArray, numPoints: number): void;
+    _extractQuantized(out: Float32Array, numPoints: number): void;
+    _extractOctahedron(out: Float32Array, numPoints: number): void;
     _extractInteger(out: ExtractTypedArray, numPoints: number): void;
 }