@latticexyz/common 2.0.0-next.15 → 2.0.0-next.17

package/src/codegen/render-solidity/common.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { getLeftPaddingBits, isLeftAligned, renderTableId, renderValueTypeToBytes32 } from "./common";
+
+describe("isLeftAligned", () => {
+  it("returns true when a Solidity type's bytes should be left aligned", () => {
+    expect(isLeftAligned({ internalTypeId: "bytes32" })).toBe(true);
+    expect(isLeftAligned({ internalTypeId: "uint256" })).toBe(false);
+    expect(isLeftAligned({ internalTypeId: "bool" })).toBe(false);
+  });
+});
+
+describe("getLeftPaddingBits", () => {
+  it("returns number of bits to left pad the bytes representation", () => {
+    expect(getLeftPaddingBits({ internalTypeId: "bytes32", staticByteLength: 32 })).toBe(0);
+    expect(getLeftPaddingBits({ internalTypeId: "bytes16", staticByteLength: 16 })).toBe(0);
+    expect(getLeftPaddingBits({ internalTypeId: "uint32", staticByteLength: 4 })).toBe(224);
+    expect(getLeftPaddingBits({ internalTypeId: "uint64", staticByteLength: 8 })).toBe(192);
+    expect(getLeftPaddingBits({ internalTypeId: "uint128", staticByteLength: 16 })).toBe(128);
+  });
+});
+
+describe("renderValueTypeToBytes32", () => {
+  it("returns Solidity code to cast native type to bytes32", () => {
+    expect(renderValueTypeToBytes32("someField", { typeUnwrap: "", internalTypeId: "bytes32" })).toMatchInlineSnapshot(
+      '"someField"'
+    );
+    expect(
+      renderValueTypeToBytes32("someField", { typeUnwrap: "SomeStruct.unwrap", internalTypeId: "bytes32" })
+    ).toMatchInlineSnapshot('"SomeStruct.unwrap(someField)"');
+
+    expect(renderValueTypeToBytes32("someField", { typeUnwrap: "", internalTypeId: "bytes16" })).toMatchInlineSnapshot(
+      '"bytes32(someField)"'
+    );
+    expect(
+      renderValueTypeToBytes32("someField", { typeUnwrap: "SomeStruct.unwrap", internalTypeId: "bytes16" })
+    ).toMatchInlineSnapshot('"bytes32(SomeStruct.unwrap(someField))"');
+
+    expect(renderValueTypeToBytes32("someField", { typeUnwrap: "", internalTypeId: "uint8" })).toMatchInlineSnapshot(
+      '"bytes32(uint256(someField))"'
+    );
+    expect(
+      renderValueTypeToBytes32("someField", { typeUnwrap: "SomeStruct.unwrap", internalTypeId: "uint8" })
+    ).toMatchInlineSnapshot('"bytes32(uint256(SomeStruct.unwrap(someField)))"');
+
+    expect(renderValueTypeToBytes32("someField", { typeUnwrap: "", internalTypeId: "bool" })).toMatchInlineSnapshot(
+      '"_boolToBytes32(someField)"'
+    );
+    expect(
+      renderValueTypeToBytes32("someField", { typeUnwrap: "SomeStruct.unwrap", internalTypeId: "bool" })
+    ).toMatchInlineSnapshot('"_boolToBytes32(SomeStruct.unwrap(someField))"');
+
+    expect(renderValueTypeToBytes32("someField", { typeUnwrap: "", internalTypeId: "address" })).toMatchInlineSnapshot(
+      '"bytes32(uint256(uint160(someField)))"'
+    );
+    expect(
+      renderValueTypeToBytes32("someField", { typeUnwrap: "SomeStruct.unwrap", internalTypeId: "address" })
+    ).toMatchInlineSnapshot('"bytes32(uint256(uint160(SomeStruct.unwrap(someField))))"');
+  });
+});
+
+describe("renderTableId", () => {
+  it("returns Solidity code to compute table ID", () => {
+    expect(renderTableId({ namespace: "somewhere", name: "Player", offchainOnly: false, tableIdName: "PlayerTableId" }))
+      .toMatchInlineSnapshot(`
+        "
+            // Hex below is the result of \`WorldResourceIdLib.encode({ namespace: \\"somewhere\\", name: \\"Player\\", typeId: RESOURCE_TABLE });\`
+            ResourceId constant _tableId = ResourceId.wrap(0x7462736f6d6577686572650000000000506c6179657200000000000000000000);
+            ResourceId constant PlayerTableId = _tableId;
+          "
+      `);
+  });
+
+  it("returns Solidity code to compute offchain table ID", () => {
+    expect(renderTableId({ namespace: "somewhere", name: "Player", offchainOnly: true, tableIdName: "PlayerTableId" }))
+      .toMatchInlineSnapshot(`
+        "
+            // Hex below is the result of \`WorldResourceIdLib.encode({ namespace: \\"somewhere\\", name: \\"Player\\", typeId: RESOURCE_OFFCHAIN_TABLE });\`
+            ResourceId constant _tableId = ResourceId.wrap(0x6f74736f6d6577686572650000000000506c6179657200000000000000000000);
+            ResourceId constant PlayerTableId = _tableId;
+          "
+      `);
+  });
+});

