@kontor/kontor-sdk 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/esm/sdk/utils/wit/codecs/list.js

@@ -0,0 +1,117 @@
+/**
+ * Instance that represents a decoded list<Inner> value.
+ *
+ * Generic parameterization is on the *inner codec constructor* so that
+ * the JS type of this list instance is always ListJs<CodecJs<InnerC>>.
+ */
+export class ListCodecFactory {
+    constructor(innerCodec, data) {
+        Object.defineProperty(this, "innerCodec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: innerCodec
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: data
+        });
+    }
+    toWave() {
+        // Convert array of inner wave expressions back to array syntax
+        const innerWaves = this.data.join(", ");
+        return `[${innerWaves}]`;
+    }
+    toJs() {
+        // Decode each element using the inner codec
+        return this.data.map((innerWave) => {
+            // 1) parse inner WaveExpr → inner WaveData
+            const innerWaveData = this.innerCodec.parseWave(innerWave);
+            // 2) WaveData → inner instance
+            const innerInst = this.innerCodec.fromKontor(innerWaveData);
+            // 3) instance → JS
+            return innerInst.toJs();
+        });
+    }
+    // ----- Static factory to build a typed list<T> codec constructor -----
+    static create(innerCodec) {
+        // Class expression implements the static methods required by CodecConstructor
+        class ListCodecClass {
+            constructor(data) {
+                // Internally forward all instance behavior to ListCodecFactory
+                Object.defineProperty(this, "_impl", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
+                this._impl = new ListCodecFactory(innerCodec, data);
+            }
+            toWave() {
+                return this._impl.toWave();
+            }
+            toJs() {
+                return this._impl.toJs();
+            }
+            // ----- Static methods required by CodecConstructor -----
+            static fromJs(value) {
+                // Convert JS array to array of wave expressions
+                const waveArray = value.map((item) => {
+                    const innerInst = innerCodec.fromJs(item);
+                    return innerInst.toWave();
+                });
+                return new ListCodecClass(waveArray);
+            }
+            static fromKontor(data) {
+                return new ListCodecClass(data);
+            }
+            static parseWave(expr) {
+                // Parse array syntax: "[item1, item2, ...]"
+                const trimmed = expr.trim();
+                // Empty array
+                if (trimmed === "[]") {
+                    return [];
+                }
+                // Remove brackets
+                if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+                    throw new Error(`Expected array syntax [...], got: ${expr}`);
+                }
+                const inner = trimmed.slice(1, -1).trim();
+                if (inner === "") {
+                    return [];
+                }
+                // Split by commas at the top level (respecting nested structures)
+                const items = [];
+                let depth = 0;
+                let current = "";
+                for (let i = 0; i < inner.length; i++) {
+                    const char = inner[i];
+                    if (char === "{" || char === "[" || char === "(") {
+                        depth++;
+                        current += char;
+                    }
+                    else if (char === "}" || char === "]" || char === ")") {
+                        depth--;
+                        current += char;
+                    }
+                    else if (char === "," && depth === 0) {
+                        items.push(current.trim());
+                        current = "";
+                    }
+                    else {
+                        current += char;
+                    }
+                }
+                // Add last item
+                if (current.trim()) {
+                    items.push(current.trim());
+                }
+                return items;
+            }
+        }
+        return ListCodecClass;
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/esm/sdk/utils/wit/codecs/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../../../../src/sdk/utils/wit/codecs/list.ts"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,MAAM,OAAO,gBAAgB;IAI3B,YACmB,UAAkB,EACnB,IAAc;QAD9B;;;;mBAAiB,UAAU;WAAQ;QACnC;;;;mBAAgB,IAAI;WAAU;IAC7B,CAAC;IAEJ,MAAM;QACJ,+DAA+D;QAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxC,OAAO,IAAI,UAAU,GAAe,CAAC;IACvC,CAAC;IAED,IAAI;QACF,4CAA4C;QAC5C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE;YACjC,2CAA2C;YAC3C,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAC7C,SAAS,CACW,CAAC;YAEvB,+BAA+B;YAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAC1C,aAAa,CACO,CAAC;YAEvB,mBAAmB;YACnB,OAAO,SAAS,CAAC,IAAI,EAAqB,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,wEAAwE;IAExE,MAAM,CAAC,MAAM,CAGX,UAAkB;QASlB,8EAA8E;QAC9E,MAAM,cAAc;YAIlB,YAAY,IAAc;gBAH1B,+DAA+D;gBAC9C;;;;;mBAAgC;gBAG/C,IAAI,CAAC,KAAK,GAAG,IAAI,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YACtD,CAAC;YAED,MAAM;gBACJ,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAC7B,CAAC;YAED,IAAI;gBACF,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YAC3B,CAAC;YAED,0DAA0D;YAE1D,MAAM,CAAC,MAAM,CAAC,KAA8B;gBAC1C,gDAAgD;gBAChD,MAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;oBACnC,MAAM,SAAS,GAAG,UAAU,CAAC,MAAM,CAAC,IAAW,CAAC,CAAC;oBACjD,OAAO,SAAS,CAAC,MAAM,EAAE,CAAC;gBAC5B,CAAC,CAAC,CAAC;gBACH,OAAO,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC;YACvC,CAAC;YAED,MAAM,CAAC,UAAU,CAAC,IAAc;gBAC9B,OAAO,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC;YAClC,CAAC;YAED,MAAM,CAAC,SAAS,CAAC,IAAY;gBAC3B,4CAA4C;gBAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBAE5B,cAAc;gBACd,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;oBACrB,OAAO,EAAE,CAAC;gBACZ,CAAC;gBAED,kBAAkB;gBAClB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;oBACvD,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,EAAE,CAAC,CAAC;gBAC/D,CAAC;gBAED,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;gBAC1C,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;oBACjB,OAAO,EAAE,CAAC;gBACZ,CAAC;gBAED,kEAAkE;gBAClE,MAAM,KAAK,GAAa,EAAE,CAAC;gBAC3B,IAAI,KAAK,GAAG,CAAC,CAAC;gBACd,IAAI,OAAO,GAAG,EAAE,CAAC;gBAEjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;oBAEtB,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;wBACjD,KAAK,EAAE,CAAC;wBACR,OAAO,IAAI,IAAI,CAAC;oBAClB,CAAC;yBAAM,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;wBACxD,KAAK,EAAE,CAAC;wBACR,OAAO,IAAI,IAAI,CAAC;oBAClB,CAAC;yBAAM,IAAI,IAAI,KAAK,GAAG,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;wBACvC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;wBAC3B,OAAO,GAAG,EAAE,CAAC;oBACf,CAAC;yBAAM,CAAC;wBACN,OAAO,IAAI,IAAI,CAAC;oBAClB,CAAC;gBACH,CAAC;gBAED,gBAAgB;gBAChB,IAAI,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;oBACnB,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;gBAC7B,CAAC;gBAED,OAAO,KAAK,CAAC;YACf,CAAC;SACF;QAED,OAAO,cAIN,CAAC;IACJ,CAAC;CACF"}

