@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/packages/common/src/array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.mjs","names":[],"sources":["../../../../packages/common/src/array.ts"],"sourcesContent":["export function arrayEqual<T>(a: ArrayLike<T>, b: ArrayLike<T>): boolean {\n  if (a.length !== b.length) {\n    return false\n  }\n  return Array.from(a).every((val, i) => val === b[i])\n}\n\nexport function concatArrays(...arrs: ArrayLike<number>[]): Uint8Array {\n  const size = arrs.reduce((sum, arr) => sum + arr.length, 0)\n  const c = new Uint8Array(size)\n\n  let offset = 0\n  for (let i = 0; i < arrs.length; i++) {\n    c.set(arrs[i], offset)\n    offset += arrs[i].length\n  }\n\n  return c\n}\n"],"mappings":";AAAA,SAAgB,WAAc,GAAiB,GAA0B;AACvE,KAAI,EAAE,WAAW,EAAE,OACjB,QAAO;AAET,QAAO,MAAM,KAAK,EAAE,CAAC,OAAO,KAAK,MAAM,QAAQ,EAAE,GAAG;;AAGtD,SAAgB,aAAa,GAAG,MAAuC;CACrE,MAAM,OAAO,KAAK,QAAQ,KAAK,QAAQ,MAAM,IAAI,QAAQ,EAAE;CAC3D,MAAM,IAAI,IAAI,WAAW,KAAK;CAE9B,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,IAAE,IAAI,KAAK,IAAI,OAAO;AACtB,YAAU,KAAK,GAAG;;AAGpB,QAAO"}

package/packages/common/src/codecs/codec.d.ts

@@ -0,0 +1,71 @@
+import { EncodingFormat } from "./types.js";
+
+//#region packages/common/src/codecs/codec.d.ts
+
+/**
+ * A bidirectional codec that transforms between application types and wire formats.
+ * Supports format-specific encoding (JSON vs msgpack).
+ *
+ * @template T - The application/runtime type (e.g., bigint, string, Uint8Array)
+ * @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)
+ */
+declare abstract class Codec<T, TEncoded = T, TWireEncoded = TEncoded> {
+  /**
+   * The default value for this type (used to determine if a value should be omitted during encoding)
+   */
+  abstract defaultValue(): T;
+  /**
+   * Encode a value, always returning the value regardless of if it is default
+   * @param value - The application value
+   * @param format - The wire format (json or msgpack)
+   * @returns The encoded value, or the default if it is undefined or null
+   */
+  encode(value: T | undefined | null, format: EncodingFormat): TEncoded;
+  /**
+   * Encode a value, omitting it if set to the default value.
+   * @param value - The application value
+   * @param format - The wire format (json or msgpack)
+   * @returns The encoded value, or undefined if it equals the default (will be omitted)
+   */
+  encodeOptional(value: T | undefined | null, format: EncodingFormat): TEncoded | undefined;
+  /**
+   * Decode a value from wire format
+   * @param value - The wire value
+   * @param format - The wire format (json or msgpack)
+   * @returns The decoded application value
+   */
+  decode(value: TWireEncoded | undefined | null, format: EncodingFormat): T;
+  /**
+   * Decode an optional value from wire format (preserves undefined vs default distinction)
+   * @param value - The wire value
+   * @param format - The wire format (json or msgpack)
+   * @returns The decoded application value, or undefined if wire value was undefined
+   */
+  decodeOptional(value: TWireEncoded | undefined | null, format: EncodingFormat): T | undefined;
+  /**
+   * Transform application value to wire format
+   * Override this method to implement encoding logic, otherwise defaults to pass-through
+   * @param value - The application value (guaranteed to not be undefined or default)
+   * @param format - The wire format
+   * @returns The encoded value
+   */
+  protected toEncoded(value: T, format: EncodingFormat): TEncoded;
+  /**
+   * Transform wire format to application value
+   * Override this method to implement specific decoding logic, otherwise defaults to pass-through
+   * @param value - The wire value (guaranteed to not be undefined)
+   * @param format - The wire format
+   * @returns The decoded value
+   */
+  protected fromEncoded(value: TWireEncoded, format: EncodingFormat): T;
+  /**
+   * Check if a value equals the default value (determines if it should be omitted during encoding)
+   * Override this method for custom default comparison logic, otherwise defaults to default value equality
+   * @param value - The value to check
+   * @returns True if value equals default
+   */
+  isDefaultValue(value: T): boolean;
+}
+//#endregion
+export { Codec };
+//# sourceMappingURL=codec.d.ts.map

package/packages/common/src/codecs/codec.js

@@ -0,0 +1,87 @@
+
+//#region packages/common/src/codecs/codec.ts
+/**
+* A bidirectional codec that transforms between application types and wire formats.
+* Supports format-specific encoding (JSON vs msgpack).
+*
+* @template T - The application/runtime type (e.g., bigint, string, Uint8Array)
+* @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)
+*/
+var Codec = class {
+	/**
+	* Encode a value, always returning the value regardless of if it is default
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or the default if it is undefined or null
+	*/
+	encode(value, format) {
+		if (value === void 0 || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format);
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Encode a value, omitting it if set to the default value.
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or undefined if it equals the default (will be omitted)
+	*/
+	encodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		if (this.isDefaultValue(value)) return void 0;
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Decode a value from wire format
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value
+	*/
+	decode(value, format) {
+		if (value === void 0 || value === null) return this.defaultValue();
+		const decoded = this.fromEncoded(value, format);
+		if (this.isDefaultValue(decoded)) return this.defaultValue();
+		return decoded;
+	}
+	/**
+	* Decode an optional value from wire format (preserves undefined vs default distinction)
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value, or undefined if wire value was undefined
+	*/
+	decodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		return this.fromEncoded(value, format);
+	}
+	/**
+	* Transform application value to wire format
+	* Override this method to implement encoding logic, otherwise defaults to pass-through
+	* @param value - The application value (guaranteed to not be undefined or default)
+	* @param format - The wire format
+	* @returns The encoded value
+	*/
+	toEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Transform wire format to application value
+	* Override this method to implement specific decoding logic, otherwise defaults to pass-through
+	* @param value - The wire value (guaranteed to not be undefined)
+	* @param format - The wire format
+	* @returns The decoded value
+	*/
+	fromEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Check if a value equals the default value (determines if it should be omitted during encoding)
+	* Override this method for custom default comparison logic, otherwise defaults to default value equality
+	* @param value - The value to check
+	* @returns True if value equals default
+	*/
+	isDefaultValue(value) {
+		return value === this.defaultValue();
+	}
+};
+
+//#endregion
+exports.Codec = Codec;
+//# sourceMappingURL=codec.js.map