package/src/codegen/render-solidity/common.ts

@@ -8,9 +8,13 @@ import {
   RenderType,
 } from "./types";
 import { posixPath } from "../utils";
+import { resourceToHex } from "../../resourceToHex";
 
+/**
+ * Common header for all codegenerated solidity files
+ */
 export const renderedSolidityHeader = `// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.21;
+pragma solidity >=0.8.24;
 
 /* Autogenerated file. Do not edit manually. */`;
 
@@ -29,24 +33,30 @@ export function renderArguments(args: (string | undefined)[]): string {
   return internalRenderList(",", filteredArgs, (arg) => arg);
 }
 
+interface RenderedCommonData {
+  /** `_tableId` variable prefixed with its type (empty string if absent) */
+  _typedTableId: string;
+  /** Comma-separated table key names prefixed with their types (empty string if 0 keys) */
+  _typedKeyArgs: string;
+  /** Definition and initialization of the dynamic `_keyTuple` bytes32 array */
+  _keyTupleDefinition: string;
+}
+
+/**
+ * Renders some solidity statements commonly used within table libraries
+ * @param param0.staticResourceData static data about the table library
+ * @param param0.keyTuple key tuple of the table library
+ * @returns Rendered statement strings
+ */
 export function renderCommonData({
   staticResourceData,
   keyTuple,
 }: {
   staticResourceData?: StaticResourceData;
   keyTuple: RenderKeyTuple[];
-}): {
-  _tableId: string;
-  _typedTableId: string;
-  _keyArgs: string;
-  _typedKeyArgs: string;
-  _keyTupleDefinition: string;
-} {
+}): RenderedCommonData {
   // static resource means static tableId as well, and no tableId arguments
-  const _tableId = staticResourceData ? "" : "_tableId";
   const _typedTableId = staticResourceData ? "" : "ResourceId _tableId";
-
-  const _keyArgs = renderArguments(keyTuple.map(({ name }) => name));
   const _typedKeyArgs = renderArguments(keyTuple.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
 
   const _keyTupleDefinition = `
@@ -55,9 +65,7 @@ export function renderCommonData({
   `;
 
   return {
-    _tableId,
     _typedTableId,
-    _keyArgs,
     _typedKeyArgs,
     _keyTupleDefinition,
   };
@@ -125,28 +133,60 @@ export function renderAbsoluteImports(imports: AbsoluteImportDatum[]): string {
   return renderedImports.join("\n");
 }
 
+interface RenderWithStoreCallbackData {
+  /** `_store` variable prefixed with its type (undefined if library name) */
+  _typedStore: string | undefined;
+  /**  `_store` variable (undefined if library name) */
+  _store: string;
+  /** Empty string if storeArgument is false, otherwise `" (using the specified store)"` */
+  _commentSuffix: string;
+  /** Prefix to differentiate different kinds of store usage within methods */
+  _methodNamePrefix: string;
+  /** Whether FieldLayout variable should be passed to store methods */
+  _useExplicitFieldLayout?: boolean;
+}
+
+/**
+ * Renders several versions of the callback's result, which access Store in different ways
+ * @param storeArgument whether to render a version with `IStore _store` as an argument
+ * @param callback renderer for a method which uses store
+ * @returns Concatenated results of all callback calls
+ */
 export function renderWithStore(
   storeArgument: boolean,
-  callback: (
-    _typedStore: string | undefined,
-    _store: string,
-    _commentSuffix: string,
-    _untypedStore: string | undefined,
-    _methodPrefix: string,
-    _internal?: boolean
-  ) => string
+  callback: (data: RenderWithStoreCallbackData) => string
 ): string {
   let result = "";
-  result += callback(undefined, "StoreSwitch", "", undefined, "");
-  result += callback(undefined, "StoreCore", "", undefined, "_", true);
+  result += callback({ _typedStore: undefined, _store: "StoreSwitch", _commentSuffix: "", _methodNamePrefix: "" });
+  result += callback({
+    _typedStore: undefined,
+    _store: "StoreCore",
+    _commentSuffix: "",
+    _methodNamePrefix: "_",
+    _useExplicitFieldLayout: true,
+  });
 
   if (storeArgument) {
-    result += "\n" + callback("IStore _store", "_store", " (using the specified store)", "_store", "");
+    result +=
+      "\n" +
+      callback({
+        _typedStore: "IStore _store",
+        _store: "_store",
+        _commentSuffix: " (using the specified store)",
+        _methodNamePrefix: "",
+      });
   }
 
   return result;
 }
 
+/**
+ * Renders several versions of the callback's result, which have different method name suffixes
+ * @param withSuffixlessFieldMethods whether to render methods with an empty suffix
+ * @param fieldName name of the field which the methods access, used for a suffix
+ * @param callback renderer for a method to be suffixed
+ * @returns Concatenated results of all callback calls
+ */
 export function renderWithFieldSuffix(
   withSuffixlessFieldMethods: boolean,
   fieldName: string,
@@ -163,42 +203,47 @@ export function renderWithFieldSuffix(
   return result;
 }
 
-export function renderTableId({ namespace, name, offchainOnly, tableIdName }: StaticResourceData): {
-  hardcodedTableId: string;
-  tableIdDefinition: string;
-} {
-  const hardcodedTableId = `
-    ResourceId.wrap(
-      bytes32(
-        abi.encodePacked(
-          ${offchainOnly ? "RESOURCE_OFFCHAIN_TABLE" : "RESOURCE_TABLE"},
-          bytes14("${namespace}"),
-          bytes16("${name}")
-        )
-      )
-    )
-  `;
-
-  const tableIdDefinition = `
-    ResourceId constant _tableId = ${hardcodedTableId};
+/**
+ * Renders `_tableId` variable definition and initialization, and its alias which uses the provided `tableIdName`.
+ * @param param0 static resource data needed to construct the table id
+ */
+export function renderTableId({
+  namespace,
+  name,
+  offchainOnly,
+  tableIdName,
+}: Pick<StaticResourceData, "namespace" | "name" | "offchainOnly" | "tableIdName">): string {
+  return `
+    // Hex below is the result of \`WorldResourceIdLib.encode({ namespace: ${JSON.stringify(
+      namespace
+    )}, name: ${JSON.stringify(name)}, typeId: ${offchainOnly ? "RESOURCE_OFFCHAIN_TABLE" : "RESOURCE_TABLE"} });\`
+    ResourceId constant _tableId = ResourceId.wrap(${resourceToHex({
+      type: offchainOnly ? "offchainTable" : "table",
+      namespace,
+      name,
+    })});
     ResourceId constant ${tableIdName} = _tableId;
   `;