package/dist/esm/sdk/utils/wit/codecs/option.js

@@ -0,0 +1,91 @@
+import { Enum } from "./enum.js";
+export const KontorOption = Enum.Option;
+/**
+ * Instance that represents a decoded option<Inner> value.
+ *
+ * Generic parameterization is on the *inner codec constructor* so that
+ * the JS type of this option instance is always OptionJs<CodecJs<InnerC>>.
+ */
+export class OptionCodecFactory {
+    constructor(innerCodec, data) {
+        Object.defineProperty(this, "innerCodec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: innerCodec
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: data
+        });
+    }
+    toWave() {
+        if (this.data.kind === "none") {
+            return "none";
+        }
+        // assume data.value is a WaveExpr string for the inner
+        return `some(${this.data.value ?? ""})`;
+    }
+    toJs() {
+        if (this.data.kind === "none") {
+            return { kind: "none" };
+        }
+        if (this.data.value == null) {
+            throw new Error("Option some() has no inner value");
+        }
+        // 1) parse inner WaveExpr → inner WaveData
+        const innerWaveData = this.innerCodec.parseWave(this.data.value);
+        // 2) WaveData → inner instance
+        const innerInst = this.innerCodec.fromKontor(innerWaveData);
+        // 3) instance → JS
+        return { kind: "some", value: innerInst.toJs() };
+    }
+    // ----- Static factory to build a typed option<T> codec constructor -----
+    static create(innerCodec) {
+        // Class expression implements the static methods required by CodecConstructor
+        class OptionCodecClass {
+            constructor(data) {
+                // Internally forward all instance behavior to OptionCodecInstance
+                Object.defineProperty(this, "_impl", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
+                this._impl = new OptionCodecFactory(innerCodec, data);
+            }
+            // ----- CodecConstructor statics -----
+            static fromJs(value) {
+                if (value.kind === "none") {
+                    return new OptionCodecFactory(innerCodec, { kind: "none" });
+                }
+                // encode inner via innerCodec
+                const innerInst = innerCodec.fromJs(value.value);
+                const innerWave = innerInst.toWave();
+                return new OptionCodecFactory(innerCodec, {
+                    kind: "some",
+                    value: innerWave,
+                });
+            }
+            static parseWave(expr) {
+                // Expect raw "none" or "some(<inner...>)"
+                return Enum.Option.schema.parse(expr);
+            }
+            static fromKontor(data) {
+                return new OptionCodecFactory(innerCodec, data);
+            }
+            // ----- Instance side -----
+            toWave() {
+                return this._impl.toWave();
+            }
+            toJs() {
+                return this._impl.toJs();
+            }
+        }
+        // Satisfy the CodecConstructor contract with precise generics
+        return OptionCodecClass;
+    }
+}
+//# sourceMappingURL=option.js.map

