@latticexyz/world 2.2.21-f4db683f90214b03bb8d68635a3825cc9bf58263 → 2.2.22-01a4d064e5fd8e579d54bb3aa8997f225c6960d3

package/dist/node.js

@@ -258,6 +258,7 @@ import {
   renderedSolidityHeader as renderedSolidityHeader2,
   renderImports as renderImports2
 } from "@latticexyz/common/codegen";
+import { stringToHex } from "viem";
 function renderSystemLibrary(options) {
   const {
     imports: systemImports,
@@ -266,11 +267,18 @@ function renderSystemLibrary(options) {
     systemName,
     namespace,
     resourceId,
-    functions,
+    functions: functionsInput,
     errors: systemErrors,
     worldImportPath,
     storeImportPath
   } = options;
+  const functions = functionsInput.map((func) => ({
+    ...func,
+    // Format parameters (add auxiliary argument names, replace calldata location)
+    parameters: formatParams(func.parameters),
+    // Remove `payable` from stateMutability for library functions
+    stateMutability: func.stateMutability.replace("payable", "")
+  }));
   const imports = [
     ...systemImports,
     {
@@ -390,7 +398,7 @@ function renderErrors(errors) {
 }
 function renderUserTypeFunction(contractFunction, userTypeName) {
   const { name, parameters, stateMutability, returnParameters } = contractFunction;
-  const args = [`${userTypeName} self`, ...parameters].map((arg) => arg.replace(/ calldata /, " memory "));
+  const args = [`${userTypeName} self`, ...parameters];
   const functionSignature = `
     function ${name}(
       ${renderArguments2(args)}
@@ -407,7 +415,7 @@ function renderUserTypeFunction(contractFunction, userTypeName) {
 }
 function renderCallWrapperFunction(contractFunction, callingFromRootSystemErrorName) {
   const { name, parameters, stateMutability, returnParameters } = contractFunction;
-  const args = [`CallWrapper memory self`, ...parameters].map((arg) => arg.replace(/ calldata /, " memory "));
+  const args = [`CallWrapper memory self`, ...parameters];
   const functionSignature = `
     function ${name}(
       ${renderArguments2(args)}
@@ -451,7 +459,7 @@ function renderRootCallWrapperFunction(contractFunction, namespace) {
   if (namespace === "" && stateMutability != "") {
     return "";
   }
-  const args = ["RootCallWrapper memory self", ...parameters].map((arg) => arg.replace(/ calldata /, " memory "));
+  const args = ["RootCallWrapper memory self", ...parameters];
   const functionSignature = `
     function ${name}(
       ${renderArguments2(args)}
@@ -492,7 +500,7 @@ function renderFunctionInterface(contractFunction) {
 }
 function functionInterfaceName(contractFunction) {
   const { name, parameters } = contractFunction;
-  const paramTypes = parameters.map((param) => param.split(" ")[0]).map((type5) => type5.replace("[]", "Array")).join("_");
+  const paramTypes = parameters.map((param) => param.split(" ")[0]).map((type5) => type5.replace("[]", "Array")).map((type5) => type5.replace(/\[.+\]/, (match2) => stringToHex(match2))).join("_");
   return `_${name}${paramTypes.length === 0 ? "" : `_${paramTypes}`}`;
 }
 function renderEncodeSystemCall(contractFunction) {
@@ -512,6 +520,14 @@ function renderReturnParameters2(returnParameters) {
   if (returnParameters.length == 0) return "";
   return `returns (${renderArguments2(returnParameters)})`;
 }
+function formatParams(params) {
+  let auxCount = 0;
+  return params.map((arg) => arg.replace(/ calldata /, " memory ")).map((arg) => {
+    const items = arg.split(" ");
+    const needsAux = items.length === 1 || items.length === 2 && items[1] === "memory";
+    return needsAux ? `${arg} __aux${auxCount++}` : arg;
+  });
+}
 
 // ts/node/render-solidity/renderWorldInterface.ts
 import { renderArguments as renderArguments3, renderedSolidityHeader as renderedSolidityHeader3, renderImports as renderImports3 } from "@latticexyz/common/codegen";
@@ -553,7 +569,7 @@ function renderWorldInterface({
 }
 
 // ts/node/render-solidity/worldgen.ts
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import path4 from "node:path";
 import { formatAndWriteSolidity, contractToInterface } from "@latticexyz/common/codegen";
 
@@ -562,6 +578,7 @@ import { isHex } from "viem";
 
 // ts/node/getSystemContracts.ts
 import path3 from "node:path";
+import fs from "node:fs/promises";
 
 // ts/node/findSolidityFiles.ts
 import path2 from "node:path";
@@ -5270,8 +5287,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs3 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs3);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs4 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs4);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -5829,8 +5846,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs3) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+  newRoot(fs4) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -5858,8 +5875,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs3) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+  newRoot(fs4) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -6947,19 +6964,25 @@ async function findSolidityFiles({ cwd, pattern = "**" }) {
 }
 
 // ts/node/getSystemContracts.ts
+import { parseSystem } from "@latticexyz/common/codegen";
+import { isDefined } from "@latticexyz/common/utils";
 async function getSystemContracts({
   rootDir,
   config
 }) {
-  const solidityFiles = await findSolidityFiles({
+  const filePaths = await findSolidityFiles({
     cwd: rootDir,
     pattern: path3.join(config.sourceDirectory, "**")
   });
-  return solidityFiles.filter(
-    (file) => file.basename.endsWith("System") && // exclude the base System contract
-    file.basename !== "System" && // exclude interfaces
-    !/^I[A-Z]/.test(file.basename)
-  ).map((file) => {
+  const files = await Promise.all(
+    filePaths.map(async (file) => {
+      const source = await fs.readFile(path3.join(rootDir, file.filename), "utf-8");
+      return { ...file, source };
+    })
+  );
+  return files.map((file) => {
+    const parsedSystem = parseSystem(file.source, file.basename);
+    if (!parsedSystem) return;
     const namespaceLabel = (() => {
       if (!config.multipleNamespaces && config.namespace != null) return config.namespace;
       const relativePath = path3.relative(path3.join(rootDir, config.sourceDirectory), file.filename);
@@ -6976,7 +6999,7 @@ async function getSystemContracts({
       namespaceLabel,
       systemLabel: file.basename
     };
-  });
+  }).filter(isDefined);
 }
 
 // ts/node/resolveSystems.ts
@@ -7034,7 +7057,7 @@ async function worldgen({
     config.codegen.outputDirectory,
     config.codegen.worldgenDirectory
   );
-  const systems = (await resolveSystems({ rootDir, config })).filter((system) => system.deploy.registerWorldFunctions).map((system) => {
+  const systems = (await resolveSystems({ rootDir, config })).filter((system) => system.deploy.registerWorldFunctions || config.codegen.generateSystemLibraries).map((system) => {
     const interfaceName = `I${system.label}`;
     const libraryName = `${system.label}Lib`;
     const sourceDir = config.multipleNamespaces ? path4.join(config.sourceDirectory, "namespaces", system.namespaceLabel) : config.sourceDirectory;
@@ -7054,12 +7077,12 @@ async function worldgen({
   if (clean) {
     const libraryDirs = [...new Set(systems.map(({ libraryPath }) => path4.dirname(libraryPath)))];
     await Promise.all([
-      fs.rm(worldgenOutDir, { recursive: true, force: true }),
-      ...libraryDirs.map((dir) => fs.rm(dir, { recursive: true, force: true }))
+      fs2.rm(worldgenOutDir, { recursive: true, force: true }),
+      ...libraryDirs.map((dir) => fs2.rm(dir, { recursive: true, force: true }))
     ]);
   }
   const outputPath = path4.join(worldgenOutDir, config.codegen.worldInterfaceName + ".sol");
-  const worldImports = systems.map(
+  const worldImports = systems.filter((system) => system.deploy.registerWorldFunctions).map(
     (system) => ({
       symbol: system.interfaceName,
       path: "./" + path4.relative(path4.dirname(outputPath), system.interfacePath)
@@ -7069,22 +7092,24 @@ async function worldgen({
   const worldImportPath = config.codegen.worldImportPath.startsWith(".") ? "./" + path4.relative(path4.dirname(outputPath), path4.join(rootDir, config.codegen.worldImportPath)) : config.codegen.worldImportPath;
   await Promise.all(
     systems.map(async (system) => {
-      const source = await fs.readFile(path4.join(rootDir, system.sourcePath), "utf8");
+      const source = await fs2.readFile(path4.join(rootDir, system.sourcePath), "utf8");
       const { functions, errors, symbolImports } = contractToInterface(source, system.label);
-      const interfaceImports = symbolImports.map(
-        ({ symbol, path: importPath }) => ({
-          symbol,
-          path: importPath.startsWith(".") ? "./" + path4.relative(worldgenOutDir, path4.join(rootDir, path4.dirname(system.sourcePath), importPath)) : importPath
-        })
-      );
-      const systemInterface = renderSystemInterface({
-        name: system.interfaceName,
-        functionPrefix: system.namespace === "" ? "" : `${system.namespace}__`,
-        functions,
-        errors,
-        imports: interfaceImports
-      });
-      await formatAndWriteSolidity(systemInterface, system.interfacePath, "Generated system interface");
+      if (system.deploy.registerWorldFunctions) {
+        const interfaceImports = symbolImports.map(
+          ({ symbol, path: importPath }) => ({
+            symbol,
+            path: importPath.startsWith(".") ? "./" + path4.relative(worldgenOutDir, path4.join(rootDir, path4.dirname(system.sourcePath), importPath)) : importPath
+          })
+        );
+        const systemInterface = renderSystemInterface({
+          name: system.interfaceName,
+          functionPrefix: system.namespace === "" ? "" : `${system.namespace}__`,
+          functions,
+          errors,
+          imports: interfaceImports
+        });
+        await formatAndWriteSolidity(systemInterface, system.interfacePath, "Generated system interface");
+      }
       if (config.codegen.generateSystemLibraries) {
         const systemImport = {
           symbol: system.label,
@@ -7129,7 +7154,7 @@ async function worldgen({
 import path5 from "node:path";
 import { readFile } from "node:fs/promises";
 import { type as type2 } from "arktype";
-import { indent, isDefined } from "@latticexyz/common/utils";
+import { indent, isDefined as isDefined2 } from "@latticexyz/common/utils";
 import { size, sliceHex } from "viem";
 
 // ts/node/common.ts
@@ -7207,7 +7232,7 @@ ${indent(artifact.message)}`);
       return;
     }
     return artifact;
-  }).filter(isDefined).filter(hasMetadata).map((artifact) => {
+  }).filter(isDefined2).filter(hasMetadata).map((artifact) => {
     artifact;
     const sourcePath = Object.keys(artifact.metadata.settings.compilationTarget)[0];
     const name = artifact.metadata.settings.compilationTarget[sourcePath];
@@ -7316,7 +7341,7 @@ async function buildSystemsManifest(opts) {
 }
 
 // ts/node/loadSystemsManifest.ts
-import fs2 from "node:fs/promises";
+import fs3 from "node:fs/promises";
 import path7 from "node:path";
 import { type as type4 } from "arktype";
 import { indent as indent2 } from "@latticexyz/common/utils";
@@ -7324,13 +7349,13 @@ var parseManifest = type4("string").pipe.try((s) => JSON.parse(s), SystemsManife
 async function loadSystemsManifest(opts) {
   const outFile = path7.join(opts.rootDir, systemsManifestFilename);
   try {
-    await fs2.access(outFile, fs2.constants.F_OK | fs2.constants.R_OK);
+    await fs3.access(outFile, fs3.constants.F_OK | fs3.constants.R_OK);
   } catch (error2) {
     throw new Error(
       `Systems manifest at "${systemsManifestFilename}" not found or not readable. Run \`mud build\` before trying again.`
     );
   }
-  const json = await fs2.readFile(outFile, "utf8");
+  const json = await fs3.readFile(outFile, "utf8");
   const manifest = parseManifest(json);
   if (manifest instanceof type4.errors) {
     throw new Error(