nucleation 0.2.18 → 0.3.1

package/Autostack.d.ts

@@ -0,0 +1,43 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError"
+import type { Schematic } from "./Schematic"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Free functions in the old ABI hung directly off `schematic_*`; here they get a
+ * namespacing opaque-less home via static methods on a zero-size type is not
+ * supported, so they live as static methods taking `&Schematic` explicitly.
+ */
+export class Autostack {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Detect repeating structures (region coverage). Writes a JSON array string;
+     * each element has `mode`, `vectors`, `coverage`, `region_min`/`region_max`,
+     * `cell_min`/`cell_max`, `label`.
+     */
+    static detectStructures(schematic: Schematic): string;
+
+    /**
+     * Graph-based detection: recovers diagonal lattice periods via the redstone
+     * logic graph. Writes `"[]"` for non-redstone builds. Requires the
+     * `simulation` feature; writes `"[]"` when compiled without it.
+     */
+    static detectStructuresGraph(schematic: Schematic): string;
+
+    /**
+     * Resize a 1D / diagonal structure along its period vector.
+     */
+    static resize1d(schematic: Schematic, vx: number, vy: number, vz: number, units: number): Schematic;
+
+    /**
+     * Resize a 2D structure to `n1`×`n2` cells along the two period vectors.
+     */
+    static resize2d(schematic: Schematic, v1x: number, v1y: number, v1z: number, v2x: number, v2y: number, v2z: number, n1: number, n2: number): Schematic;
+}

package/Autostack.mjs