package/packages/common/src/codecs/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","names":[],"sources":["../../../../../packages/common/src/codecs/codec.ts"],"sourcesContent":["/* eslint-disable unused-imports/no-unused-vars */\nimport type { EncodingFormat } from './types'\n\n/**\n * A bidirectional codec that transforms between application types and wire formats.\n * Supports format-specific encoding (JSON vs msgpack).\n *\n * @template T - The application/runtime type (e.g., bigint, string, Uint8Array)\n * @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)\n */\nexport abstract class Codec<T, TEncoded = T, TWireEncoded = TEncoded> {\n  /**\n   * The default value for this type (used to determine if a value should be omitted during encoding)\n   */\n  public abstract defaultValue(): T\n\n  /**\n   * Encode a value, always returning the value regardless of if it is default\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or the default if it is undefined or null\n   */\n  public encode(value: T | undefined | null, format: EncodingFormat): TEncoded {\n    if (value === undefined || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format)\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Encode a value, omitting it if set to the default value.\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or undefined if it equals the default (will be omitted)\n   */\n  public encodeOptional(value: T | undefined | null, format: EncodingFormat): TEncoded | undefined {\n    if (value === undefined || value === null) return undefined\n    if (this.isDefaultValue(value)) return undefined\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Decode a value from wire format\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value\n   */\n  public decode(value: TWireEncoded | undefined | null, format: EncodingFormat): T {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return this.defaultValue()\n    const decoded = this.fromEncoded(value, format)\n    if (this.isDefaultValue(decoded)) return this.defaultValue()\n    return decoded\n  }\n\n  /**\n   * Decode an optional value from wire format (preserves undefined vs default distinction)\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value, or undefined if wire value was undefined\n   */\n  public decodeOptional(value: TWireEncoded | undefined | null, format: EncodingFormat): T | undefined {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return undefined\n    return this.fromEncoded(value, format)\n  }\n\n  /**\n   * Transform application value to wire format\n   * Override this method to implement encoding logic, otherwise defaults to pass-through\n   * @param value - The application value (guaranteed to not be undefined or default)\n   * @param format - The wire format\n   * @returns The encoded value\n   */\n  protected toEncoded(value: T, format: EncodingFormat): TEncoded {\n    return value as unknown as TEncoded\n  }\n\n  /**\n   * Transform wire format to application value\n   * Override this method to implement specific decoding logic, otherwise defaults to pass-through\n   * @param value - The wire value (guaranteed to not be undefined)\n   * @param format - The wire format\n   * @returns The decoded value\n   */\n  protected fromEncoded(value: TWireEncoded, format: EncodingFormat): T {\n    return value as unknown as T\n  }\n\n  /**\n   * Check if a value equals the default value (determines if it should be omitted during encoding)\n   * Override this method for custom default comparison logic, otherwise defaults to default value equality\n   * @param value - The value to check\n   * @returns True if value equals default\n   */\n  public isDefaultValue(value: T): boolean {\n    return value === this.defaultValue()\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,IAAsB,QAAtB,MAAsE;;;;;;;CAYpE,AAAO,OAAO,OAA6B,QAAkC;AAC3E,MAAI,UAAU,UAAa,UAAU,QAAQ,KAAK,eAAe,MAAM,CAAE,QAAO,KAAK,UAAU,KAAK,cAAc,EAAE,OAAO;AAC3H,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,eAAe,OAA6B,QAA8C;AAC/F,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,MAAI,KAAK,eAAe,MAAM,CAAE,QAAO;AACvC,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,OAAO,OAAwC,QAA2B;AAE/E,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO,KAAK,cAAc;EACrE,MAAM,UAAU,KAAK,YAAY,OAAO,OAAO;AAC/C,MAAI,KAAK,eAAe,QAAQ,CAAE,QAAO,KAAK,cAAc;AAC5D,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAwC,QAAuC;AAEnG,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,SAAO,KAAK,YAAY,OAAO,OAAO;;;;;;;;;CAUxC,AAAU,UAAU,OAAU,QAAkC;AAC9D,SAAO;;;;;;;;;CAUT,AAAU,YAAY,OAAqB,QAA2B;AACpE,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAmB;AACvC,SAAO,UAAU,KAAK,cAAc"}

package/packages/common/src/codecs/codec.mjs

@@ -0,0 +1,86 @@
+//#region packages/common/src/codecs/codec.ts
+/**
+* A bidirectional codec that transforms between application types and wire formats.
+* Supports format-specific encoding (JSON vs msgpack).
+*
+* @template T - The application/runtime type (e.g., bigint, string, Uint8Array)
+* @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)
+*/
+var Codec = class {
+	/**
+	* Encode a value, always returning the value regardless of if it is default
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or the default if it is undefined or null
+	*/
+	encode(value, format) {
+		if (value === void 0 || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format);
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Encode a value, omitting it if set to the default value.
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or undefined if it equals the default (will be omitted)
+	*/
+	encodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		if (this.isDefaultValue(value)) return void 0;
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Decode a value from wire format
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value
+	*/
+	decode(value, format) {
+		if (value === void 0 || value === null) return this.defaultValue();
+		const decoded = this.fromEncoded(value, format);
+		if (this.isDefaultValue(decoded)) return this.defaultValue();
+		return decoded;
+	}
+	/**
+	* Decode an optional value from wire format (preserves undefined vs default distinction)
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value, or undefined if wire value was undefined
+	*/
+	decodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		return this.fromEncoded(value, format);
+	}
+	/**
+	* Transform application value to wire format
+	* Override this method to implement encoding logic, otherwise defaults to pass-through
+	* @param value - The application value (guaranteed to not be undefined or default)
+	* @param format - The wire format
+	* @returns The encoded value
+	*/
+	toEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Transform wire format to application value
+	* Override this method to implement specific decoding logic, otherwise defaults to pass-through
+	* @param value - The wire value (guaranteed to not be undefined)
+	* @param format - The wire format
+	* @returns The decoded value
+	*/
+	fromEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Check if a value equals the default value (determines if it should be omitted during encoding)
+	* Override this method for custom default comparison logic, otherwise defaults to default value equality
+	* @param value - The value to check
+	* @returns True if value equals default
+	*/
+	isDefaultValue(value) {
+		return value === this.defaultValue();
+	}
+};
+
+//#endregion
+export { Codec };
+//# sourceMappingURL=codec.mjs.map

package/packages/common/src/codecs/codec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.mjs","names":[],"sources":["../../../../../packages/common/src/codecs/codec.ts"],"sourcesContent":["/* eslint-disable unused-imports/no-unused-vars */\nimport type { EncodingFormat } from './types'\n\n/**\n * A bidirectional codec that transforms between application types and wire formats.\n * Supports format-specific encoding (JSON vs msgpack).\n *\n * @template T - The application/runtime type (e.g., bigint, string, Uint8Array)\n * @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)\n */\nexport abstract class Codec<T, TEncoded = T, TWireEncoded = TEncoded> {\n  /**\n   * The default value for this type (used to determine if a value should be omitted during encoding)\n   */\n  public abstract defaultValue(): T\n\n  /**\n   * Encode a value, always returning the value regardless of if it is default\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or the default if it is undefined or null\n   */\n  public encode(value: T | undefined | null, format: EncodingFormat): TEncoded {\n    if (value === undefined || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format)\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Encode a value, omitting it if set to the default value.\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or undefined if it equals the default (will be omitted)\n   */\n  public encodeOptional(value: T | undefined | null, format: EncodingFormat): TEncoded | undefined {\n    if (value === undefined || value === null) return undefined\n    if (this.isDefaultValue(value)) return undefined\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Decode a value from wire format\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value\n   */\n  public decode(value: TWireEncoded | undefined | null, format: EncodingFormat): T {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return this.defaultValue()\n    const decoded = this.fromEncoded(value, format)\n    if (this.isDefaultValue(decoded)) return this.defaultValue()\n    return decoded\n  }\n\n  /**\n   * Decode an optional value from wire format (preserves undefined vs default distinction)\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value, or undefined if wire value was undefined\n   */\n  public decodeOptional(value: TWireEncoded | undefined | null, format: EncodingFormat): T | undefined {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return undefined\n    return this.fromEncoded(value, format)\n  }\n\n  /**\n   * Transform application value to wire format\n   * Override this method to implement encoding logic, otherwise defaults to pass-through\n   * @param value - The application value (guaranteed to not be undefined or default)\n   * @param format - The wire format\n   * @returns The encoded value\n   */\n  protected toEncoded(value: T, format: EncodingFormat): TEncoded {\n    return value as unknown as TEncoded\n  }\n\n  /**\n   * Transform wire format to application value\n   * Override this method to implement specific decoding logic, otherwise defaults to pass-through\n   * @param value - The wire value (guaranteed to not be undefined)\n   * @param format - The wire format\n   * @returns The decoded value\n   */\n  protected fromEncoded(value: TWireEncoded, format: EncodingFormat): T {\n    return value as unknown as T\n  }\n\n  /**\n   * Check if a value equals the default value (determines if it should be omitted during encoding)\n   * Override this method for custom default comparison logic, otherwise defaults to default value equality\n   * @param value - The value to check\n   * @returns True if value equals default\n   */\n  public isDefaultValue(value: T): boolean {\n    return value === this.defaultValue()\n  }\n}\n"],"mappings":";;;;;;;;AAUA,IAAsB,QAAtB,MAAsE;;;;;;;CAYpE,AAAO,OAAO,OAA6B,QAAkC;AAC3E,MAAI,UAAU,UAAa,UAAU,QAAQ,KAAK,eAAe,MAAM,CAAE,QAAO,KAAK,UAAU,KAAK,cAAc,EAAE,OAAO;AAC3H,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,eAAe,OAA6B,QAA8C;AAC/F,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,MAAI,KAAK,eAAe,MAAM,CAAE,QAAO;AACvC,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,OAAO,OAAwC,QAA2B;AAE/E,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO,KAAK,cAAc;EACrE,MAAM,UAAU,KAAK,YAAY,OAAO,OAAO;AAC/C,MAAI,KAAK,eAAe,QAAQ,CAAE,QAAO,KAAK,cAAc;AAC5D,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAwC,QAAuC;AAEnG,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,SAAO,KAAK,YAAY,OAAO,OAAO;;;;;;;;;CAUxC,AAAU,UAAU,OAAU,QAAkC;AAC9D,SAAO;;;;;;;;;CAUT,AAAU,YAAY,OAAqB,QAA2B;AACpE,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAmB;AACvC,SAAO,UAAU,KAAK,cAAc"}

package/packages/common/src/codecs/composite/array.js

@@ -0,0 +1,45 @@
+const require_codec = require('../codec.js');
+const require_address = require('../primitives/address.js');
+const require_bigint = require('../primitives/bigint.js');
+const require_boolean = require('../primitives/boolean.js');
+const require_bytes = require('../primitives/bytes.js');
+const require_number = require('../primitives/number.js');
+const require_string = require('../primitives/string.js');
+
+//#region packages/common/src/codecs/composite/array.ts
+/**
+* Array codec - encodes each element using the item codec
+*/
+var ArrayCodec = class extends require_codec.Codec {
+	constructor(itemCodec) {
+		super();
+		this.itemCodec = itemCodec;
+	}
+	defaultValue() {
+		return [];
+	}
+	toEncoded(value, format) {
+		return value.map((item) => this.itemCodec.encode(item, format));
+	}
+	fromEncoded(value, format) {
+		return value.map((item) => this.itemCodec.decode(item, format));
+	}
+	isDefaultValue(value) {
+		return value.length === 0;
+	}
+};
+const bytesArrayCodec = new ArrayCodec(require_bytes.bytesCodec);
+const addressArrayCodec = new ArrayCodec(require_address.addressCodec);
+const bigIntArrayCodec = new ArrayCodec(require_bigint.bigIntCodec);
+const numberArrayCodec = new ArrayCodec(require_number.numberCodec);
+const booleanArrayCodec = new ArrayCodec(require_boolean.booleanCodec);
+const stringArrayCodec = new ArrayCodec(require_string.stringCodec);
+
+//#endregion
+exports.ArrayCodec = ArrayCodec;
+exports.addressArrayCodec = addressArrayCodec;
+exports.bigIntArrayCodec = bigIntArrayCodec;
+exports.bytesArrayCodec = bytesArrayCodec;
+exports.numberArrayCodec = numberArrayCodec;
+exports.stringArrayCodec = stringArrayCodec;
+//# sourceMappingURL=array.js.map

package/packages/common/src/codecs/composite/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","names":["Codec","itemCodec: Codec<T, TEncoded>","bytesCodec","addressCodec","bigIntCodec","numberCodec","booleanCodec","stringCodec"],"sources":["../../../../../../packages/common/src/codecs/composite/array.ts"],"sourcesContent":["import { Codec } from '../codec'\nimport { addressCodec } from '../primitives/address'\nimport { bigIntCodec } from '../primitives/bigint'\nimport { booleanCodec } from '../primitives/boolean'\nimport { bytesCodec } from '../primitives/bytes'\nimport { numberCodec } from '../primitives/number'\nimport { stringCodec } from '../primitives/string'\nimport type { EncodingFormat } from '../types'\n\n/**\n * Array codec - encodes each element using the item codec\n */\nexport class ArrayCodec<T, TEncoded = T> extends Codec<T[], TEncoded[]> {\n  constructor(private readonly itemCodec: Codec<T, TEncoded>) {\n    super()\n  }\n\n  public defaultValue(): T[] {\n    return []\n  }\n\n  protected toEncoded(value: T[], format: EncodingFormat): TEncoded[] {\n    return value.map((item) => this.itemCodec.encode(item, format))\n  }\n\n  protected fromEncoded(value: TEncoded[], format: EncodingFormat): T[] {\n    return value.map((item) => this.itemCodec.decode(item, format))\n  }\n\n  public isDefaultValue(value: T[]): boolean {\n    return value.length === 0\n  }\n}\n\nexport const bytesArrayCodec = new ArrayCodec(bytesCodec)\nexport const addressArrayCodec = new ArrayCodec(addressCodec)\nexport const bigIntArrayCodec = new ArrayCodec(bigIntCodec)\nexport const numberArrayCodec = new ArrayCodec(numberCodec)\nexport const booleanArrayCodec = new ArrayCodec(booleanCodec)\nexport const stringArrayCodec = new ArrayCodec(stringCodec)\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,aAAb,cAAiDA,oBAAuB;CACtE,YAAY,AAAiBC,WAA+B;AAC1D,SAAO;EADoB;;CAI7B,AAAO,eAAoB;AACzB,SAAO,EAAE;;CAGX,AAAU,UAAU,OAAY,QAAoC;AAClE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAU,YAAY,OAAmB,QAA6B;AACpE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAO,eAAe,OAAqB;AACzC,SAAO,MAAM,WAAW;;;AAI5B,MAAa,kBAAkB,IAAI,WAAWC,yBAAW;AACzD,MAAa,oBAAoB,IAAI,WAAWC,6BAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAWC,2BAAY;AAC3D,MAAa,mBAAmB,IAAI,WAAWC,2BAAY;AAC3D,MAAa,oBAAoB,IAAI,WAAWC,6BAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAWC,2BAAY"}

package/packages/common/src/codecs/composite/array.mjs

@@ -0,0 +1,40 @@
+import { Codec } from "../codec.mjs";
+import { addressCodec } from "../primitives/address.mjs";
+import { bigIntCodec } from "../primitives/bigint.mjs";
+import { booleanCodec } from "../primitives/boolean.mjs";
+import { bytesCodec } from "../primitives/bytes.mjs";
+import { numberCodec } from "../primitives/number.mjs";
+import { stringCodec } from "../primitives/string.mjs";
+
+//#region packages/common/src/codecs/composite/array.ts
+/**
+* Array codec - encodes each element using the item codec
+*/
+var ArrayCodec = class extends Codec {
+	constructor(itemCodec) {
+		super();
+		this.itemCodec = itemCodec;
+	}
+	defaultValue() {
+		return [];
+	}
+	toEncoded(value, format) {
+		return value.map((item) => this.itemCodec.encode(item, format));
+	}
+	fromEncoded(value, format) {
+		return value.map((item) => this.itemCodec.decode(item, format));
+	}
+	isDefaultValue(value) {
+		return value.length === 0;
+	}
+};
+const bytesArrayCodec = new ArrayCodec(bytesCodec);
+const addressArrayCodec = new ArrayCodec(addressCodec);
+const bigIntArrayCodec = new ArrayCodec(bigIntCodec);
+const numberArrayCodec = new ArrayCodec(numberCodec);
+const booleanArrayCodec = new ArrayCodec(booleanCodec);
+const stringArrayCodec = new ArrayCodec(stringCodec);
+
+//#endregion
+export { ArrayCodec, addressArrayCodec, bigIntArrayCodec, bytesArrayCodec, numberArrayCodec, stringArrayCodec };
+//# sourceMappingURL=array.mjs.map

package/packages/common/src/codecs/composite/array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.mjs","names":["itemCodec: Codec<T, TEncoded>"],"sources":["../../../../../../packages/common/src/codecs/composite/array.ts"],"sourcesContent":["import { Codec } from '../codec'\nimport { addressCodec } from '../primitives/address'\nimport { bigIntCodec } from '../primitives/bigint'\nimport { booleanCodec } from '../primitives/boolean'\nimport { bytesCodec } from '../primitives/bytes'\nimport { numberCodec } from '../primitives/number'\nimport { stringCodec } from '../primitives/string'\nimport type { EncodingFormat } from '../types'\n\n/**\n * Array codec - encodes each element using the item codec\n */\nexport class ArrayCodec<T, TEncoded = T> extends Codec<T[], TEncoded[]> {\n  constructor(private readonly itemCodec: Codec<T, TEncoded>) {\n    super()\n  }\n\n  public defaultValue(): T[] {\n    return []\n  }\n\n  protected toEncoded(value: T[], format: EncodingFormat): TEncoded[] {\n    return value.map((item) => this.itemCodec.encode(item, format))\n  }\n\n  protected fromEncoded(value: TEncoded[], format: EncodingFormat): T[] {\n    return value.map((item) => this.itemCodec.decode(item, format))\n  }\n\n  public isDefaultValue(value: T[]): boolean {\n    return value.length === 0\n  }\n}\n\nexport const bytesArrayCodec = new ArrayCodec(bytesCodec)\nexport const addressArrayCodec = new ArrayCodec(addressCodec)\nexport const bigIntArrayCodec = new ArrayCodec(bigIntCodec)\nexport const numberArrayCodec = new ArrayCodec(numberCodec)\nexport const booleanArrayCodec = new ArrayCodec(booleanCodec)\nexport const stringArrayCodec = new ArrayCodec(stringCodec)\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,aAAb,cAAiD,MAAuB;CACtE,YAAY,AAAiBA,WAA+B;AAC1D,SAAO;EADoB;;CAI7B,AAAO,eAAoB;AACzB,SAAO,EAAE;;CAGX,AAAU,UAAU,OAAY,QAAoC;AAClE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAU,YAAY,OAAmB,QAA6B;AACpE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAO,eAAe,OAAqB;AACzC,SAAO,MAAM,WAAW;;;AAI5B,MAAa,kBAAkB,IAAI,WAAW,WAAW;AACzD,MAAa,oBAAoB,IAAI,WAAW,aAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAW,YAAY;AAC3D,MAAa,mBAAmB,IAAI,WAAW,YAAY;AAC3D,MAAa,oBAAoB,IAAI,WAAW,aAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAW,YAAY"}

package/packages/common/src/codecs/composite/map.js

@@ -0,0 +1,68 @@
+const require_codec = require('../codec.js');
+
+//#region packages/common/src/codecs/composite/map.ts
+/**
+* Map codec - handles Maps with any key type (including Uint8Array, bigint, number)
+* Depending on the encoding format, the map is encoded differently:
+* - json: Supports string and bigint keys. The map is represented as an object when encoding.
+*   Bigint keys are converted to/from strings (e.g., 1n becomes "1").
+*   An exception is thrown upon encountering an unsupported key type.
+* - msgpack: Preserves key types and is represented as a Map when encoding.
+*/
+var MapCodec = class extends require_codec.Codec {
+	keyType;
+	constructor(keyCodec, valueCodec) {
+		super();
+		this.keyCodec = keyCodec;
+		this.valueCodec = valueCodec;
+		const defaultKeyValue = this.keyCodec.defaultValue();
+		this.keyType = defaultKeyValue instanceof Uint8Array ? "Uint8Array" : typeof defaultKeyValue;
+	}
+	defaultValue() {
+		return /* @__PURE__ */ new Map();
+	}
+	ensureKeyIsSupported(format) {
+		if (format === "msgpack") return true;
+		if (this.keyType !== "string" && this.keyType !== "bigint") throw new Error(`Map key of type '${this.keyType}' is not supported in ${format} format`);
+	}
+	toEncoded(value, format) {
+		this.ensureKeyIsSupported(format);
+		const entries = [];
+		for (const [k, v] of value.entries()) {
+			const encodedKey = this.keyCodec.encode(k, format);
+			const encodedValue = this.valueCodec.encode(v, format);
+			entries.push([encodedKey, encodedValue]);
+		}
+		if (format === "json") {
+			const obj = {};
+			for (const [k, v] of entries) {
+				const keyStr = typeof k === "string" ? k : String(k);
+				obj[keyStr] = v;
+			}
+			return obj;
+		}
+		return new Map(entries);
+	}
+	fromEncoded(value, format) {
+		this.ensureKeyIsSupported(format);
+		const result = /* @__PURE__ */ new Map();
+		let entries;
+		if (value instanceof Map) entries = Array.from(value.entries());
+		else entries = Object.entries(value);
+		for (const [encodedKey, encodedValue] of entries) {
+			let keyToDecode = encodedKey;
+			if (format === "json" && this.keyType === "bigint" && typeof encodedKey === "string") keyToDecode = BigInt(encodedKey);
+			const key = this.keyCodec.decode(keyToDecode, format);
+			const val = this.valueCodec.decode(encodedValue, format);
+			result.set(key, val);
+		}
+		return result;
+	}
+	isDefaultValue(value) {
+		return value.size === 0;
+	}
+};
+
+//#endregion
+exports.MapCodec = MapCodec;
+//# sourceMappingURL=map.js.map

package/packages/common/src/codecs/composite/map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","names":["Codec","keyCodec: Codec<K, KEncoded>","valueCodec: Codec<V, VEncoded>","entries: Array<[KEncoded, VEncoded]>","obj: Record<string, VEncoded>"],"sources":["../../../../../../packages/common/src/codecs/composite/map.ts"],"sourcesContent":["import { Codec } from '../codec'\nimport type { EncodingFormat } from '../types'\n\n/**\n * Map codec - handles Maps with any key type (including Uint8Array, bigint, number)\n * Depending on the encoding format, the map is encoded differently:\n * - json: Supports string and bigint keys. The map is represented as an object when encoding.\n *   Bigint keys are converted to/from strings (e.g., 1n becomes \"1\").\n *   An exception is thrown upon encountering an unsupported key type.\n * - msgpack: Preserves key types and is represented as a Map when encoding.\n */\nexport class MapCodec<K, V, KEncoded = K, VEncoded = V> extends Codec<Map<K, V>, Map<KEncoded, VEncoded> | Record<string, VEncoded>> {\n  private keyType: string\n\n  constructor(\n    private readonly keyCodec: Codec<K, KEncoded>,\n    private readonly valueCodec: Codec<V, VEncoded>,\n  ) {\n    super()\n    const defaultKeyValue = this.keyCodec.defaultValue()\n    this.keyType = defaultKeyValue instanceof Uint8Array ? 'Uint8Array' : typeof defaultKeyValue\n  }\n\n  public defaultValue(): Map<K, V> {\n    return new Map()\n  }\n\n  private ensureKeyIsSupported(format: EncodingFormat) {\n    if (format === 'msgpack') {\n      return true\n    }\n    if (this.keyType !== 'string' && this.keyType !== 'bigint') {\n      throw new Error(`Map key of type '${this.keyType}' is not supported in ${format} format`)\n    }\n  }\n\n  protected toEncoded(value: Map<K, V>, format: EncodingFormat): Map<KEncoded, VEncoded> | Record<string, VEncoded> {\n    this.ensureKeyIsSupported(format)\n\n    const entries: Array<[KEncoded, VEncoded]> = []\n\n    for (const [k, v] of value.entries()) {\n      const encodedKey = this.keyCodec.encode(k, format)\n      const encodedValue = this.valueCodec.encode(v, format)\n      entries.push([encodedKey, encodedValue])\n    }\n    if (format === 'json') {\n      const obj: Record<string, VEncoded> = {}\n      for (const [k, v] of entries) {\n        const keyStr = typeof k === 'string' ? k : String(k)\n        obj[keyStr] = v\n      }\n      return obj\n    }\n\n    return new Map(entries)\n  }\n\n  protected fromEncoded(value: Map<KEncoded, VEncoded> | Record<string, VEncoded>, format: EncodingFormat): Map<K, V> {\n    this.ensureKeyIsSupported(format)\n\n    const result = new Map<K, V>()\n\n    let entries: Array<[KEncoded, VEncoded]>\n    if (value instanceof Map) {\n      entries = Array.from(value.entries())\n    } else {\n      entries = Object.entries(value) as Array<[KEncoded, VEncoded]>\n    }\n\n    for (const [encodedKey, encodedValue] of entries) {\n      let keyToDecode = encodedKey as KEncoded\n      if (format === 'json' && this.keyType === 'bigint' && typeof encodedKey === 'string') {\n        keyToDecode = BigInt(encodedKey) as KEncoded\n      }\n      const key = this.keyCodec.decode(keyToDecode, format)\n      const val = this.valueCodec.decode(encodedValue, format)\n      result.set(key, val)\n    }\n\n    return result\n  }\n\n  public isDefaultValue(value: Map<K, V>): boolean {\n    return value.size === 0\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,WAAb,cAAgEA,oBAAqE;CACnI,AAAQ;CAER,YACE,AAAiBC,UACjB,AAAiBC,YACjB;AACA,SAAO;EAHU;EACA;EAGjB,MAAM,kBAAkB,KAAK,SAAS,cAAc;AACpD,OAAK,UAAU,2BAA2B,aAAa,eAAe,OAAO;;CAG/E,AAAO,eAA0B;AAC/B,yBAAO,IAAI,KAAK;;CAGlB,AAAQ,qBAAqB,QAAwB;AACnD,MAAI,WAAW,UACb,QAAO;AAET,MAAI,KAAK,YAAY,YAAY,KAAK,YAAY,SAChD,OAAM,IAAI,MAAM,oBAAoB,KAAK,QAAQ,wBAAwB,OAAO,SAAS;;CAI7F,AAAU,UAAU,OAAkB,QAA4E;AAChH,OAAK,qBAAqB,OAAO;EAEjC,MAAMC,UAAuC,EAAE;AAE/C,OAAK,MAAM,CAAC,GAAG,MAAM,MAAM,SAAS,EAAE;GACpC,MAAM,aAAa,KAAK,SAAS,OAAO,GAAG,OAAO;GAClD,MAAM,eAAe,KAAK,WAAW,OAAO,GAAG,OAAO;AACtD,WAAQ,KAAK,CAAC,YAAY,aAAa,CAAC;;AAE1C,MAAI,WAAW,QAAQ;GACrB,MAAMC,MAAgC,EAAE;AACxC,QAAK,MAAM,CAAC,GAAG,MAAM,SAAS;IAC5B,MAAM,SAAS,OAAO,MAAM,WAAW,IAAI,OAAO,EAAE;AACpD,QAAI,UAAU;;AAEhB,UAAO;;AAGT,SAAO,IAAI,IAAI,QAAQ;;CAGzB,AAAU,YAAY,OAA2D,QAAmC;AAClH,OAAK,qBAAqB,OAAO;EAEjC,MAAM,yBAAS,IAAI,KAAW;EAE9B,IAAID;AACJ,MAAI,iBAAiB,IACnB,WAAU,MAAM,KAAK,MAAM,SAAS,CAAC;MAErC,WAAU,OAAO,QAAQ,MAAM;AAGjC,OAAK,MAAM,CAAC,YAAY,iBAAiB,SAAS;GAChD,IAAI,cAAc;AAClB,OAAI,WAAW,UAAU,KAAK,YAAY,YAAY,OAAO,eAAe,SAC1E,eAAc,OAAO,WAAW;GAElC,MAAM,MAAM,KAAK,SAAS,OAAO,aAAa,OAAO;GACrD,MAAM,MAAM,KAAK,WAAW,OAAO,cAAc,OAAO;AACxD,UAAO,IAAI,KAAK,IAAI;;AAGtB,SAAO;;CAGT,AAAO,eAAe,OAA2B;AAC/C,SAAO,MAAM,SAAS"}

package/packages/common/src/codecs/composite/map.mjs

@@ -0,0 +1,68 @@
+import { Codec } from "../codec.mjs";
+
+//#region packages/common/src/codecs/composite/map.ts
+/**
+* Map codec - handles Maps with any key type (including Uint8Array, bigint, number)
+* Depending on the encoding format, the map is encoded differently:
+* - json: Supports string and bigint keys. The map is represented as an object when encoding.
+*   Bigint keys are converted to/from strings (e.g., 1n becomes "1").
+*   An exception is thrown upon encountering an unsupported key type.
+* - msgpack: Preserves key types and is represented as a Map when encoding.
+*/
+var MapCodec = class extends Codec {
+	keyType;
+	constructor(keyCodec, valueCodec) {
+		super();
+		this.keyCodec = keyCodec;
+		this.valueCodec = valueCodec;
+		const defaultKeyValue = this.keyCodec.defaultValue();
+		this.keyType = defaultKeyValue instanceof Uint8Array ? "Uint8Array" : typeof defaultKeyValue;
+	}
+	defaultValue() {
+		return /* @__PURE__ */ new Map();
+	}
+	ensureKeyIsSupported(format) {
+		if (format === "msgpack") return true;
+		if (this.keyType !== "string" && this.keyType !== "bigint") throw new Error(`Map key of type '${this.keyType}' is not supported in ${format} format`);
+	}
+	toEncoded(value, format) {
+		this.ensureKeyIsSupported(format);
+		const entries = [];
+		for (const [k, v] of value.entries()) {
+			const encodedKey = this.keyCodec.encode(k, format);
+			const encodedValue = this.valueCodec.encode(v, format);
+			entries.push([encodedKey, encodedValue]);
+		}
+		if (format === "json") {
+			const obj = {};
+			for (const [k, v] of entries) {
+				const keyStr = typeof k === "string" ? k : String(k);
+				obj[keyStr] = v;
+			}
+			return obj;
+		}
+		return new Map(entries);
+	}
+	fromEncoded(value, format) {
+		this.ensureKeyIsSupported(format);
+		const result = /* @__PURE__ */ new Map();
+		let entries;
+		if (value instanceof Map) entries = Array.from(value.entries());
+		else entries = Object.entries(value);
+		for (const [encodedKey, encodedValue] of entries) {
+			let keyToDecode = encodedKey;
+			if (format === "json" && this.keyType === "bigint" && typeof encodedKey === "string") keyToDecode = BigInt(encodedKey);
+			const key = this.keyCodec.decode(keyToDecode, format);
+			const val = this.valueCodec.decode(encodedValue, format);
+			result.set(key, val);
+		}
+		return result;
+	}
+	isDefaultValue(value) {
+		return value.size === 0;
+	}
+};
+
+//#endregion
+export { MapCodec };
+//# sourceMappingURL=map.mjs.map

package/packages/common/src/codecs/composite/map.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.mjs","names":["keyCodec: Codec<K, KEncoded>","valueCodec: Codec<V, VEncoded>","entries: Array<[KEncoded, VEncoded]>","obj: Record<string, VEncoded>"],"sources":["../../../../../../packages/common/src/codecs/composite/map.ts"],"sourcesContent":["import { Codec } from '../codec'\nimport type { EncodingFormat } from '../types'\n\n/**\n * Map codec - handles Maps with any key type (including Uint8Array, bigint, number)\n * Depending on the encoding format, the map is encoded differently:\n * - json: Supports string and bigint keys. The map is represented as an object when encoding.\n *   Bigint keys are converted to/from strings (e.g., 1n becomes \"1\").\n *   An exception is thrown upon encountering an unsupported key type.\n * - msgpack: Preserves key types and is represented as a Map when encoding.\n */\nexport class MapCodec<K, V, KEncoded = K, VEncoded = V> extends Codec<Map<K, V>, Map<KEncoded, VEncoded> | Record<string, VEncoded>> {\n  private keyType: string\n\n  constructor(\n    private readonly keyCodec: Codec<K, KEncoded>,\n    private readonly valueCodec: Codec<V, VEncoded>,\n  ) {\n    super()\n    const defaultKeyValue = this.keyCodec.defaultValue()\n    this.keyType = defaultKeyValue instanceof Uint8Array ? 'Uint8Array' : typeof defaultKeyValue\n  }\n\n  public defaultValue(): Map<K, V> {\n    return new Map()\n  }\n\n  private ensureKeyIsSupported(format: EncodingFormat) {\n    if (format === 'msgpack') {\n      return true\n    }\n    if (this.keyType !== 'string' && this.keyType !== 'bigint') {\n      throw new Error(`Map key of type '${this.keyType}' is not supported in ${format} format`)\n    }\n  }\n\n  protected toEncoded(value: Map<K, V>, format: EncodingFormat): Map<KEncoded, VEncoded> | Record<string, VEncoded> {\n    this.ensureKeyIsSupported(format)\n\n    const entries: Array<[KEncoded, VEncoded]> = []\n\n    for (const [k, v] of value.entries()) {\n      const encodedKey = this.keyCodec.encode(k, format)\n      const encodedValue = this.valueCodec.encode(v, format)\n      entries.push([encodedKey, encodedValue])\n    }\n    if (format === 'json') {\n      const obj: Record<string, VEncoded> = {}\n      for (const [k, v] of entries) {\n        const keyStr = typeof k === 'string' ? k : String(k)\n        obj[keyStr] = v\n      }\n      return obj\n    }\n\n    return new Map(entries)\n  }\n\n  protected fromEncoded(value: Map<KEncoded, VEncoded> | Record<string, VEncoded>, format: EncodingFormat): Map<K, V> {\n    this.ensureKeyIsSupported(format)\n\n    const result = new Map<K, V>()\n\n    let entries: Array<[KEncoded, VEncoded]>\n    if (value instanceof Map) {\n      entries = Array.from(value.entries())\n    } else {\n      entries = Object.entries(value) as Array<[KEncoded, VEncoded]>\n    }\n\n    for (const [encodedKey, encodedValue] of entries) {\n      let keyToDecode = encodedKey as KEncoded\n      if (format === 'json' && this.keyType === 'bigint' && typeof encodedKey === 'string') {\n        keyToDecode = BigInt(encodedKey) as KEncoded\n      }\n      const key = this.keyCodec.decode(keyToDecode, format)\n      const val = this.valueCodec.decode(encodedValue, format)\n      result.set(key, val)\n    }\n\n    return result\n  }\n\n  public isDefaultValue(value: Map<K, V>): boolean {\n    return value.size === 0\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,WAAb,cAAgE,MAAqE;CACnI,AAAQ;CAER,YACE,AAAiBA,UACjB,AAAiBC,YACjB;AACA,SAAO;EAHU;EACA;EAGjB,MAAM,kBAAkB,KAAK,SAAS,cAAc;AACpD,OAAK,UAAU,2BAA2B,aAAa,eAAe,OAAO;;CAG/E,AAAO,eAA0B;AAC/B,yBAAO,IAAI,KAAK;;CAGlB,AAAQ,qBAAqB,QAAwB;AACnD,MAAI,WAAW,UACb,QAAO;AAET,MAAI,KAAK,YAAY,YAAY,KAAK,YAAY,SAChD,OAAM,IAAI,MAAM,oBAAoB,KAAK,QAAQ,wBAAwB,OAAO,SAAS;;CAI7F,AAAU,UAAU,OAAkB,QAA4E;AAChH,OAAK,qBAAqB,OAAO;EAEjC,MAAMC,UAAuC,EAAE;AAE/C,OAAK,MAAM,CAAC,GAAG,MAAM,MAAM,SAAS,EAAE;GACpC,MAAM,aAAa,KAAK,SAAS,OAAO,GAAG,OAAO;GAClD,MAAM,eAAe,KAAK,WAAW,OAAO,GAAG,OAAO;AACtD,WAAQ,KAAK,CAAC,YAAY,aAAa,CAAC;;AAE1C,MAAI,WAAW,QAAQ;GACrB,MAAMC,MAAgC,EAAE;AACxC,QAAK,MAAM,CAAC,GAAG,MAAM,SAAS;IAC5B,MAAM,SAAS,OAAO,MAAM,WAAW,IAAI,OAAO,EAAE;AACpD,QAAI,UAAU;;AAEhB,UAAO;;AAGT,SAAO,IAAI,IAAI,QAAQ;;CAGzB,AAAU,YAAY,OAA2D,QAAmC;AAClH,OAAK,qBAAqB,OAAO;EAEjC,MAAM,yBAAS,IAAI,KAAW;EAE9B,IAAID;AACJ,MAAI,iBAAiB,IACnB,WAAU,MAAM,KAAK,MAAM,SAAS,CAAC;MAErC,WAAU,OAAO,QAAQ,MAAM;AAGjC,OAAK,MAAM,CAAC,YAAY,iBAAiB,SAAS;GAChD,IAAI,cAAc;AAClB,OAAI,WAAW,UAAU,KAAK,YAAY,YAAY,OAAO,eAAe,SAC1E,eAAc,OAAO,WAAW;GAElC,MAAM,MAAM,KAAK,SAAS,OAAO,aAAa,OAAO;GACrD,MAAM,MAAM,KAAK,WAAW,OAAO,cAAc,OAAO;AACxD,UAAO,IAAI,KAAK,IAAI;;AAGtB,SAAO;;CAGT,AAAO,eAAe,OAA2B;AAC/C,SAAO,MAAM,SAAS"}

package/packages/common/src/codecs/composite/record.js

@@ -0,0 +1,40 @@
+const require_rolldown_runtime = require('../../../../../_virtual/rolldown_runtime.js');
+const require_codec = require('../codec.js');
+let buffer = require("buffer");
+
+//#region packages/common/src/codecs/composite/record.ts
+/**
+* Record codec - for string-keyed objects with homogeneous values
+*/
+var RecordCodec = class extends require_codec.Codec {
+	constructor(valueCodec) {
+		super();
+		this.valueCodec = valueCodec;
+	}
+	defaultValue() {
+		return {};
+	}
+	toEncoded(value, format) {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) result[key] = this.valueCodec.encode(val, format);
+		return result;
+	}
+	fromEncoded(value, format) {
+		const result = {};
+		if (value instanceof Map) for (const [_key, val] of value.entries()) {
+			const keyType = typeof _key;
+			if (keyType === "number" || keyType === "bigint") throw new Error(`RecordCodec received a non-string key of type ${keyType}`);
+			const key = _key instanceof Uint8Array ? buffer.Buffer.from(_key).toString("utf-8") : String(_key);
+			result[key] = this.valueCodec.decode(val, format);
+		}
+		else for (const [key, val] of Object.entries(value)) result[key] = this.valueCodec.decode(val, format);
+		return result;
+	}
+	isDefaultValue(value) {
+		return Object.keys(value).length === 0;
+	}
+};
+
+//#endregion
+exports.RecordCodec = RecordCodec;
+//# sourceMappingURL=record.js.map

package/packages/common/src/codecs/composite/record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.js","names":["Codec","valueCodec: Codec<V, VEncoded>","result: Record<string, VEncoded>","result: Record<string, V>","Buffer"],"sources":["../../../../../../packages/common/src/codecs/composite/record.ts"],"sourcesContent":["import { Buffer } from 'buffer'\nimport { Codec } from '../codec'\nimport type { EncodingFormat } from '../types'\nimport { WireObject } from '../wire'\n\n/**\n * Record codec - for string-keyed objects with homogeneous values\n */\nexport class RecordCodec<V, VEncoded = V> extends Codec<Record<string, V>, Record<string, VEncoded>, WireObject<VEncoded>> {\n  constructor(private readonly valueCodec: Codec<V, VEncoded>) {\n    super()\n  }\n\n  public defaultValue(): Record<string, V> {\n    return {}\n  }\n\n  protected toEncoded(value: Record<string, V>, format: EncodingFormat): Record<string, VEncoded> {\n    const result: Record<string, VEncoded> = {}\n\n    for (const [key, val] of Object.entries(value)) {\n      const encoded = this.valueCodec.encode(val, format)\n      result[key] = encoded\n    }\n\n    return result\n  }\n\n  protected fromEncoded(value: WireObject<VEncoded>, format: EncodingFormat): Record<string, V> {\n    const result: Record<string, V> = {}\n    if (value instanceof Map) {\n      for (const [_key, val] of value.entries()) {\n        const keyType = typeof _key\n        if (keyType === 'number' || keyType === 'bigint') {\n          throw new Error(`RecordCodec received a non-string key of type ${keyType}`)\n        }\n        const key = _key instanceof Uint8Array ? Buffer.from(_key).toString('utf-8') : String(_key)\n        result[key] = this.valueCodec.decode(val, format)\n      }\n    } else {\n      for (const [key, val] of Object.entries(value)) {\n        result[key] = this.valueCodec.decode(val, format)\n      }\n    }\n\n    return result\n  }\n\n  public isDefaultValue(value: Record<string, V>): boolean {\n    return Object.keys(value).length === 0\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAa,cAAb,cAAkDA,oBAAyE;CACzH,YAAY,AAAiBC,YAAgC;AAC3D,SAAO;EADoB;;CAI7B,AAAO,eAAkC;AACvC,SAAO,EAAE;;CAGX,AAAU,UAAU,OAA0B,QAAkD;EAC9F,MAAMC,SAAmC,EAAE;AAE3C,OAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,MAAM,CAE5C,QAAO,OADS,KAAK,WAAW,OAAO,KAAK,OAAO;AAIrD,SAAO;;CAGT,AAAU,YAAY,OAA6B,QAA2C;EAC5F,MAAMC,SAA4B,EAAE;AACpC,MAAI,iBAAiB,IACnB,MAAK,MAAM,CAAC,MAAM,QAAQ,MAAM,SAAS,EAAE;GACzC,MAAM,UAAU,OAAO;AACvB,OAAI,YAAY,YAAY,YAAY,SACtC,OAAM,IAAI,MAAM,iDAAiD,UAAU;GAE7E,MAAM,MAAM,gBAAgB,aAAaC,cAAO,KAAK,KAAK,CAAC,SAAS,QAAQ,GAAG,OAAO,KAAK;AAC3F,UAAO,OAAO,KAAK,WAAW,OAAO,KAAK,OAAO;;MAGnD,MAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,MAAM,CAC5C,QAAO,OAAO,KAAK,WAAW,OAAO,KAAK,OAAO;AAIrD,SAAO;;CAGT,AAAO,eAAe,OAAmC;AACvD,SAAO,OAAO,KAAK,MAAM,CAAC,WAAW"}

package/packages/common/src/codecs/composite/record.mjs

@@ -0,0 +1,39 @@
+import { Codec } from "../codec.mjs";
+import { Buffer } from "buffer";
+
+//#region packages/common/src/codecs/composite/record.ts
+/**
+* Record codec - for string-keyed objects with homogeneous values
+*/
+var RecordCodec = class extends Codec {
+	constructor(valueCodec) {
+		super();
+		this.valueCodec = valueCodec;
+	}
+	defaultValue() {
+		return {};
+	}
+	toEncoded(value, format) {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) result[key] = this.valueCodec.encode(val, format);
+		return result;
+	}
+	fromEncoded(value, format) {
+		const result = {};
+		if (value instanceof Map) for (const [_key, val] of value.entries()) {
+			const keyType = typeof _key;
+			if (keyType === "number" || keyType === "bigint") throw new Error(`RecordCodec received a non-string key of type ${keyType}`);
+			const key = _key instanceof Uint8Array ? Buffer.from(_key).toString("utf-8") : String(_key);
+			result[key] = this.valueCodec.decode(val, format);
+		}
+		else for (const [key, val] of Object.entries(value)) result[key] = this.valueCodec.decode(val, format);
+		return result;
+	}
+	isDefaultValue(value) {
+		return Object.keys(value).length === 0;
+	}
+};
+
+//#endregion
+export { RecordCodec };
+//# sourceMappingURL=record.mjs.map

package/packages/common/src/codecs/composite/record.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.mjs","names":["valueCodec: Codec<V, VEncoded>","result: Record<string, VEncoded>","result: Record<string, V>"],"sources":["../../../../../../packages/common/src/codecs/composite/record.ts"],"sourcesContent":["import { Buffer } from 'buffer'\nimport { Codec } from '../codec'\nimport type { EncodingFormat } from '../types'\nimport { WireObject } from '../wire'\n\n/**\n * Record codec - for string-keyed objects with homogeneous values\n */\nexport class RecordCodec<V, VEncoded = V> extends Codec<Record<string, V>, Record<string, VEncoded>, WireObject<VEncoded>> {\n  constructor(private readonly valueCodec: Codec<V, VEncoded>) {\n    super()\n  }\n\n  public defaultValue(): Record<string, V> {\n    return {}\n  }\n\n  protected toEncoded(value: Record<string, V>, format: EncodingFormat): Record<string, VEncoded> {\n    const result: Record<string, VEncoded> = {}\n\n    for (const [key, val] of Object.entries(value)) {\n      const encoded = this.valueCodec.encode(val, format)\n      result[key] = encoded\n    }\n\n    return result\n  }\n\n  protected fromEncoded(value: WireObject<VEncoded>, format: EncodingFormat): Record<string, V> {\n    const result: Record<string, V> = {}\n    if (value instanceof Map) {\n      for (const [_key, val] of value.entries()) {\n        const keyType = typeof _key\n        if (keyType === 'number' || keyType === 'bigint') {\n          throw new Error(`RecordCodec received a non-string key of type ${keyType}`)\n        }\n        const key = _key instanceof Uint8Array ? Buffer.from(_key).toString('utf-8') : String(_key)\n        result[key] = this.valueCodec.decode(val, format)\n      }\n    } else {\n      for (const [key, val] of Object.entries(value)) {\n        result[key] = this.valueCodec.decode(val, format)\n      }\n    }\n\n    return result\n  }\n\n  public isDefaultValue(value: Record<string, V>): boolean {\n    return Object.keys(value).length === 0\n  }\n}\n"],"mappings":";;;;;;;AAQA,IAAa,cAAb,cAAkD,MAAyE;CACzH,YAAY,AAAiBA,YAAgC;AAC3D,SAAO;EADoB;;CAI7B,AAAO,eAAkC;AACvC,SAAO,EAAE;;CAGX,AAAU,UAAU,OAA0B,QAAkD;EAC9F,MAAMC,SAAmC,EAAE;AAE3C,OAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,MAAM,CAE5C,QAAO,OADS,KAAK,WAAW,OAAO,KAAK,OAAO;AAIrD,SAAO;;CAGT,AAAU,YAAY,OAA6B,QAA2C;EAC5F,MAAMC,SAA4B,EAAE;AACpC,MAAI,iBAAiB,IACnB,MAAK,MAAM,CAAC,MAAM,QAAQ,MAAM,SAAS,EAAE;GACzC,MAAM,UAAU,OAAO;AACvB,OAAI,YAAY,YAAY,YAAY,SACtC,OAAM,IAAI,MAAM,iDAAiD,UAAU;GAE7E,MAAM,MAAM,gBAAgB,aAAa,OAAO,KAAK,KAAK,CAAC,SAAS,QAAQ,GAAG,OAAO,KAAK;AAC3F,UAAO,OAAO,KAAK,WAAW,OAAO,KAAK,OAAO;;MAGnD,MAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,MAAM,CAC5C,QAAO,OAAO,KAAK,WAAW,OAAO,KAAK,OAAO;AAIrD,SAAO;;CAGT,AAAO,eAAe,OAAmC;AACvD,SAAO,OAAO,KAAK,MAAM,CAAC,WAAW"}