@latticexyz/common 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2 → 2.2.18-c2ad22c7feb566e1731ff16e8be291746bdffb3e

package/dist/codegen.cjs

@@ -1,889 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/codegen/index.ts
-var codegen_exports = {};
-__export(codegen_exports, {
-  abiToInterface: () => abiToInterface,
-  contractToInterface: () => contractToInterface,
-  findContractNode: () => findContractNode,
-  formatAndWriteSolidity: () => formatAndWriteSolidity,
-  formatAndWriteTypescript: () => formatAndWriteTypescript,
-  formatSolidity: () => formatSolidity,
-  formatTypescript: () => formatTypescript,
-  getLeftPaddingBits: () => getLeftPaddingBits,
-  isLeftAligned: () => isLeftAligned,
-  renderArguments: () => renderArguments,
-  renderCommonData: () => renderCommonData,
-  renderEnums: () => renderEnums,
-  renderImportPath: () => renderImportPath,
-  renderImports: () => renderImports,
-  renderList: () => renderList,
-  renderTableId: () => renderTableId,
-  renderTypeHelpers: () => renderTypeHelpers,
-  renderValueTypeToBytes32: () => renderValueTypeToBytes32,
-  renderWithFieldSuffix: () => renderWithFieldSuffix,
-  renderWithStore: () => renderWithStore,
-  renderedSolidityHeader: () => renderedSolidityHeader,
-  schemaTypesToRecsTypeStrings: () => schemaTypesToRecsTypeStrings
-});
-module.exports = __toCommonJS(codegen_exports);
-
-// src/codegen/render-solidity/abiToInterface.ts
-var import_abitype = require("abitype");
-
-// src/resourceToHex.ts
-var import_viem = require("viem");
-var resourceTypeIds = {
-  // keep these in sync with storeResourceTypes.sol
-  table: "tb",
-  offchainTable: "ot",
-  // keep these in sync with worldResourceTypes.sol
-  namespace: "ns",
-  system: "sy"
-};
-function resourceToHex(resource) {
-  const typeId = resourceTypeIds[resource.type];
-  if (resource.namespace.length > 14) {
-    throw new Error(`Namespaces must fit into \`bytes14\`, but "${resource.namespace}" is too long.`);
-  }
-  return (0, import_viem.concatHex)([
-    (0, import_viem.stringToHex)(typeId, { size: 2 }),
-    (0, import_viem.stringToHex)(resource.namespace, { size: 14 }),
-    (0, import_viem.stringToHex)(resource.name.slice(0, 16), { size: 16 })
-  ]);
-}
-
-// src/hexToResource.ts
-var import_viem2 = require("viem");
-
-// src/resourceTypes.ts
-var resourceTypes = ["table", "offchainTable", "namespace", "system"];
-
-// src/resourceToLabel.ts
-var rootNamespace = "";
-function resourceToLabel({
-  namespace,
-  name
-}) {
-  return namespace === rootNamespace ? name : `${namespace}__${name}`;
-}
-
-// src/hexToResource.ts
-var resourceTypeIdToType = Object.fromEntries(
-  Object.entries(resourceTypeIds).map(([key, value]) => [value, key])
-);
-function getResourceType(resourceTypeId) {
-  const type = resourceTypeIdToType[resourceTypeId];
-  if (resourceTypes.includes(type)) {
-    return type;
-  }
-}
-function hexToResource(hex) {
-  const resourceTypeId = (0, import_viem2.hexToString)((0, import_viem2.sliceHex)(hex, 0, 2)).replace(/\0+$/, "");
-  const type = getResourceType(resourceTypeId);
-  const namespace = (0, import_viem2.hexToString)((0, import_viem2.sliceHex)(hex, 2, 16)).replace(/\0+$/, "");
-  const name = (0, import_viem2.hexToString)((0, import_viem2.sliceHex)(hex, 16, 32)).replace(/\0+$/, "");
-  if (!type) {
-    throw new Error(`Unknown type (${resourceTypeId}) for resource (${resourceToLabel({ namespace, name })})`);
-  }
-  return { resourceId: hex, type, namespace, name };
-}
-
-// src/codegen/render-solidity/renderImportPath.ts
-var import_node_path = __toESM(require("path"), 1);
-function winToPosix(segment) {
-  return segment.replaceAll(import_node_path.default.win32.sep, import_node_path.default.posix.sep);
-}
-function renderImportPath(basePath, ...segments) {
-  const fullPath = import_node_path.default.posix.join(winToPosix(basePath), ...segments.map(winToPosix)).replace(/\/$/, "");
-  if (basePath.startsWith(".")) {
-    const relativePath = "./" + fullPath;
-    return relativePath.replace(/^(\.\/)+\./, ".");
-  }
-  return fullPath;
-}
-
-// src/codegen/render-solidity/common.ts
-var renderedSolidityHeader = `// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
-
-/* Autogenerated file. Do not edit manually. */`;
-function renderList(list, renderItem) {
-  return internalRenderList("", list, renderItem);
-}
-function renderArguments(args) {
-  const filteredArgs = args.filter((arg) => arg !== void 0 && arg !== "");
-  return internalRenderList(",", filteredArgs, (arg) => arg);
-}
-function renderCommonData({
-  staticResourceData,
-  keyTuple
-}) {
-  const _typedTableId = staticResourceData ? "" : "ResourceId _tableId";
-  const _typedKeyArgs = renderArguments(keyTuple.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  const _keyTupleDefinition = `
-    bytes32[] memory _keyTuple = new bytes32[](${keyTuple.length});
-    ${renderList(keyTuple, (key, index) => `_keyTuple[${index}] = ${renderValueTypeToBytes32(key.name, key)};`)}
-  `;
-  return {
-    _typedTableId,
-    _typedKeyArgs,
-    _keyTupleDefinition
-  };
-}
-function renderImports(imports) {
-  const aggregatedImports = /* @__PURE__ */ new Map();
-  for (const { symbol, path: path3 } of imports) {
-    if (!aggregatedImports.has(path3)) {
-      aggregatedImports.set(path3, /* @__PURE__ */ new Set());
-    }
-    aggregatedImports.get(path3)?.add(symbol);
-  }
-  const renderedImports = [];
-  for (const [path3, symbols] of aggregatedImports) {
-    const renderedSymbols = [...symbols].join(", ");
-    renderedImports.push(`import { ${renderedSymbols} } from "${renderImportPath(path3)}";`);
-  }
-  return renderedImports.join("\n");
-}
-function renderWithStore(storeArgument, callback) {
-  let result = "";
-  result += callback({ _typedStore: void 0, _store: "StoreSwitch", _commentSuffix: "", _methodNamePrefix: "" });
-  result += callback({
-    _typedStore: void 0,
-    _store: "StoreCore",
-    _commentSuffix: "",
-    _methodNamePrefix: "_",
-    _useExplicitFieldLayout: true
-  });
-  if (storeArgument) {
-    result += "\n" + callback({
-      _typedStore: "IStore _store",
-      _store: "_store",
-      _commentSuffix: " (using the specified store)",
-      _methodNamePrefix: ""
-    });
-  }
-  return result;
-}
-function renderWithFieldSuffix(withSuffixlessFieldMethods, fieldName, callback) {
-  const methodNameSuffix = `${fieldName[0].toUpperCase()}${fieldName.slice(1)}`;
-  let result = "";
-  result += callback(methodNameSuffix);
-  if (withSuffixlessFieldMethods) {
-    result += "\n" + callback("");
-  }
-  return result;
-}
-function renderTableId({
-  namespace,
-  name,
-  offchainOnly
-}) {
-  const tableId = resourceToHex({
-    type: offchainOnly ? "offchainTable" : "table",
-    namespace,
-    name
-  });
-  const resource = hexToResource(tableId);
-  return `
-    // Hex below is the result of \`WorldResourceIdLib.encode({ namespace: ${JSON.stringify(
-    resource.namespace
-  )}, name: ${JSON.stringify(resource.name)}, typeId: ${offchainOnly ? "RESOURCE_OFFCHAIN_TABLE" : "RESOURCE_TABLE"} });\`
-    ResourceId constant _tableId = ResourceId.wrap(${tableId});
-  `;
-}
-function renderValueTypeToBytes32(name, { typeUnwrap, internalTypeId }) {
-  const innerText = typeUnwrap.length ? `${typeUnwrap}(${name})` : name;
-  if (internalTypeId === "bytes32") {
-    return innerText;
-  } else if (/^bytes\d{1,2}$/.test(internalTypeId)) {
-    return `bytes32(${innerText})`;
-  } else if (/^uint\d{1,3}$/.test(internalTypeId)) {
-    return `bytes32(uint256(${innerText}))`;
-  } else if (/^int\d{1,3}$/.test(internalTypeId)) {
-    return `bytes32(uint256(int256(${innerText})))`;
-  } else if (internalTypeId === "address") {
-    return `bytes32(uint256(uint160(${innerText})))`;
-  } else if (internalTypeId === "bool") {
-    return `_boolToBytes32(${innerText})`;
-  } else {
-    throw new Error(`Unknown value type id ${internalTypeId}`);
-  }
-}
-function isLeftAligned(field) {
-  return /^bytes\d{1,2}$/.test(field.internalTypeId);
-}
-function getLeftPaddingBits(field) {
-  if (isLeftAligned(field)) {
-    return 0;
-  } else {
-    return 256 - field.staticByteLength * 8;
-  }
-}
-function internalRenderList(lineTerminator, list, renderItem) {
-  return list.map((item, index) => renderItem(item, index) + (index === list.length - 1 ? "" : lineTerminator)).join("\n");
-}
-
-// src/codegen/render-solidity/abiToInterface.ts
-function formatParam(param) {
-  return (0, import_abitype.formatAbiParameter)(param);
-}
-function formatFunction(item) {
-  const params = item.inputs.map(formatParam).join(", ");
-  const returns = item.outputs.map(formatParam).join(", ");
-  return `function ${item.name}(${params}) external${returns.length ? ` returns (${returns})` : ""}`;
-}
-function formatSystemId(systemId) {
-  const resource = hexToResource(systemId);
-  return `
-    // equivalent to \`WorldResourceIdLib.encode({ namespace: ${JSON.stringify(
-    resource.namespace
-  )}, name: ${JSON.stringify(resource.name)}, typeId: RESOURCE_SYSTEM });\`
-    ResourceId constant systemId = ResourceId.wrap(${systemId});
-  `;
-}
-function abiToInterface({ name, systemId, abi }) {
-  const imports = systemId ? [`{ ResourceId } from "@latticexyz/store/src/ResourceId.sol"`] : [];
-  const errors = abi.filter((item) => item.type === "error");
-  const functions = abi.filter((item) => item.type === "function");
-  return `
-    ${renderedSolidityHeader}
-
-    ${imports.map((item) => `import ${item};`).join("\n")}
-
-    ${systemId ? formatSystemId(systemId) : ""}
-
-    interface ${name} {
-      ${errors.map((item) => `${(0, import_abitype.formatAbiItem)(item)};`).join("\n")}
-
-      ${functions.map((item) => {
-    if ([...item.inputs, ...item.outputs].some((param) => param.type.startsWith("tuple"))) {
-      return `// TODO: replace tuple with struct
-// ${formatFunction(item)};`;
-    }
-    return `${formatFunction(item)};`;
-  }).join("\n")}
-    }
-  `;
-}
-
-// src/codegen/render-solidity/renderEnums.ts
-function renderEnums(enums) {
-  const enumDefinitions = Object.entries(enums).map(
-    ([name, values]) => `
-      enum ${name} {
-        ${values.join(", ")}
-      }
-    `
-  );
-  return `
-    ${renderedSolidityHeader}
-    ${enumDefinitions.join("")}
-  `;
-}
-
-// src/codegen/render-solidity/renderTypeHelpers.ts
-function renderTypeHelpers(options) {
-  const { fields, keyTuple } = options;
-  let result = "";
-  for (const wrappingHelper of getWrappingHelpers([...fields, ...keyTuple])) {
-    result += wrappingHelper;
-  }
-  if (fields.some(({ internalTypeId }) => internalTypeId.match("bool"))) {
-    result += `
-    /**
-     * @notice Cast a value to a bool.
-     * @dev Boolean values are encoded as uint8 (1 = true, 0 = false), but Solidity doesn't allow casting between uint8 and bool.
-     * @param value The uint8 value to convert.
-     * @return result The boolean value.
-     */
-    function _toBool(uint8 value) pure returns (bool result) {
-      assembly {
-        result := value
-      }
-    }
-    `;
-  }
-  if (keyTuple.some(({ internalTypeId }) => internalTypeId.match("bool"))) {
-    result += `
-    /**
-     * @notice Cast a bool to a bytes32.
-     * @dev The boolean value is casted to a bytes32 value with 0 or 1 at the least significant bit.
-     */
-    function _boolToBytes32(bool value) pure returns (bytes32 result) {
-      assembly {
-        result := value
-      }
-    }
-    `;
-  }
-  return result;
-}
-function getWrappingHelpers(array) {
-  const wrappers = /* @__PURE__ */ new Map();
-  const unwrappers = /* @__PURE__ */ new Map();
-  for (const { typeWrappingData, typeWrap, typeUnwrap, internalTypeId } of array) {
-    if (!typeWrappingData) continue;
-    const { kind } = typeWrappingData;
-    if (kind === "staticArray") {
-      const { elementType, staticLength } = typeWrappingData;
-      wrappers.set(typeWrap, renderWrapperStaticArray(typeWrap, elementType, staticLength, internalTypeId));
-      unwrappers.set(typeUnwrap, renderUnwrapperStaticArray(typeUnwrap, elementType, staticLength, internalTypeId));
-    }
-  }
-  return [...wrappers.values(), ...unwrappers.values()];
-}
-function renderWrapperStaticArray(functionName, elementType, staticLength, internalTypeId) {
-  return `
-    /**
-     * @notice Cast a dynamic array to a static array.
-     * @dev In memory static arrays are just dynamic arrays without the 32 length bytes,
-     * so this function moves the pointer to the first element of the dynamic array.
-     * If the length of the dynamic array is smaller than the static length,
-     * the function returns an uninitialized array to avoid memory corruption.
-     * @param _value The dynamic array to cast.
-     * @return _result The static array.
-     */
-    function ${functionName}(
-      ${internalTypeId} memory _value
-    ) pure returns (
-      ${elementType}[${staticLength}] memory _result
-    ) {
-      if (_value.length < ${staticLength}) {
-        // return an uninitialized array if the length is smaller than the fixed length to avoid memory corruption
-        return _result;
-      } else {
-        // in memory static arrays are just dynamic arrays without the 32 length bytes
-        // (without the length check this could lead to memory corruption)
-        assembly {
-          _result := add(_value, 0x20)
-        }
-      }
-    }
-  `;
-}
-function renderUnwrapperStaticArray(functionName, elementType, staticLength, internalTypeId) {
-  const byteLength = staticLength * 32;
-  return `
-    /**
-     * @notice Copy a static array to a dynamic array.
-     * @dev Static arrays don't have a length prefix, so this function copies the memory from the static array to a new dynamic array.
-     * @param _value The static array to copy.
-     * @return _result The dynamic array.
-     */ 
-    function ${functionName}(
-      ${elementType}[${staticLength}] memory _value
-    ) pure returns (
-      ${internalTypeId} memory _result
-    ) {
-      _result = new ${internalTypeId}(${staticLength});
-      uint256 fromPointer;
-      uint256 toPointer;
-      assembly {
-        fromPointer := _value
-        toPointer := add(_result, 0x20)
-      }
-      Memory.copy(fromPointer, toPointer, ${byteLength});
-    }
-  `;
-}
-
-// src/codegen/render-typescript/schemaTypesToRecsTypeStrings.ts
-var import_deprecated = require("@latticexyz/schema-type/deprecated");
-var schemaTypesToRecsTypeStrings = {
-  [import_deprecated.SchemaType.UINT8]: "RecsType.Number",
-  [import_deprecated.SchemaType.UINT16]: "RecsType.Number",
-  [import_deprecated.SchemaType.UINT24]: "RecsType.Number",
-  [import_deprecated.SchemaType.UINT32]: "RecsType.Number",
-  [import_deprecated.SchemaType.UINT40]: "RecsType.Number",
-  [import_deprecated.SchemaType.UINT48]: "RecsType.Number",
-  [import_deprecated.SchemaType.UINT56]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT64]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT72]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT80]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT88]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT96]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT104]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT112]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT120]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT128]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT136]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT144]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT152]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT160]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT168]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT176]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT184]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT192]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT200]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT208]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT216]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT224]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT232]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT240]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT248]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.UINT256]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT8]: "RecsType.Number",
-  [import_deprecated.SchemaType.INT16]: "RecsType.Number",
-  [import_deprecated.SchemaType.INT24]: "RecsType.Number",
-  [import_deprecated.SchemaType.INT32]: "RecsType.Number",
-  [import_deprecated.SchemaType.INT40]: "RecsType.Number",
-  [import_deprecated.SchemaType.INT48]: "RecsType.Number",
-  [import_deprecated.SchemaType.INT56]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT64]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT72]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT80]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT88]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT96]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT104]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT112]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT120]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT128]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT136]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT144]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT152]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT160]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT168]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT176]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT184]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT192]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT200]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT208]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT216]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT224]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT232]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT240]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT248]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.INT256]: "RecsType.BigInt",
-  [import_deprecated.SchemaType.BYTES1]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES2]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES3]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES4]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES5]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES6]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES7]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES8]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES9]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES10]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES11]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES12]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES13]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES14]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES15]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES16]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES17]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES18]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES19]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES20]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES21]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES22]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES23]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES24]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES25]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES26]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES27]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES28]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES29]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES30]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES31]: "RecsType.String",
-  [import_deprecated.SchemaType.BYTES32]: "RecsType.String",
-  [import_deprecated.SchemaType.BOOL]: "RecsType.Boolean",
-  [import_deprecated.SchemaType.ADDRESS]: "RecsType.String",
-  [import_deprecated.SchemaType.UINT8_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.UINT16_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.UINT24_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.UINT32_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.UINT40_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.UINT48_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.UINT56_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT64_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT72_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT80_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT88_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT96_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT104_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT112_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT120_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT128_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT136_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT144_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT152_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT160_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT168_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT176_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT184_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT192_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT200_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT208_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT216_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT224_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT232_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT240_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT248_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.UINT256_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT8_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.INT16_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.INT24_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.INT32_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.INT40_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.INT48_ARRAY]: "RecsType.NumberArray",
-  [import_deprecated.SchemaType.INT56_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT64_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT72_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT80_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT88_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT96_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT104_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT112_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT120_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT128_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT136_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT144_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT152_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT160_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT168_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT176_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT184_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT192_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT200_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT208_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT216_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT224_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT232_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT240_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT248_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.INT256_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES1_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES2_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES3_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES4_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES5_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES6_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES7_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES8_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES9_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES10_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES11_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES12_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES13_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES14_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES15_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES16_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES17_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES18_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES19_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES20_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES21_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES22_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES23_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES24_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES25_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES26_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES27_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES28_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES29_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES30_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES31_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BYTES32_ARRAY]: "RecsType.BigIntArray",
-  [import_deprecated.SchemaType.BOOL_ARRAY]: "RecsType.T",
-  // no boolean array
-  [import_deprecated.SchemaType.ADDRESS_ARRAY]: "RecsType.StringArray",
-  [import_deprecated.SchemaType.BYTES]: "RecsType.String",
-  [import_deprecated.SchemaType.STRING]: "RecsType.String"
-};
-
-// src/codegen/utils/contractToInterface.ts
-var import_parser = require("@solidity-parser/parser");
-
-// src/errors/MUDError.ts
-var MUDError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "MUDError";
-  }
-};
-
-// src/codegen/utils/contractToInterface.ts
-function contractToInterface(source, contractName) {
-  const ast = (0, import_parser.parse)(source);
-  const contractNode = findContractNode(ast, contractName);
-  let symbolImports = [];
-  const functions = [];
-  const errors = [];
-  if (!contractNode) {
-    throw new MUDError(`Contract not found: ${contractName}`);
-  }
-  (0, import_parser.visit)(contractNode, {
-    FunctionDefinition({
-      name,
-      visibility,
-      parameters,
-      stateMutability,
-      returnParameters,
-      isConstructor,
-      isFallback,
-      isReceiveEther
-    }) {
-      try {
-        if (isConstructor || isFallback || isReceiveEther) return;
-        if (visibility === "default") throw new MUDError(`Visibility is not specified`);
-        if (visibility === "external" || visibility === "public") {
-          functions.push({
-            name: name === null ? "" : name,
-            parameters: parameters.map(parseParameter),
-            stateMutability: stateMutability || "",
-            returnParameters: returnParameters === null ? [] : returnParameters.map(parseParameter)
-          });
-          for (const { typeName } of parameters.concat(returnParameters ?? [])) {
-            const symbols = typeNameToSymbols(typeName);
-            symbolImports = symbolImports.concat(symbolsToImports(ast, symbols));
-          }
-        }
-      } catch (error3) {
-        if (error3 instanceof MUDError) {
-          error3.message = `Function "${name}" in contract "${contractName}": ${error3.message}`;
-        }
-        throw error3;
-      }
-    },
-    CustomErrorDefinition({ name, parameters }) {
-      errors.push({
-        name,
-        parameters: parameters.map(parseParameter)
-      });
-      for (const parameter of parameters) {
-        const symbols = typeNameToSymbols(parameter.typeName);
-        symbolImports = symbolImports.concat(symbolsToImports(ast, symbols));
-      }
-    }
-  });
-  return {
-    functions,
-    errors,
-    symbolImports
-  };
-}
-function findContractNode(ast, contractName) {
-  let contract = void 0;
-  (0, import_parser.visit)(ast, {
-    ContractDefinition(node) {
-      if (node.name === contractName) {
-        contract = node;
-      }
-    }
-  });
-  return contract;
-}
-function parseParameter({ name, typeName, storageLocation }) {
-  let typedNameWithLocation = "";
-  const { name: flattenedTypeName, stateMutability } = flattenTypeName(typeName);
-  typedNameWithLocation += flattenedTypeName;
-  if (stateMutability !== null) {
-    typedNameWithLocation += ` ${stateMutability}`;
-  }
-  if (storageLocation !== null) {
-    typedNameWithLocation += ` ${storageLocation}`;
-  }
-  if (name !== null) {
-    typedNameWithLocation += ` ${name}`;
-  }
-  return typedNameWithLocation;
-}
-function flattenTypeName(typeName) {
-  if (typeName === null) {
-    return {
-      name: "",
-      stateMutability: null
-    };
-  }
-  if (typeName.type === "ElementaryTypeName") {
-    return {
-      name: typeName.name,
-      stateMutability: typeName.stateMutability
-    };
-  } else if (typeName.type === "UserDefinedTypeName") {
-    return {
-      name: typeName.namePath,
-      stateMutability: null
-    };
-  } else if (typeName.type === "ArrayTypeName") {
-    let length = "";
-    if (typeName.length?.type === "NumberLiteral") {
-      length = typeName.length.number;
-    } else if (typeName.length?.type === "Identifier") {
-      length = typeName.length.name;
-    }
-    const { name, stateMutability } = flattenTypeName(typeName.baseTypeName);
-    return {
-      name: `${name}[${length}]`,
-      stateMutability
-    };
-  } else {
-    throw new MUDError(`Invalid typeName.type ${typeName.type}`);
-  }
-}
-function typeNameToSymbols(typeName) {
-  if (typeName?.type === "UserDefinedTypeName") {
-    const symbol = typeName.namePath.split(".")[0];
-    return [symbol];
-  } else if (typeName?.type === "ArrayTypeName") {
-    const symbols = typeNameToSymbols(typeName.baseTypeName);
-    if (typeName.length?.type === "Identifier") {
-      const innerTypeName = typeName.length.name;
-      symbols.push(innerTypeName.split(".")[0]);
-    }
-    return symbols;
-  } else {
-    return [];
-  }
-}
-function symbolsToImports(ast, symbols) {
-  const imports = [];
-  for (const symbol of symbols) {
-    let symbolImport;
-    (0, import_parser.visit)(ast, {
-      ImportDirective({ path: path3, symbolAliases }) {
-        if (symbolAliases) {
-          for (const symbolAndAlias of symbolAliases) {
-            const symbolAlias = symbolAndAlias[1] || symbolAndAlias[0];
-            if (symbol === symbolAlias) {
-              symbolImport = {
-                // always use the original symbol for interface imports
-                symbol: symbolAndAlias[0],
-                path: path3
-              };
-              return;
-            }
-          }
-        }
-      }
-    });
-    if (symbolImport) {
-      imports.push(symbolImport);
-    } else {
-      throw new MUDError(`Symbol "${symbol}" has no explicit import`);
-    }
-  }
-  return imports;
-}
-
-// src/codegen/utils/format.ts
-var import_prettier = __toESM(require("prettier"), 1);
-var import_prettier_plugin_solidity = __toESM(require("prettier-plugin-solidity"), 1);
-async function formatSolidity(content, prettierConfigPath) {
-  let config;
-  if (prettierConfigPath) {
-    config = await import_prettier.default.resolveConfig(prettierConfigPath);
-  }
-  try {
-    return import_prettier.default.format(content, {
-      plugins: [import_prettier_plugin_solidity.default],
-      parser: "solidity-parse",
-      printWidth: 120,
-      semi: true,
-      tabWidth: 2,
-      useTabs: false,
-      bracketSpacing: true,
-      ...config
-    });
-  } catch (error3) {
-    let message;
-    if (error3 instanceof Error) {
-      message = error3.message;
-    } else {
-      message = error3;
-    }
-    console.log(`Error during output formatting: ${message}`);
-    return content;
-  }
-}
-async function formatTypescript(content) {
-  return import_prettier.default.format(content, {
-    parser: "typescript"
-  });
-}
-
-// src/codegen/utils/formatAndWrite.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-
-// src/debug.ts
-var import_debug = __toESM(require("debug"), 1);
-var debug = (0, import_debug.default)("mud:common");
-var error = (0, import_debug.default)("mud:common");
-debug.log = console.debug.bind(console);
-error.log = console.error.bind(console);
-
-// src/codegen/debug.ts
-var debug2 = debug.extend("codegen");
-var error2 = debug.extend("codegen");
-debug2.log = console.debug.bind(console);
-error2.log = console.error.bind(console);
-
-// src/codegen/utils/formatAndWrite.ts
-async function formatAndWriteSolidity(output, fullOutputPath, logPrefix) {
-  const formattedOutput = await formatSolidity(output);
-  await import_promises.default.mkdir(import_node_path2.default.dirname(fullOutputPath), { recursive: true });
-  await import_promises.default.writeFile(fullOutputPath, formattedOutput);
-  debug2(`${logPrefix}: ${fullOutputPath}`);
-}
-async function formatAndWriteTypescript(output, fullOutputPath, logPrefix) {
-  const formattedOutput = await formatTypescript(output);
-  await import_promises.default.mkdir(import_node_path2.default.dirname(fullOutputPath), { recursive: true });
-  await import_promises.default.writeFile(fullOutputPath, formattedOutput);
-  debug2(`${logPrefix}: ${fullOutputPath}`);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  abiToInterface,
-  contractToInterface,
-  findContractNode,
-  formatAndWriteSolidity,
-  formatAndWriteTypescript,
-  formatSolidity,
-  formatTypescript,
-  getLeftPaddingBits,
-  isLeftAligned,
-  renderArguments,
-  renderCommonData,
-  renderEnums,
-  renderImportPath,
-  renderImports,
-  renderList,
-  renderTableId,
-  renderTypeHelpers,
-  renderValueTypeToBytes32,
-  renderWithFieldSuffix,
-  renderWithStore,
-  renderedSolidityHeader,
-  schemaTypesToRecsTypeStrings
-});
-//# sourceMappingURL=codegen.cjs.map