package/dist/esm/sdk/utils/wit/codecs/option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.js","sourceRoot":"","sources":["../../../../../../src/sdk/utils/wit/codecs/option.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC;AAKxC;;;;;GAKG;AACH,MAAM,OAAO,kBAAkB;IAI7B,YACmB,UAAkB,EACnB,IAAmB;QADnC;;;;mBAAiB,UAAU;WAAQ;QACnC;;;;mBAAgB,IAAI;WAAe;IAClC,CAAC;IAEJ,MAAM;QACJ,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC9B,OAAO,MAAkB,CAAC;QAC5B,CAAC;QACD,uDAAuD;QACvD,OAAO,QAAQ,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,GAAe,CAAC;IACtD,CAAC;IAED,IAAI;QACF,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC1B,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACtD,CAAC;QAED,2CAA2C;QAC3C,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAC7C,IAAI,CAAC,IAAI,CAAC,KAAK,CACK,CAAC;QAEvB,+BAA+B;QAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAC1C,aAAa,CACO,CAAC;QAEvB,mBAAmB;QACnB,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,IAAI,EAAqB,EAAE,CAAC;IACtE,CAAC;IAED,0EAA0E;IAE1E,MAAM,CAAC,MAAM,CAGX,UAAkB;QASlB,8EAA8E;QAC9E,MAAM,gBAAgB;YAIpB,YAAY,IAAmB;gBAH/B,kEAAkE;gBACjD;;;;;mBAAkC;gBAGjD,IAAI,CAAC,KAAK,GAAG,IAAI,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YACxD,CAAC;YAED,uCAAuC;YAEvC,MAAM,CAAC,MAAM,CACX,KAAgC;gBAEhC,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;oBAC1B,OAAO,IAAI,kBAAkB,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;gBAC9D,CAAC;gBACD,8BAA8B;gBAC9B,MAAM,SAAS,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,KAAwB,CAAC,CAAC;gBACpE,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;gBACrC,OAAO,IAAI,kBAAkB,CAAC,UAAU,EAAE;oBACxC,IAAI,EAAE,MAAM;oBACZ,KAAK,EAAE,SAAS;iBACjB,CAAC,CAAC;YACL,CAAC;YAED,MAAM,CAAC,SAAS,CAAC,IAAY;gBAC3B,0CAA0C;gBAC1C,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACxC,CAAC;YAED,MAAM,CAAC,UAAU,CAAC,IAAmB;gBACnC,OAAO,IAAI,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YAClD,CAAC;YAED,4BAA4B;YAE5B,MAAM;gBACJ,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAC7B,CAAC;YACD,IAAI;gBACF,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YAC3B,CAAC;SACF;QAED,8DAA8D;QAC9D,OAAO,gBAIN,CAAC;IACJ,CAAC;CACF"}

