deepwoken 0.2.0 → 0.2.2

package/index.ts

@@ -1,17 +1,23 @@
 export { ATTUNEMENT_STATS, CORE_STATS, WEAPON_STATS } from './types.js';
 export type { Aspect, Mantra, Outfit, Stat, Talent, Weapon } from './types.js';
+export type { Atom, Clause, ClauseType, Reducability } from './requirement.js';
 
 import type { Aspect, Mantra, Outfit, Stat, Talent, Weapon } from './types.js';
+import type { Clause } from './requirement.js';
 
 // dynamically import wasm bc the server will try to load wasm regardless man
 let WasmDeepData: any;
 let WasmStatMap: any;
+let WasmRequirement: any;
+let wasmNameToIdentifier: (name: string) => string;
 
 if (typeof window !== 'undefined') {
     const wasm = await import('./pkg/deepwoken.js');
     await wasm.default();
     WasmDeepData = wasm.DeepData;
     WasmStatMap = wasm.StatMap;
+    WasmRequirement = wasm.Requirement;
+    wasmNameToIdentifier = wasm.nameToIdentifier;
 }
 
 export class DeepData {
@@ -46,8 +52,14 @@ export class DeepData {
     aspects(): Aspect[] { return this._wasm.aspects(); }
 }
 
+/** Transforms the name of things ingame into a parsable identifier/key used in the database */
+export function nameToIdentifier(name: string): string {
+    return wasmNameToIdentifier(name);
+}
+
 export class StatMap {
-    private _wasm: any;
+    /** @internal */
+    _wasm: any;
 
     constructor(map: Partial<Record<Stat, number>> = {}) {
         this._wasm = new WasmStatMap(map);
@@ -64,3 +76,19 @@ export class StatMap {
     set(stat: Stat, value: number) { this._wasm.set(stat, value); }
     toJSON(): Partial<Record<Stat, number>> { return this._wasm.toJSON(); }
 }
+
+export class Requirement {
+    private _wasm: any;
+
+    constructor(input: string) {
+        this._wasm = new WasmRequirement(input);
+    }
+
+    satisfiedBy(stats: StatMap): boolean { return this._wasm.satisfiedBy(stats._wasm); }
+    isEmpty(): boolean { return this._wasm.isEmpty(); }
+    usedStats(): Stat[] { return this._wasm.usedStats(); }
+    name(): string | null { return this._wasm.name(); }
+    prereqs(): string[] { return this._wasm.prereqs(); }
+    clauses(): Clause[] { return this._wasm.clauses(); }
+    toString(): string { return this._wasm.toString(); }
+}

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "deepwoken",
-    "version": "0.2.0",
+    "version": "0.2.2",
     "type": "module",
     "main": "index.ts",
     "types": "index.ts",
     "files": [
         "index.ts",
         "types.ts",
+        "requirement.ts",
         "generated.ts",
         "pkg/deepwoken_bg.wasm",
         "pkg/deepwoken.js",

package/pkg/deepwoken.d.ts

@@ -29,6 +29,19 @@ export class DeepData {
     weapons(): any;
 }
 
+export class Requirement {
+    free(): void;
+    [Symbol.dispose](): void;
+    clauses(): any;
+    isEmpty(): boolean;
+    name(): string | undefined;
+    constructor(input: string);
+    prereqs(): any;
+    satisfiedBy(stats: StatMap): boolean;
+    toString(): string;
+    usedStats(): any;
+}
+
 export class StatMap {
     free(): void;
     [Symbol.dispose](): void;
@@ -42,6 +55,11 @@ export class StatMap {
     toJSON(): any;
 }
 
+/**
+ * Transforms the name of things ingame into an identifier/key used in the database
+ */
+export function nameToIdentifier(name: string): string;
+
 export function shrineOrderDwb(pre: StatMap, racial: StatMap): StatMap;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
@@ -49,6 +67,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_deepdata_free: (a: number, b: number) => void;
+    readonly __wbg_requirement_free: (a: number, b: number) => void;
     readonly __wbg_statmap_free: (a: number, b: number) => void;
     readonly deepdata_aspects: (a: number) => [number, number, number];
     readonly deepdata_fetchLatest: () => any;
@@ -63,6 +82,15 @@ export interface InitOutput {
     readonly deepdata_outfits: (a: number) => [number, number, number];
     readonly deepdata_talents: (a: number) => [number, number, number];
     readonly deepdata_weapons: (a: number) => [number, number, number];
+    readonly nameToIdentifier: (a: number, b: number) => [number, number];
+    readonly requirement_clauses: (a: number) => [number, number, number];
+    readonly requirement_isEmpty: (a: number) => number;
+    readonly requirement_name: (a: number) => [number, number];
+    readonly requirement_new: (a: number, b: number) => [number, number, number];
+    readonly requirement_prereqs: (a: number) => [number, number, number];
+    readonly requirement_satisfiedBy: (a: number, b: number) => number;
+    readonly requirement_toString: (a: number) => [number, number];
+    readonly requirement_usedStats: (a: number) => [number, number, number];
     readonly shrineOrderDwb: (a: number, b: number) => number;
     readonly statmap_cost: (a: number) => number;
     readonly statmap_get: (a: number, b: number, c: number) => [number, number, number];
@@ -72,17 +100,18 @@ export interface InitOutput {
     readonly statmap_set: (a: number, b: number, c: number, d: number) => [number, number];
     readonly statmap_toJSON: (a: number) => [number, number, number];
     readonly statmap_shrineOrder: (a: number, b: number) => number;
-    readonly wasm_bindgen__closure__destroy__hf10da1d08ed9fc18: (a: number, b: number) => void;
-    readonly wasm_bindgen__closure__destroy__he46194fcf4899997: (a: number, b: number) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__h71bc5879fd2abe15: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen__convert__closures_____invoke__h2dcdf54066fbc735: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__h8e5a743d58fae3f8: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__hfbac65673247baa3: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h22f2fd8de233cef9: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h462ab53fb1f380e1: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h3f8186ac2655158b: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hcf18b6c4eb572639: (a: number, b: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;
     readonly __externref_table_alloc: () => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __wbindgen_start: () => void;
 }
 

package/pkg/deepwoken.js

@@ -172,6 +172,107 @@ export class DeepData {
 }
 if (Symbol.dispose) DeepData.prototype[Symbol.dispose] = DeepData.prototype.free;
 
+export class Requirement {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RequirementFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_requirement_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    clauses() {
+        const ret = wasm.requirement_clauses(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.requirement_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    name() {
+        const ret = wasm.requirement_name(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {string} input
+     */
+    constructor(input) {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.requirement_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        RequirementFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {any}
+     */
+    prereqs() {
+        const ret = wasm.requirement_prereqs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {StatMap} stats
+     * @returns {boolean}
+     */
+    satisfiedBy(stats) {
+        _assertClass(stats, StatMap);
+        const ret = wasm.requirement_satisfiedBy(this.__wbg_ptr, stats.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.requirement_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    usedStats() {
+        const ret = wasm.requirement_usedStats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) Requirement.prototype[Symbol.dispose] = Requirement.prototype.free;
+
 export class StatMap {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -270,6 +371,26 @@ export class StatMap {
 }
 if (Symbol.dispose) StatMap.prototype[Symbol.dispose] = StatMap.prototype.free;
 
+/**
+ * Transforms the name of things ingame into an identifier/key used in the database
+ * @param {string} name
+ * @returns {string}
+ */
+export function nameToIdentifier(name) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nameToIdentifier(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * @param {StatMap} pre
  * @param {StatMap} racial
@@ -513,7 +634,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h2dcdf54066fbc735(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h3f8186ac2655158b(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -637,13 +758,13 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 145, function: Function { arguments: [], shim_idx: 146, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hf10da1d08ed9fc18, wasm_bindgen__convert__closures_____invoke__h8e5a743d58fae3f8);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 146, function: Function { arguments: [], shim_idx: 147, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hfbac65673247baa3, wasm_bindgen__convert__closures_____invoke__hcf18b6c4eb572639);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 169, function: Function { arguments: [Externref], shim_idx: 170, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__he46194fcf4899997, wasm_bindgen__convert__closures_____invoke__h71bc5879fd2abe15);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 166, function: Function { arguments: [Externref], shim_idx: 167, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h22f2fd8de233cef9, wasm_bindgen__convert__closures_____invoke__h462ab53fb1f380e1);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -677,19 +798,19 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h8e5a743d58fae3f8(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h8e5a743d58fae3f8(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__hcf18b6c4eb572639(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hcf18b6c4eb572639(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h71bc5879fd2abe15(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h71bc5879fd2abe15(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h462ab53fb1f380e1(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h462ab53fb1f380e1(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h2dcdf54066fbc735(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h2dcdf54066fbc735(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h3f8186ac2655158b(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h3f8186ac2655158b(arg0, arg1, arg2, arg3);
 }
 
 
@@ -703,6 +824,9 @@ const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate
 const DeepDataFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_deepdata_free(ptr >>> 0, 1));
+const RequirementFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_requirement_free(ptr >>> 0, 1));
 const StatMapFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_statmap_free(ptr >>> 0, 1));

package/requirement.ts

@@ -0,0 +1,15 @@
+import type { Stat } from './generated.js';
+
+export type Reducability = "reducible" | "strict";
+export type ClauseType = "and" | "or";
+
+export interface Atom {
+    reducability: Reducability;
+    value: number;
+    stats: Stat[];
+}
+
+export interface Clause {
+    clause_type: ClauseType;
+    atoms: Atom[];
+}