nucleation 0.1.67 → 0.1.69

package/nucleation-original.js

@@ -395,6 +395,71 @@ export class BlockStateWrapper {
     }
 }
 
+const LazyChunkIteratorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lazychunkiterator_free(ptr >>> 0, 1));
+
+export class LazyChunkIterator {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(LazyChunkIterator.prototype);
+        obj.__wbg_ptr = ptr;
+        LazyChunkIteratorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LazyChunkIteratorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lazychunkiterator_free(ptr, 0);
+    }
+    /**
+     * Get the next chunk on-demand (generates it fresh, doesn't store it)
+     * @returns {any}
+     */
+    next() {
+        const ret = wasm.lazychunkiterator_next(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    has_next() {
+        const ret = wasm.lazychunkiterator_has_next(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    total_chunks() {
+        const ret = wasm.lazychunkiterator_total_chunks(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    current_position() {
+        const ret = wasm.lazychunkiterator_current_position(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    reset() {
+        wasm.lazychunkiterator_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} index
+     */
+    skip_to(index) {
+        wasm.lazychunkiterator_skip_to(this.__wbg_ptr, index);
+    }
+}
+
 const SchematicWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_schematicwrapper_free(ptr >>> 0, 1));
@@ -514,6 +579,23 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_palette_from_region(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * @returns {any}
+     */
+    get_bounding_box() {
+        const ret = wasm.schematicwrapper_get_bounding_box(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} region_name
+     * @returns {any}
+     */
+    get_region_bounding_box(region_name) {
+        const ptr0 = passStringToWasm0(region_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_get_region_bounding_box(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * @param {number} x
      * @param {number} y
@@ -710,6 +792,92 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_chunk_blocks(this.__wbg_ptr, offset_x, offset_y, offset_z, width, height, length);
         return ret;
     }
+    /**
+     * Get all palettes once - eliminates repeated string transfers
+     * Returns: { default: [BlockState], regions: { regionName: [BlockState] } }
+     * @returns {any}
+     */
+    get_all_palettes() {
+        const ret = wasm.schematicwrapper_get_all_palettes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Optimized chunks iterator that returns palette indices instead of full block data
+     * Returns array of: { chunk_x, chunk_y, chunk_z, blocks: [[x,y,z,palette_index],...] }
+     * @param {number} chunk_width
+     * @param {number} chunk_height
+     * @param {number} chunk_length
+     * @returns {Array<any>}
+     */
+    chunks_indices(chunk_width, chunk_height, chunk_length) {
+        const ret = wasm.schematicwrapper_chunks_indices(this.__wbg_ptr, chunk_width, chunk_height, chunk_length);
+        return ret;
+    }
+    /**
+     * Optimized chunks with strategy - returns palette indices
+     * @param {number} chunk_width
+     * @param {number} chunk_height
+     * @param {number} chunk_length
+     * @param {string} strategy
+     * @param {number} camera_x
+     * @param {number} camera_y
+     * @param {number} camera_z
+     * @returns {Array<any>}
+     */
+    chunks_indices_with_strategy(chunk_width, chunk_height, chunk_length, strategy, camera_x, camera_y, camera_z) {
+        const ptr0 = passStringToWasm0(strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_chunks_indices_with_strategy(this.__wbg_ptr, chunk_width, chunk_height, chunk_length, ptr0, len0, camera_x, camera_y, camera_z);
+        return ret;
+    }
+    /**
+     * Get specific chunk blocks as palette indices (for lazy loading individual chunks)
+     * Returns array of [x, y, z, palette_index]
+     * @param {number} offset_x
+     * @param {number} offset_y
+     * @param {number} offset_z
+     * @param {number} width
+     * @param {number} height
+     * @param {number} length
+     * @returns {Array<any>}
+     */
+    get_chunk_blocks_indices(offset_x, offset_y, offset_z, width, height, length) {
+        const ret = wasm.schematicwrapper_get_chunk_blocks_indices(this.__wbg_ptr, offset_x, offset_y, offset_z, width, height, length);
+        return ret;
+    }
+    /**
+     * All blocks as palette indices - for when you need everything at once but efficiently
+     * Returns array of [x, y, z, palette_index]
+     * @returns {Array<any>}
+     */
+    blocks_indices() {
+        const ret = wasm.schematicwrapper_blocks_indices(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get optimization stats
+     * @returns {any}
+     */
+    get_optimization_info() {
+        const ret = wasm.schematicwrapper_get_optimization_info(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} chunk_width
+     * @param {number} chunk_height
+     * @param {number} chunk_length
+     * @param {string} strategy
+     * @param {number} camera_x
+     * @param {number} camera_y
+     * @param {number} camera_z
+     * @returns {LazyChunkIterator}
+     */
+    create_lazy_chunk_iterator(chunk_width, chunk_height, chunk_length, strategy, camera_x, camera_y, camera_z) {
+        const ptr0 = passStringToWasm0(strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_create_lazy_chunk_iterator(this.__wbg_ptr, chunk_width, chunk_height, chunk_length, ptr0, len0, camera_x, camera_y, camera_z);
+        return LazyChunkIterator.__wrap(ret);
+    }
 }
 
 async function __wbg_load(module, imports) {
@@ -791,6 +959,10 @@ function __wbg_get_imports() {
         const ret = Date.now();
         return ret;
     };
+    imports.wbg.__wbg_of_4a05197bfc89556f = function(arg0, arg1, arg2) {
+        const ret = Array.of(arg0, arg1, arg2);
+        return ret;
+    };
     imports.wbg.__wbg_push_737cfc8c1432c2c6 = function(arg0, arg1) {
         const ret = arg0.push(arg1);
         return ret;

package/nucleation.d.ts

@@ -17,6 +17,19 @@ export class BlockStateWrapper {
   name(): string;
   properties(): any;
 }
+export class LazyChunkIterator {
+  private constructor();
+  free(): void;
+  /**
+   * Get the next chunk on-demand (generates it fresh, doesn't store it)
+   */
+  next(): any;
+  has_next(): boolean;
+  total_chunks(): number;
+  current_position(): number;
+  reset(): void;
+  skip_to(index: number): void;
+}
 export class SchematicWrapper {
   free(): void;
   constructor();
@@ -29,6 +42,8 @@ export class SchematicWrapper {
   get_available_schematic_versions(): Array<any>;
   get_palette(): any;
   get_palette_from_region(region_name: string): any;
+  get_bounding_box(): any;
+  get_region_bounding_box(region_name: string): any;
   set_block(x: number, y: number, z: number, block_name: string): void;
   copy_region(from_schematic: SchematicWrapper, min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, target_x: number, target_y: number, target_z: number, excluded_blocks: any): void;
   set_block_with_properties(x: number, y: number, z: number, block_name: string, properties: any): void;
@@ -46,6 +61,35 @@ export class SchematicWrapper {
   chunks(chunk_width: number, chunk_height: number, chunk_length: number): Array<any>;
   chunks_with_strategy(chunk_width: number, chunk_height: number, chunk_length: number, strategy: string, camera_x: number, camera_y: number, camera_z: number): Array<any>;
   get_chunk_blocks(offset_x: number, offset_y: number, offset_z: number, width: number, height: number, length: number): Array<any>;
+  /**
+   * Get all palettes once - eliminates repeated string transfers
+   * Returns: { default: [BlockState], regions: { regionName: [BlockState] } }
+   */
+  get_all_palettes(): any;
+  /**
+   * Optimized chunks iterator that returns palette indices instead of full block data
+   * Returns array of: { chunk_x, chunk_y, chunk_z, blocks: [[x,y,z,palette_index],...] }
+   */
+  chunks_indices(chunk_width: number, chunk_height: number, chunk_length: number): Array<any>;
+  /**
+   * Optimized chunks with strategy - returns palette indices
+   */
+  chunks_indices_with_strategy(chunk_width: number, chunk_height: number, chunk_length: number, strategy: string, camera_x: number, camera_y: number, camera_z: number): Array<any>;
+  /**
+   * Get specific chunk blocks as palette indices (for lazy loading individual chunks)
+   * Returns array of [x, y, z, palette_index]
+   */
+  get_chunk_blocks_indices(offset_x: number, offset_y: number, offset_z: number, width: number, height: number, length: number): Array<any>;
+  /**
+   * All blocks as palette indices - for when you need everything at once but efficiently
+   * Returns array of [x, y, z, palette_index]
+   */
+  blocks_indices(): Array<any>;
+  /**
+   * Get optimization stats
+   */
+  get_optimization_info(): any;
+  create_lazy_chunk_iterator(chunk_width: number, chunk_height: number, chunk_length: number, strategy: string, camera_x: number, camera_y: number, camera_z: number): LazyChunkIterator;
 }
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
@@ -60,6 +104,7 @@ export interface InitOutput {
   readonly __wbg_get_blockposition_z: (a: number) => number;
   readonly __wbg_set_blockposition_z: (a: number, b: number) => void;
   readonly blockposition_new: (a: number, b: number, c: number) => number;
+  readonly __wbg_lazychunkiterator_free: (a: number, b: number) => void;
   readonly __wbg_schematicwrapper_free: (a: number, b: number) => void;
   readonly __wbg_blockstatewrapper_free: (a: number, b: number) => void;
   readonly schematicwrapper_new: () => number;
@@ -72,6 +117,8 @@ export interface InitOutput {
   readonly schematicwrapper_get_available_schematic_versions: (a: number) => any;
   readonly schematicwrapper_get_palette: (a: number) => any;
   readonly schematicwrapper_get_palette_from_region: (a: number, b: number, c: number) => any;
+  readonly schematicwrapper_get_bounding_box: (a: number) => any;
+  readonly schematicwrapper_get_region_bounding_box: (a: number, b: number, c: number) => any;
   readonly schematicwrapper_set_block: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly schematicwrapper_copy_region: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: any) => [number, number];
   readonly schematicwrapper_set_block_with_properties: (a: number, b: number, c: number, d: number, e: number, f: number, g: any) => [number, number];
@@ -89,6 +136,19 @@ export interface InitOutput {
   readonly schematicwrapper_chunks: (a: number, b: number, c: number, d: number) => any;
   readonly schematicwrapper_chunks_with_strategy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
   readonly schematicwrapper_get_chunk_blocks: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+  readonly schematicwrapper_get_all_palettes: (a: number) => any;
+  readonly schematicwrapper_chunks_indices: (a: number, b: number, c: number, d: number) => any;
+  readonly schematicwrapper_chunks_indices_with_strategy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
+  readonly schematicwrapper_get_chunk_blocks_indices: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+  readonly schematicwrapper_blocks_indices: (a: number) => any;
+  readonly schematicwrapper_get_optimization_info: (a: number) => any;
+  readonly schematicwrapper_create_lazy_chunk_iterator: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+  readonly lazychunkiterator_next: (a: number) => any;
+  readonly lazychunkiterator_has_next: (a: number) => number;
+  readonly lazychunkiterator_total_chunks: (a: number) => number;
+  readonly lazychunkiterator_current_position: (a: number) => number;
+  readonly lazychunkiterator_reset: (a: number) => void;
+  readonly lazychunkiterator_skip_to: (a: number, b: number) => void;
   readonly blockstatewrapper_new: (a: number, b: number) => number;
   readonly blockstatewrapper_with_property: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly blockstatewrapper_name: (a: number) => [number, number];

package/package.json

@@ -5,7 +5,7 @@
     "Nano nano@schem.at"
   ],
   "description": "A high-performance Minecraft schematic parser and utility library",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",