package/dist/esm/sdk/utils/wit/codecs/string.js

@@ -0,0 +1,27 @@
+export const StringCodec = {
+    fromJs(value) {
+        return {
+            toWave() {
+                // Wave syntax for string args: we assume quoted
+                return `"${value}"`;
+            },
+            toJs() {
+                return value;
+            },
+        };
+    },
+    fromKontor(data) {
+        return {
+            toWave() {
+                return `"${data}"`;
+            },
+            toJs() {
+                return data;
+            },
+        };
+    },
+    parseWave(expr) {
+        return JSON.parse(expr);
+    },
+};
+//# sourceMappingURL=string.js.map

package/dist/esm/sdk/utils/wit/codecs/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../../../../../src/sdk/utils/wit/codecs/string.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM,CAAC,KAAa;QAClB,OAAO;YACL,MAAM;gBACJ,gDAAgD;gBAChD,OAAO,IAAI,KAAK,GAAe,CAAC;YAClC,CAAC;YACD,IAAI;gBACF,OAAO,KAAK,CAAC;YACf,CAAC;SACF,CAAC;IACJ,CAAC;IAED,UAAU,CAAC,IAAY;QACrB,OAAO;YACL,MAAM;gBACJ,OAAO,IAAI,IAAI,GAAe,CAAC;YACjC,CAAC;YACD,IAAI;gBACF,OAAO,IAAc,CAAC;YACxB,CAAC;SACF,CAAC;IACJ,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;CACoE,CAAC"}

package/dist/esm/sdk/utils/wit/codecs/types.js

@@ -0,0 +1,45 @@
+export const unit = { _tag: "Unit" };
+// ---------- Encoder: JS → WaveExpr (fully type-safe) ----------
+export class Encoder {
+    constructor(schema) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+    }
+    encode(values) {
+        const out = {};
+        for (const key of Object.keys(this.schema)) {
+            const ctor = this.schema[key];
+            const inst = ctor.fromJs(values[key]);
+            out[key] = inst.toWave();
+        }
+        return out;
+    }
+}
+// ---------- Decoder: WaveExpr → JS (inferred from codec) ----------
+export class Decoder {
+    constructor(codec) {
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: codec
+        });
+    }
+    decode(expr) {
+        console.log("in tuple decode");
+        const wave = this.codec.parseWave(expr);
+        console.log({ wave });
+        const inst = this.codec.fromKontor(wave);
+        console.log({ inst });
+        return inst.toJs();
+    }
+}
+// Optional ergonomic helper so callers don't write generics at `new` sites
+export function makeDecoder(codec) {
+    return new Decoder(codec);
+}
+//# sourceMappingURL=types.js.map