-  return {
-    hardcodedTableId,
-    tableIdDefinition,
-  };
 }
 
-export function renderValueTypeToBytes32(name: string, { typeUnwrap, internalTypeId }: RenderType): string {
+/**
+ * Renders solidity typecasts to get from the given type to `bytes32`
+ * @param name variable name to be typecasted
+ * @param param1 type data
+ */
+export function renderValueTypeToBytes32(
+  name: string,
+  { typeUnwrap, internalTypeId }: Pick<RenderType, "typeUnwrap" | "internalTypeId">
+): string {
   const innerText = typeUnwrap.length ? `${typeUnwrap}(${name})` : name;
 
   if (internalTypeId === "bytes32") {
     return innerText;
-  } else if (internalTypeId.match(/^bytes\d{1,2}$/)) {
+  } else if (/^bytes\d{1,2}$/.test(internalTypeId)) {
     return `bytes32(${innerText})`;
-  } else if (internalTypeId.match(/^uint\d{1,3}$/)) {
+  } else if (/^uint\d{1,3}$/.test(internalTypeId)) {
     return `bytes32(uint256(${innerText}))`;
-  } else if (internalTypeId.match(/^int\d{1,3}$/)) {
+  } else if (/^int\d{1,3}$/.test(internalTypeId)) {
     return `bytes32(uint256(int256(${innerText})))`;
   } else if (internalTypeId === "address") {
     return `bytes32(uint256(uint160(${innerText})))`;
@@ -209,10 +254,16 @@ export function renderValueTypeToBytes32(name: string, { typeUnwrap, internalTyp
   }
 }
 
+/**
+ * Whether the storage representation of the given solidity type is left aligned
+ */
 export function isLeftAligned(field: Pick<RenderType, "internalTypeId">): boolean {
-  return field.internalTypeId.match(/^bytes\d{1,2}$/) !== null;
+  return /^bytes\d{1,2}$/.test(field.internalTypeId);
 }
 
+/**
+ * The number of padding bits in the storage representation of a right-aligned solidity type
+ */
 export function getLeftPaddingBits(field: Pick<RenderType, "internalTypeId" | "staticByteLength">): number {
   if (isLeftAligned(field)) {
     return 0;
@@ -221,6 +272,9 @@ export function getLeftPaddingBits(field: Pick<RenderType, "internalTypeId" | "s
   }
 }
 
+/**
+ * Internal helper to render `lineTerminator`-separated list of items mapped by `renderItem`
+ */
 function internalRenderList<T>(
   lineTerminator: string,
   list: T[],

package/src/codegen/render-solidity/renderEnums.ts

@@ -1,6 +1,9 @@
 import { renderArguments, renderList, renderedSolidityHeader } from "./common";
 import { RenderEnum } from "./types";
 
+/**
+ * Render a list of enum data as solidity enum definitions
+ */
 export function renderEnums(enums: RenderEnum[]): string {
   let result = renderedSolidityHeader;
 

package/src/codegen/render-solidity/renderTypeHelpers.ts

@@ -1,5 +1,8 @@
 import { RenderField, RenderKeyTuple, RenderType } from "./types";
 
+/**
+ * Renders the necessary helper functions to typecast to/from the types of given fields and keys
+ */
 export function renderTypeHelpers(options: { fields: RenderField[]; keyTuple: RenderKeyTuple[] }): string {
   const { fields, keyTuple } = options;
 
@@ -59,6 +62,14 @@ function getWrappingHelpers(array: RenderType[]): string[] {
   return [...wrappers.values(), ...unwrappers.values()];
 }
 
+/**
+ * Renders a function to cast a dynamic array to a static array.
+ * @param functionName name of the function to be rendered
+ * @param elementType type of the array's element
+ * @param staticLength length of the static array
+ * @param internalTypeId solidity type name of the dynamic array
+ * @returns
+ */
 function renderWrapperStaticArray(
   functionName: string,
   elementType: string,
@@ -96,6 +107,14 @@ function renderWrapperStaticArray(
   `;
 }
 
+/**
+ * Renders a function to cast a static array to a dynamic array.
+ * @param functionName name of the function to be rendered
+ * @param elementType type of the array's element
+ * @param staticLength length of the static array
+ * @param internalTypeId solidity type name of the dynamic array
+ * @returns
+ */
 function renderUnwrapperStaticArray(
   functionName: string,
   elementType: string,

package/src/codegen/render-solidity/types.ts

@@ -14,13 +14,18 @@ export type ImportDatum = AbsoluteImportDatum | RelativeImportDatum;
 export interface StaticResourceData {
   /** Name of the table id constant to render. */
   tableIdName: string;
+  /** Table namespace string */
   namespace: string;
+  /** Table name string */
   name: string;
+  /** Whether the table is offchain only (does not use storage) */
   offchainOnly: boolean;
 }
 
 export interface RenderType {
+  /** Fully-qualified name of the user-defined type (may include a library name as prefix) */
   typeId: string;
+  /** Fully-qualified name of the user-defined type (may include a library name as prefix), followed by location (none/memory/storage) */
   typeWithLocation: string;
   /** The name of the enum element in SchemaType to use for schema registration (e.g. "UINT256_ARRAY") */
   enumName: string;

package/src/codegen/utils/contractToInterface.ts

@@ -1,5 +1,10 @@
 import { parse, visit } from "@solidity-parser/parser";
-import type { SourceUnit, TypeName, VariableDeclaration } from "@solidity-parser/parser/dist/src/ast-types";
+import type {
+  ContractDefinition,
+  SourceUnit,
+  TypeName,
+  VariableDeclaration,
+} from "@solidity-parser/parser/dist/src/ast-types";
 import { MUDError } from "../../errors";
 
 export interface ContractInterfaceFunction {
@@ -36,52 +41,55 @@ export function contractToInterface(
 } {
   const ast = parse(data);
 
-  let withContract = false;
+  const contractNode = findContractNode(parse(data), contractName);
   let symbolImports: SymbolImport[] = [];
   const functions: ContractInterfaceFunction[] = [];
   const errors: ContractInterfaceError[] = [];
 
-  visit(ast, {
-    ContractDefinition({ name }) {
-      if (name === contractName) {
-        withContract = true;
-      }
-    },
-    FunctionDefinition(
-      { name, visibility, parameters, stateMutability, returnParameters, isConstructor, isFallback, isReceiveEther },
-      parent
-    ) {
-      if (parent !== undefined && parent.type === "ContractDefinition" && parent.name === contractName) {
-        try {
-          // skip constructor and fallbacks
-          if (isConstructor || isFallback || isReceiveEther) return;
-          // forbid default visibility (this check might be unnecessary, modern solidity already disallows this)
-          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 (error: unknown) {
-          if (error instanceof MUDError) {
-            error.message = `Function "${name}" in contract "${contractName}": ${error.message}`;
+  if (!contractNode) {
+    throw new MUDError(`Contract not found: ${contractName}`);
+  }
+
+  visit(contractNode, {
+    FunctionDefinition({
+      name,
+      visibility,
+      parameters,
+      stateMutability,
+      returnParameters,
+      isConstructor,
+      isFallback,
+      isReceiveEther,
+    }) {
+      try {
+        // skip constructor and fallbacks
+        if (isConstructor || isFallback || isReceiveEther) return;
+        // forbid default visibility (this check might be unnecessary, modern solidity already disallows this)
+        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));
           }
-          throw error;
         }
+      } catch (error: unknown) {
+        if (error instanceof MUDError) {
+          error.message = `Function "${name}" in contract "${contractName}": ${error.message}`;
+        }
+        throw error;
       }
     },
     CustomErrorDefinition({ name, parameters }) {
       errors.push({
-        name: name === null ? "" : name,
+        name,
         parameters: parameters.map(parseParameter),
       });
 
@@ -92,10 +100,6 @@ export function contractToInterface(
     },
   });
 
-  if (!withContract) {
-    throw new MUDError(`Contract not found: ${contractName}`);
-  }
-
   return {
     functions,
     errors,
@@ -103,6 +107,20 @@ export function contractToInterface(
   };
 }
 
+function findContractNode(ast: SourceUnit, contractName: string): ContractDefinition | undefined {
+  let contract = undefined;
+
+  visit(ast, {
+    ContractDefinition(node) {
+      if (node.name === contractName) {
+        contract = node;
+      }
+    },
+  });
+
+  return contract;
+}
+
 function parseParameter({ name, typeName, storageLocation }: VariableDeclaration): string {
   let typedNameWithLocation = "";
 

package/src/codegen/utils/extractUserTypes.ts

@@ -2,10 +2,15 @@ import { parse, visit } from "@solidity-parser/parser";
 import { MUDError } from "../../errors";
 
 export interface SolidityUserDefinedType {
+  /** Fully-qualified name of the user-defined type (may include a library name as prefix) */
   typeId: string;
+  /** Name of the wrapped primitive type */
   internalTypeId: string;
+  /** Symbol which must be imported to use the type (either the type name, or the library name where the type is defined) */
   importSymbol: string;
+  /** Path to the solidity file which contains the user type */
   fromPath: string;
+  /** Whether `fromPath` is relative  */
   isRelativePath: boolean;
 }
 
@@ -13,6 +18,8 @@ export interface SolidityUserDefinedType {
  * Parse the solidity data to extract user-defined type information.
  * @param data contents of a solidity file with the user types declarations
  * @param userTypeNames names of the user types to extract
+ * @param fromPath path to the solidity file from which the user types are extracted
+ * @returns record of type names mapped to the extracted type information
  */
 export function extractUserTypes(
   data: string,

package/src/codegen/utils/format.ts

@@ -1,6 +1,12 @@
 import prettier from "prettier";
 import prettierPluginSolidity from "prettier-plugin-solidity";
 
+/**
+ * Formats solidity code using prettier
+ * @param content solidity code
+ * @param prettierConfigPath optional path to a prettier config
+ * @returns formatted solidity code
+ */
 export async function formatSolidity(content: string, prettierConfigPath?: string): Promise<string> {
   let config;
   if (prettierConfigPath) {
@@ -31,6 +37,11 @@ export async function formatSolidity(content: string, prettierConfigPath?: strin
   }
 }
 
+/**
+ * Formats typescript code using prettier
+ * @param content typescript code
+ * @returns formatted typescript code
+ */
 export async function formatTypescript(content: string): Promise<string> {
   return prettier.format(content, {
     parser: "typescript",

package/src/codegen/utils/formatAndWrite.ts

@@ -3,6 +3,12 @@ import { dirname } from "path";
 import { formatSolidity, formatTypescript } from "./format";
 import { debug } from "../debug";
 
+/**
+ * Formats solidity code using prettier and write it to a file
+ * @param output solidity code
+ * @param fullOutputPath full path to the output file
+ * @param logPrefix prefix for debug logs
+ */
 export async function formatAndWriteSolidity(output: string, fullOutputPath: string, logPrefix: string): Promise<void> {
   const formattedOutput = await formatSolidity(output);
 
@@ -12,6 +18,12 @@ export async function formatAndWriteSolidity(output: string, fullOutputPath: str
   debug(`${logPrefix}: ${fullOutputPath}`);
 }
 
+/**
+ * Formats typescript code using prettier and write it to a file
+ * @param output typescript code
+ * @param fullOutputPath full path to the output file
+ * @param logPrefix prefix for debug logs
+ */
 export async function formatAndWriteTypescript(
   output: string,
   fullOutputPath: string,

package/src/codegen/utils/loadUserTypesFile.ts

@@ -9,6 +9,13 @@ export type UserType = {
   internalType: SchemaAbiType;
 };
 
+/**
+ * Load the user type files and extract type information from them.
+ * @param userTypes record of user type data mapped by type names
+ * @param outputBaseDirectory base path to the output directory
+ * @param remappings solc remappings
+ * @returns record of the user type information mapped by type names
+ */
 export function loadAndExtractUserTypes(
   userTypes: Record<string, UserType>,
   outputBaseDirectory: string,
@@ -35,7 +42,7 @@ export function loadAndExtractUserTypes(
       }
     }
 
-    extractedUserTypes = Object.assign(extractedUserTypes, userTypesInFile);
+    extractedUserTypes = { ...extractedUserTypes, ...userTypesInFile };
   }
   return extractedUserTypes;
 }

package/dist/chunk-TCWGPC6G.js

@@ -1,2 +0,0 @@
-import o from"debug";var e=o("mud:common"),r=o("mud:common");e.log=console.debug.bind(console);r.log=console.error.bind(console);export{e as a};
-//# sourceMappingURL=chunk-TCWGPC6G.js.map

package/dist/chunk-TCWGPC6G.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/debug.ts"],"sourcesContent":["import createDebug from \"debug\";\n\nexport const debug = createDebug(\"mud:common\");\nexport const error = createDebug(\"mud:common\");\n\n// Pipe debug output to stdout instead of stderr\ndebug.log = console.debug.bind(console);\n\n// Pipe error output to stderr\nerror.log = console.error.bind(console);\n"],"mappings":"AAAA,OAAOA,MAAiB,QAEjB,IAAMC,EAAQD,EAAY,YAAY,EAChCE,EAAQF,EAAY,YAAY,EAG7CC,EAAM,IAAM,QAAQ,MAAM,KAAK,OAAO,EAGtCC,EAAM,IAAM,QAAQ,MAAM,KAAK,OAAO","names":["createDebug","debug","error"]}