minerender 2.1.0-alpha.35 → 2.1.0-alpha.36

package/dist/bundle.js

@@ -11384,7 +11384,7 @@ var MineRender = (() => {
       Object.defineProperty(exports13, "__esModule", { value: true });
       exports13.JobQueue = void 0;
       var Base_1 = require_Base();
-      var JobQueue2 = class extends Base_1.RunnerBase {
+      var JobQueue3 = class extends Base_1.RunnerBase {
         /**
          * Create a new queue
          * @param runner function(key):Promise to execute the job
@@ -11418,7 +11418,7 @@ var MineRender = (() => {
           }
         }
       };
-      exports13.JobQueue = JobQueue2;
+      exports13.JobQueue = JobQueue3;
     }
   });
 
@@ -70311,24 +70311,20 @@ return ${compiler2.callType("value", tagType)}
   init_dirname();
   init_buffer2();
   init_process2();
+  var import_jobqu2 = __toESM(require_src());
   var BatchedExecutor = class {
     constructor(interval = 1, batch = 30) {
+      if (!Number.isFinite(interval) || interval < 0) throw new RangeError("Batch interval must be finite and nonnegative");
+      if (!Number.isInteger(batch) || batch < 1) throw new RangeError("Batch size must be a positive integer");
       this.interval = interval;
       this.batch = batch;
-      this.queue = [];
-      this.task = setInterval(() => this.run());
+      this.queue = new import_jobqu2.JobQueue(async (task) => task(), { interval, maxPerRun: batch, maxActive: batch });
     }
     submit(task) {
-      this.queue.push(task);
+      return this.queue.add(() => task());
     }
-    run() {
-      for (let i4 = 0; i4 < this.batch; i4++) {
-        this.runNext();
-      }
-    }
-    runNext() {
-      let next = this.queue.shift();
-      if (next) next();
+    stop() {
+      this.queue.end();
     }
   };
 
@@ -87578,22 +87574,39 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       const chunk = Chunk.isAir(value) ? this.getChunkAt(posOrX) : this.getOrCreateChunkAt(posOrX);
       return chunk?.setBlockAt(posOrX, value);
     }
-    async placeMultiBlock(multiblock, useBatches = true, executor = new BatchedExecutor()) {
-      const keys = new Set(multiblock.blocks.map((block) => AssetKey.parse("blockstates", block.type)));
-      await BlockStates.getAll(keys);
-      const place = async (block) => {
-        if (useBatches && typeof executor !== "undefined") {
-          await new Promise((resolve, reject) => {
-            executor.submit(() => {
-              this.setBlockAt(block.position, block).then(resolve).catch(reject);
-            });
-          });
-        } else {
-          await this.setBlockAt(block.position, block);
+    async placeMultiBlock(multiblock, useBatches = true, executor) {
+      const keys = /* @__PURE__ */ new Map();
+      for (const block of multiblock.blocks) {
+        if (Chunk.isAir(block)) continue;
+        const key = AssetKey.parse("blockstates", block.type);
+        keys.set(key.serialize(), key);
+      }
+      await BlockStates.getAll(keys.values());
+      if (!useBatches) {
+        for (const block of multiblock.blocks) await this.setBlockAt(block.position, block);
+        return;
+      }
+      const positions = /* @__PURE__ */ new Map();
+      for (const block of multiblock.blocks) {
+        const key = block.position.join(",");
+        const group = positions.get(key);
+        if (group) group.push(block);
+        else positions.set(key, [block]);
+      }
+      const groups = [...positions.values()];
+      const queue2 = executor ?? new BatchedExecutor();
+      try {
+        for (let i4 = 0; i4 < groups.length; i4 += queue2.batch) {
+          const results = await Promise.allSettled(groups.slice(i4, i4 + queue2.batch).map(
+            (blocks) => queue2.submit(async () => {
+              for (const block of blocks) await this.setBlockAt(block.position, block);
+            })
+          ));
+          const failure = results.find((result) => result.status === "rejected");
+          if (failure?.status === "rejected") throw failure.reason;
         }
-      };
-      for (let block of multiblock.blocks) {
-        await place(block);
+      } finally {
+        if (!executor) queue2.stop();
       }
     }
     async clear() {