package/dist/esm/sdk/utils/wit/codecs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/sdk/utils/wit/codecs/types.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,IAAI,GAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAuE3C,iEAAiE;AAEjE,MAAM,OAAO,OAAO;IAClB,YAA6B,MAAS;QAA1B;;;;mBAAiB,MAAM;WAAG;IAAG,CAAC;IAE1C,MAAM,CAAC,MAAkB;QACvB,MAAM,GAAG,GAAG,EAAkC,CAAC;QAC/C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAmB,EAAE,CAAC;YAC7D,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAE,CAAC;YAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YACtC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC3B,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAED,qEAAqE;AAErE,MAAM,OAAO,OAAO;IAGlB,YAA6B,KAAQ;QAAzB;;;;mBAAiB,KAAK;WAAG;IAAG,CAAC;IAEzC,MAAM,CAAC,IAAY;QACjB,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAiB,CAAC;QACxD,OAAO,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QACtB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAiB,CAAC;QACzD,OAAO,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC,IAAI,EAAgB,CAAC;IACnC,CAAC;CACF;AAED,2EAA2E;AAC3E,MAAM,UAAU,WAAW,CAEzB,KAAQ;IACR,OAAO,IAAI,OAAO,CAAI,KAAK,CAAC,CAAC;AAC/B,CAAC"}

package/dist/esm/sdk/utils/wit/codecs/unit.js

@@ -0,0 +1,22 @@
+import { unit, } from "./types.js";
+class _UnitCodec {
+    constructor() { }
+    static fromJs(_value) {
+        return new _UnitCodec();
+    }
+    static fromKontor(_data) {
+        return new _UnitCodec();
+    }
+    static parseWave(_expr) {
+        // ok branch payload is conceptually "unit"
+        return unit;
+    }
+    toWave() {
+        return "";
+    }
+    toJs() {
+        return unit;
+    }
+}
+export const UnitCodec = _UnitCodec;
+//# sourceMappingURL=unit.js.map

package/dist/esm/sdk/utils/wit/codecs/unit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit.js","sourceRoot":"","sources":["../../../../../../src/sdk/utils/wit/codecs/unit.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,IAAI,GAEL,MAAM,YAAY,CAAC;AAEpB,MAAM,UAAU;IACd,gBAAe,CAAC;IAEhB,MAAM,CAAC,MAAM,CAAC,MAAY;QACxB,OAAO,IAAI,UAAU,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,KAAc;QAC9B,OAAO,IAAI,UAAU,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,KAAa;QAC5B,2CAA2C;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM;QACJ,OAAO,EAAc,CAAC;IACxB,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,UAIxB,CAAC"}

package/dist/esm/sdk/utils/wit/decode-function-result.js

@@ -0,0 +1,36 @@
+import { decodeWitParameter } from "./decode-wit-parameter.js";
+import { getWitItem } from "./get-wit-item.js";
+export function decodeFunctionResult(parameters) {
+    const { wit: wit, functionName, data, } = parameters;
+    let witItem = wit[0];
+    if (functionName) {
+        const item = getWitItem({ wit: wit, name: functionName });
+        // todo: refine error
+        // if (!item) throw new WitFunctionNotFoundError(functionName, { docsPath })
+        if (!item)
+            throw new Error("WitFunctionNotFoundError");
+        witItem = item;
+    }
+    if (witItem.type !== "function")
+        // todo: refine error
+        // throw new WitFunctionNotFoundError(undefined, { docsPath })
+        throw new Error("WitFunctionNotFoundError");
+    if (!witItem.outputs)
+        // todo: refine error
+        // throw new WitFunctionOutputsNotFoundError(witItem.name, { docsPath })
+        throw new Error("WitFunctionNotFoundError");
+    const value = decodeWitParameter(data, witItem.outputs[0]);
+    // TODO: sholdn't have to index on `decoded` here
+    return value.decoded;
+    //
+    // if (values && values.length > 1)
+    //   return values as DecodeFunctionResultReturnType<wit, functionName, args>;
+    // if (values && values.length === 1)
+    //   return values[0] as DecodeFunctionResultReturnType<
+    //     wit,
+    //     functionName,
+    //     args
+    //   >;
+    // return undefined as DecodeFunctionResultReturnType<wit, functionName, args>;
+}
+//# sourceMappingURL=decode-function-result.js.map