@@ -0,0 +1,134 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import { Schematic } from "./Schematic.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const Autostack_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.Autostack_destroy(ptr);
+});
+
+/**
+ * Free functions in the old ABI hung directly off `schematic_*`; here they get a
+ * namespacing opaque-less home via static methods on a zero-size type is not
+ * supported, so they live as static methods taking `&Schematic` explicitly.
+ */
+export class Autostack {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("Autostack is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            Autostack_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Detect repeating structures (region coverage). Writes a JSON array string;
+     * each element has `mode`, `vectors`, `coverage`, `region_min`/`region_max`,
+     * `cell_min`/`cell_max`, `label`.
+     */
+    static detectStructures(schematic) {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.Autostack_detect_structures(schematic.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * Graph-based detection: recovers diagonal lattice periods via the redstone
+     * logic graph. Writes `"[]"` for non-redstone builds. Requires the
+     * `simulation` feature; writes `"[]"` when compiled without it.
+     */
+    static detectStructuresGraph(schematic) {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.Autostack_detect_structures_graph(schematic.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * Resize a 1D / diagonal structure along its period vector.
+     */
+    static resize1d(schematic, vx, vy, vz, units) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Autostack_resize_1d(diplomatReceive.buffer, schematic.ffiValue, vx, vy, vz, units);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new Schematic(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Resize a 2D structure to `n1`×`n2` cells along the two period vectors.
+     */
+    static resize2d(schematic, v1x, v1y, v1z, v2x, v2y, v2z, n1, n2) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Autostack_resize_2d(diplomatReceive.buffer, schematic.ffiValue, v1x, v1y, v1z, v2x, v2y, v2z, n1, n2);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new Schematic(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/BlockPos.d.ts

@@ -0,0 +1,28 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+export type BlockPos_obj = {
+    x: number;
+    y: number;
+    z: number;
+};
+
+
+
+export class BlockPos {
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    /** @internal */
+    static fromFields(structObj : BlockPos_obj) : BlockPos;
+
+    /**
+    * Create `BlockPos` from an object that contains all of `BlockPos`s fields.
+    * Optional fields do not need to be included in the provided object.
+    */
+    constructor(structObj: BlockPos_obj);
+
+}

package/BlockPos.mjs

@@ -0,0 +1,129 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+export class BlockPos {
+    #x;
+    get x() {
+        return this.#x;
+    }
+    set x(value){
+        this.#x = value;
+    }
+    #y;
+    get y() {
+        return this.#y;
+    }
+    set y(value){
+        this.#y = value;
+    }
+    #z;
+    get z() {
+        return this.#z;
+    }
+    set z(value){
+        this.#z = value;
+    }
+    /** @internal */
+    static fromFields(structObj) {
+        return new BlockPos(structObj);
+    }
+
+    #internalConstructor(structObj) {
+        if (typeof structObj !== "object") {
+            throw new Error("BlockPos's constructor takes an object of BlockPos's fields.");
+        }
+
+        if ("x" in structObj) {
+            this.#x = structObj.x;
+        } else {
+            throw new Error("Missing required field x.");
+        }
+
+        if ("y" in structObj) {
+            this.#y = structObj.y;
+        } else {
+            throw new Error("Missing required field y.");
+        }
+
+        if ("z" in structObj) {
+            this.#z = structObj.z;
+        } else {
+            throw new Error("Missing required field z.");
+        }
+
+        return this;
+    }
+
+    // Return this struct in FFI function friendly format.
+    // Returns an array that can be expanded with spread syntax (...)
+    _intoFFI(
+        dst,
+        functionCleanupArena,
+        appendArrayMap
+    ) {
+
+        this._writeToArrayBuffer(wasm.memory.buffer, dst, functionCleanupArena, appendArrayMap);
+
+        return dst;
+    }
+
+    static get _sizeBytes() {
+        return 12;
+    }
+
+    /// Currently unused, we may want to use later on though:
+    static get _sizeAlign() {
+        return 4;
+    }
+
+    static _fromSuppliedValue(internalConstructor, obj) {
+        if (internalConstructor !== diplomatRuntime.internalConstructor) {
+            throw new Error("_fromSuppliedValue cannot be called externally.");
+        }
+
+        if (obj instanceof BlockPos) {
+            return obj;
+        }
+
+        return BlockPos.fromFields(obj);
+    }
+
+    _writeToArrayBuffer(
+        arrayBuffer,
+        offset,
+        functionCleanupArena,
+        appendArrayMap
+    ) {
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 0, this.#x, Int32Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 4, this.#y, Int32Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 8, this.#z, Int32Array);
+    }
+
+    // This struct contains borrowed fields, so this takes in a list of
+    // "edges" corresponding to where each lifetime's data may have been borrowed from
+    // and passes it down to individual fields containing the borrow.
+    // This method does not attempt to handle any dependencies between lifetimes, the caller
+    // should handle this when constructing edge arrays.
+    static _fromFFI(internalConstructor, ptr) {
+        if (internalConstructor !== diplomatRuntime.internalConstructor) {
+            throw new Error("BlockPos._fromFFI is not meant to be called externally. Please use the default constructor.");
+        }
+        let structObj = {};
+        const xDeref = (new Int32Array(wasm.memory.buffer, ptr, 1))[0];
+        structObj.x = xDeref;
+        const yDeref = (new Int32Array(wasm.memory.buffer, ptr + 4, 1))[0];
+        structObj.y = yDeref;
+        const zDeref = (new Int32Array(wasm.memory.buffer, ptr + 8, 1))[0];
+        structObj.z = zDeref;
+
+        return new BlockPos(structObj);
+    }
+
+
+    constructor(structObj) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/BlockState.d.ts

@@ -0,0 +1,39 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A block state: a block name plus its properties. Port of the old
+ * `BlockStateWrapper` / `blockstate_*` fns.
+ */
+export class BlockState {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create a block state with the given name and no properties.
+     */
+    static create(name: string): BlockState;
+
+    /**
+     * A copy of this block state with `key=value` set; the original is
+     * unchanged.
+     */
+    withProperty(key: string, value: string): BlockState;
+
+    /**
+     * The block name (e.g. `minecraft:stone`).
+     */
+    name(): string;
+
+    /**
+     * The properties as a JSON object of string→string (the old
+     * `CPropertyArray`).
+     */
+    propertiesJson(): string;
+}

package/BlockState.mjs

@@ -0,0 +1,134 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const BlockState_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.BlockState_destroy(ptr);
+});
+
+/**
+ * A block state: a block name plus its properties. Port of the old
+ * `BlockStateWrapper` / `blockstate_*` fns.
+ */
+export class BlockState {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("BlockState is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            BlockState_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Create a block state with the given name and no properties.
+     */
+    static create(name) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const nameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, name)));
+
+        const result = wasm.BlockState_create(nameSlice.ptr);
+
+        try {
+            return new BlockState(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+        }
+    }
+
+    /**
+     * A copy of this block state with `key=value` set; the original is
+     * unchanged.
+     */
+    withProperty(key, value) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const keySlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, key)));
+        const valueSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, value)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.BlockState_with_property(diplomatReceive.buffer, this.ffiValue, keySlice.ptr, valueSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new BlockState(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * The block name (e.g. `minecraft:stone`).
+     */
+    name() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.BlockState_name(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * The properties as a JSON object of string→string (the old
+     * `CPropertyArray`).
+     */
+    propertiesJson() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.BlockState_properties_json(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/Brush.d.ts

@@ -0,0 +1,68 @@
+// generated by diplomat-tool
+import type { InterpolationSpace } from "./InterpolationSpace"
+import type { NucleationError } from "./NucleationError"
+import type { Palette } from "./Palette"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Decides which block goes at each point of a filled shape. Wraps `BrushEnum`.
+ */
+export class Brush {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Every point becomes `block_name` (a block-state string).
+     */
+    static solid(blockName: string): Brush;
+
+    /**
+     * Nearest-block-to-RGB-color brush.
+     */
+    static color(r: number, g: number, b: number): Brush;
+
+    /**
+     * Linear color gradient between two anchored points.
+     */
+    static linearGradient(x1: number, y1: number, z1: number, r1: number, g1: number, b1: number, x2: number, y2: number, z2: number, r2: number, g2: number, b2: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Base color shaded by surface normal against light direction
+     * (`lx`, `ly`, `lz`).
+     */
+    static shaded(r: number, g: number, b: number, lx: number, ly: number, lz: number): Brush;
+
+    /**
+     * Bilinear gradient over the patch `origin + s*u + t*v` with corner colors
+     * c00/c10/c01/c11.
+     */
+    static bilinearGradient(ox: number, oy: number, oz: number, ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, r00: number, g00: number, b00: number, r10: number, g10: number, b10: number, r01: number, g01: number, b01: number, r11: number, g11: number, b11: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Inverse-distance-weighted gradient between colored anchor points.
+     * `positions` is flat `[x0, y0, z0, x1, …]` and `colors` is flat
+     * `[r0, g0, b0, r1, …]`; both must describe the same non-zero number of
+     * points (`positions.len() == colors.len()`, a multiple of 3).
+     */
+    static pointGradient(positions: Array<number>, colors: Array<number>, falloff: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Use `palette` for this brush's color→block snapping instead of the
+     * default all-blocks palette. No-op for `solid` brushes, which place
+     * a fixed block state. Set it before filling; the palette is shared,
+     * not copied.
+     */
+    setPalette(palette: Palette): void;
+
+    /**
+     * Gradient along a parametric curve: `stops` holds the curve parameters in
+     * `[0, 1]` and `colors` the matching flat RGB triples
+     * (`colors.len() == stops.len() * 3`, `stops` non-empty).
+     */
+    static curveGradient(stops: Array<number>, colors: Array<number>, space: InterpolationSpace): Brush;
+}