package/dist/esm/sdk/utils/wit/decode-function-result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-function-result.js","sourceRoot":"","sources":["../../../../../src/sdk/utils/wit/decode-function-result.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAA4B,MAAM,mBAAmB,CAAC;AAgDzE,MAAM,UAAU,oBAAoB,CAIlC,UAA6D;IAE7D,MAAM,EACJ,GAAG,EAAE,GAAG,EACR,YAAY,EACZ,IAAI,GACL,GAAG,UAA4C,CAAC;IAEjD,IAAI,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACrB,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,IAAI,GAAG,UAAU,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;QAC1D,qBAAqB;QACrB,4EAA4E;QAC5E,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QACvD,OAAO,GAAG,IAAI,CAAC;IACjB,CAAC;IAED,IAAI,OAAQ,CAAC,IAAI,KAAK,UAAU;QAC9B,qBAAqB;QACrB,8DAA8D;QAC9D,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;IAC9C,IAAI,CAAC,OAAQ,CAAC,OAAO;QACnB,qBAAqB;QACrB,wEAAwE;QACxE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;IAE9C,MAAM,KAAK,GAAG,kBAAkB,CAAC,IAAI,EAAE,OAAQ,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC,CAAC;IAC7D,iDAAiD;IACjD,OAAO,KAAK,CAAC,OAA4D,CAAC;IAE1E,EAAE;IACF,mCAAmC;IACnC,8EAA8E;IAC9E,qCAAqC;IACrC,wDAAwD;IACxD,WAAW;IACX,oBAAoB;IACpB,WAAW;IACX,OAAO;IACP,+EAA+E;AACjF,CAAC"}

package/dist/esm/sdk/utils/wit/decode-wit-parameter.js

@@ -0,0 +1,286 @@
+import { InvalidWitEncodingTypeError } from "../../errors/wit.js";
+import { DecimalCodec } from "./codecs/decimal.js";
+import { StringCodec } from "./codecs/string.js";
+import { OptionCodecFactory } from "./codecs/option.js";
+import { ListCodecFactory } from "./codecs/list.js";
+import { makeDecoder, } from "./codecs/types.js";
+const stringDecoder = makeDecoder(StringCodec);
+const decimalDecoder = makeDecoder(DecimalCodec);
+const optionOfDecimalDecoder = makeDecoder(OptionCodecFactory.create(DecimalCodec));
+const optionOfTupleDecoder = (param) => makeDecoder(OptionCodecFactory.create(makeTupleCodecConstructor(param)));
+const listOfDecimalDecoder = makeDecoder(ListCodecFactory.create(DecimalCodec));
+const listOfTupleDecoder = (param) => makeDecoder(ListCodecFactory.create(makeTupleCodecConstructor(param)));
+const tupleDecoder = (param) => makeDecoder(makeTupleCodecConstructor(param));
+//
+export function decodeWitParameter(value, param) {
+    // TODO: type cast
+    const decoder = decoderForParam(param);
+    return {
+        decoded: decoder.decode(value),
+    };
+}
+export function decodeTuple(record, param) {
+    if (!param.components) {
+        throw new Error("Tuple parameter missing components");
+    }
+    console.log("value");
+    return param.components.reduce((acc, component) => {
+        if (!component.name) {
+            throw new Error("Tuple component missing name");
+        }
+        const fieldValue = record[component.name];
+        const decoder = decoderForParam(component);
+        // @ts-ignore
+        acc[component.name] = decoder.decode(fieldValue);
+        return acc;
+    }, {});
+}
+function decoderForParam(p) {
+    const t = p.type;
+    console.log({ t });
+    switch (t) {
+        case "tuple":
+            return tupleDecoder(p);
+        case "string":
+            return stringDecoder;
+        case "decimal":
+            return decimalDecoder;
+        case "option<decimal>":
+            return optionOfDecimalDecoder;
+        case "option<tuple>":
+            return optionOfTupleDecoder(p);
+        case "list<decimal>":
+            return listOfDecimalDecoder;
+        case "list<tuple>":
+            return listOfTupleDecoder(p);
+        case "error":
+        case "contract-address":
+        case "bool":
+        case "s8":
+        case "s16":
+        case "s32":
+        case "s64":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "integer":
+        case "option<string>":
+        case "option<bool>":
+        case "option<s8>":
+        case "option<s16>":
+        case "option<s32>":
+        case "option<s64>":
+        case "option<u8>":
+        case "option<u16>":
+        case "option<u32>":
+        case "option<u64>":
+        case "option<integer>":
+        case "option<_>":
+        case "list<string>":
+        case "list<bool>":
+        case "list<s8>":
+        case "list<s16>":
+        case "list<s32>":
+        case "list<s64>":
+        case "list<u8>":
+        case "list<u16>":
+        case "list<u32>":
+        case "list<u64>":
+        case "list<integer>":
+        case "list<_>":
+        case "result<_, error>":
+        case "result<string, error>":
+        case "result<bool, error>":
+        case "result<s8, error>":
+        case "result<s16, error>":
+        case "result<s32, error>":
+        case "result<s64, error>":
+        case "result<u8, error>":
+        case "result<u16, error>":
+        case "result<u32, error>":
+        case "result<u64, error>":
+        case "result<decimal, error>":
+        case "result<integer, error>":
+        case "result<tuple, error>":
+        case "result<option<string>, error>":
+        case "result<option<bool>, error>":
+        case "result<option<s8>, error>":
+        case "result<option<s16>, error>":
+        case "result<option<s32>, error>":
+        case "result<option<s64>, error>":
+        case "result<option<u8>, error>":
+        case "result<option<u16>, error>":
+        case "result<option<u32>, error>":
+        case "result<option<u64>, error>":
+        case "result<option<decimal>, error>":
+        case "result<option<integer>, error>":
+        case "result<option<_>, error>":
+        case "result<option<tuple>, error>":
+        case "option<list<string>>":
+        case "option<list<bool>>":
+        case "option<list<s8>>":
+        case "option<list<s16>>":
+        case "option<list<s32>>":
+        case "option<list<s64>>":
+        case "option<list<u8>>":
+        case "option<list<u16>>":
+        case "option<list<u32>>":
+        case "option<list<u64>>":
+        case "option<list<decimal>>":
+        case "option<list<integer>>":
+        case "option<list<_>>":
+        case "option<list<tuple>>":
+        case "result<option<list<string>>, error>":
+        case "result<option<list<bool>>, error>":
+        case "result<option<list<s8>>, error>":
+        case "result<option<list<s16>>, error>":
+        case "result<option<list<s32>>, error>":
+        case "result<option<list<s64>>, error>":
+        case "result<option<list<u8>>, error>":
+        case "result<option<list<u16>>, error>":
+        case "result<option<list<u32>>, error>":
+        case "result<option<list<u64>>, error>":
+        case "result<option<list<decimal>>, error>":
+        case "result<option<list<integer>>, error>":
+        case "result<option<list<_>>, error>":
+        case "result<option<list<tuple>>, error>":
+        case "result<list<string>, error>":
+        case "result<list<bool>, error>":
+        case "result<list<s8>, error>":
+        case "result<list<s16>, error>":
+        case "result<list<s32>, error>":
+        case "result<list<s64>, error>":
+        case "result<list<u8>, error>":
+        case "result<list<u16>, error>":
+        case "result<list<u32>, error>":
+        case "result<list<u64>, error>":
+        case "result<list<decimal>, error>":
+        case "result<list<integer>, error>":
+        case "result<list<_>, error>":
+        case "result<list<tuple>, error>":
+            throw new Error("not implemented");
+        default:
+            const exhaustive = t;
+            void exhaustive;
+            throw new InvalidWitEncodingTypeError(t, {
+                docsPath: "tk",
+            });
+        //
+    }
+}
+export class TupleCodecInstance {
+    // 'data' holds the raw parsed JSON object representing the encoded tuple
+    constructor(data, param) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: data
+        });
+        Object.defineProperty(this, "param", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: param
+        });
+    }
+    // Fixes Error 2416: Property 'toWave' must return the branded type WaveExpr
+    toWave() {
+        // Converts JS data back to the wave format (usually a stringified object)
+        throw new Error("TupleCodec.toWave not implemented for decoding context");
+    }
+    toJs() {
+        // The core decoding step: recursively call decodeTuple
+        return decodeTuple(this.data, this.param);
+    }
+}
+export function makeTupleCodecConstructor(param) {
+    if (!param.components) {
+        throw new Error("Cannot create TupleCodec: Parameter missing components");
+    }
+    // 2. Define the CodecConstructor class with static methods
+    // We remove 'implements CodecConstructor<any, any, any>' as the function returns the class itself
+    // (Fixes Error 2420, although the original code had the static methods, this clarifies intent).
+    class TupleCodec {
+        // --- Static CodecConstructor methods ---
+        // Called to create an instance from a JavaScript value (e.g., when encoding)
+        static fromJs(_value) {
+            // NOTE: Full encoding implementation is omitted for focus
+            throw new Error("TupleCodec.fromJs not implemented for decoding context");
+        }
+        // Called to parse the raw encoded string into a JavaScript object (Wave Data)
+        static parseWave(expr) {
+            // For tuples, the raw encoded string is the JSON representation.
+            console.log("parsing tuple wave expr:", expr);
+            return parseWitRecord(expr);
+        }
+        // Called to create an instance from the parsed Wave Data
+        static fromKontor(data) {
+            // Pass the original parameter definition to the instance for use in toJs()
+            return new TupleCodecInstance(data, param);
+        }
+        // --- Instance constructor (optional, mainly for type checking compatibility) ---
+        constructor(data) {
+            // Delegate to the static factory to ensure the instance is correctly initialized
+            return TupleCodec.fromKontor(data);
+        }
+    }
+    // 3. Cast the class to the correct CodecConstructor type
+    return TupleCodec;
+}
+export function parseWitRecord(raw) {
+    // Remove leading/trailing whitespace and outer braces
+    const trimmed = raw.trim().replace(/^\{|\}$/g, "");
+    const result = {};
+    let depth = 0;
+    let currentKey = "";
+    let currentValue = "";
+    let inKey = true;
+    let i = 0;
+    while (i < trimmed.length) {
+        const char = trimmed[i];
+        if (char === "{" || char === "[") {
+            depth++;
+            if (!inKey)
+                currentValue += char;
+        }
+        else if (char === "}" || char === "]") {
+            depth--;
+            if (!inKey)
+                currentValue += char;
+        }
+        else if (char === ":" && depth === 0 && inKey) {
+            // Found the separator between key and value
+            inKey = false;
+            i++;
+            continue;
+        }
+        else if (char === "," && depth === 0) {
+            // Found separator between key-value pairs
+            // @ts-ignore
+            result[currentKey.trim()] = currentValue.trim();
+            currentKey = "";
+            currentValue = "";
+            inKey = true;
+            i++;
+            continue;
+        }
+        else {
+            if (inKey) {
+                currentKey += char;
+            }
+            else {
+                currentValue += char;
+            }
+        }
+        i++;
+    }
+    // Add the last key-value pair
+    if (currentKey.trim()) {
+        // @ts-ignore
+        result[currentKey.trim()] = currentValue.trim();
+    }
+    return result;
+}
+//# sourceMappingURL=decode-wit-parameter.js.map