@latticexyz/cli 2.0.0-alpha.78 → 2.0.0-alpha.80

package/dist/{chunk-TLEAEDUA.js → chunk-6OEU4O7P.js}

@@ -1,12 +1,7 @@
 import {
-  deploy
-} from "./chunk-XUNWAEP7.js";
-import {
-  MUDError,
-  loadStoreConfig,
-  loadWorldConfig,
+  deploy,
   logError
-} from "./chunk-MN3HYFJK.js";
+} from "./chunk-YNVRICE5.js";
 import {
   execLog
 } from "./chunk-FFY7VTYB.js";
@@ -22,13 +17,13 @@ import {
   renderList,
   renderedSolidityHeader,
   tablegen
-} from "./chunk-DO7OWTMM.js";
+} from "./chunk-K25KS5QJ.js";
 import {
   tsgen
-} from "./chunk-TPZUS44H.js";
+} from "./chunk-SADK4UCO.js";
 import {
   formatAndWriteSolidity
-} from "./chunk-5NC2OON2.js";
+} from "./chunk-SKNB74MT.js";
 import {
   __commonJS,
   __toESM
@@ -3091,6 +3086,7 @@ var hello_default = commandModule4;
 
 // src/commands/tablegen.ts
 import path2 from "path";
+import { loadStoreConfig } from "@latticexyz/config";
 var commandModule5 = {
   command: "tablegen",
   describe: "Autogenerate MUD Store table libraries based on the config file",
@@ -3109,6 +3105,7 @@ var commandModule5 = {
 var tablegen_default = commandModule5;
 
 // src/commands/tsgen.ts
+import { loadStoreConfig as loadStoreConfig2 } from "@latticexyz/config";
 var commandModule6 = {
   command: "tsgen",
   describe: "Autogenerate MUD typescript definitions based on the config file",
@@ -3120,7 +3117,7 @@ var commandModule6 = {
   },
   async handler(args) {
     const { configPath, out } = args;
-    const config = await loadStoreConfig(configPath);
+    const config = await loadStoreConfig2(configPath);
     await tsgen(config, out);
     process.exit(0);
   }
@@ -3131,6 +3128,8 @@ var tsgen_default = commandModule6;
 import chalk3 from "chalk";
 import glob from "glob";
 import path3, { basename } from "path";
+import { loadStoreConfig as loadStoreConfig3, loadWorldConfig } from "@latticexyz/config";
+import { MUDError } from "@latticexyz/config";
 import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 
 // src/utils/getChainId.ts
@@ -3175,7 +3174,7 @@ async function deployHandler(args) {
   const srcDir = await getSrcDirectory();
   const existingContracts = glob.sync(`${srcDir}/**/*.sol`).map((path7) => basename(path7, ".sol"));
   const worldConfig = await loadWorldConfig(configPath, existingContracts);
-  const storeConfig = await loadStoreConfig(configPath);
+  const storeConfig = await loadStoreConfig3(configPath);
   const mudConfig = { ...worldConfig, ...storeConfig };
   if (printConfig)
     console.log(chalk3.green("\nResolved config:\n"), JSON.stringify(mudConfig, null, 2));
@@ -3215,6 +3214,7 @@ var commandModule7 = {
 var deploy_v2_default = commandModule7;
 
 // src/commands/worldgen.ts
+import { loadStoreConfig as loadStoreConfig4, loadWorldConfig as loadWorldConfig2 } from "@latticexyz/config";
 import glob2 from "glob";
 import path5, { basename as basename2 } from "path";
 
@@ -3224,6 +3224,7 @@ import path4 from "path";
 
 // src/utils/contractToInterface.ts
 import { parse, visit } from "@solidity-parser/parser";
+import { MUDError as MUDError2 } from "@latticexyz/config";
 function contractToInterface(data, contractName) {
   const ast = parse(data);
   let withContract = false;
@@ -3241,7 +3242,7 @@ function contractToInterface(data, contractName) {
           if (isConstructor || isFallback || isReceiveEther)
             return;
           if (visibility === "default")
-            throw new MUDError(`Visibility is not specified`);
+            throw new MUDError2(`Visibility is not specified`);
           if (visibility === "external" || visibility === "public") {
             functions.push({
               name: name === null ? "" : name,
@@ -3254,7 +3255,7 @@ function contractToInterface(data, contractName) {
             }
           }
         } catch (error) {
-          if (error instanceof MUDError) {
+          if (error instanceof MUDError2) {
             error.message = `Function "${name}" in contract "${contractName}": ${error.message}`;
           }
           throw error;
@@ -3263,7 +3264,7 @@ function contractToInterface(data, contractName) {
     }
   });
   if (!withContract) {
-    throw new MUDError(`Contract not found: ${contractName}`);
+    throw new MUDError2(`Contract not found: ${contractName}`);
   }
   return {
     functions,
@@ -3310,7 +3311,7 @@ function flattenTypeName(typeName) {
       stateMutability
     };
   } else {
-    throw new MUDError(`Invalid typeName.type ${typeName.type}`);
+    throw new MUDError2(`Invalid typeName.type ${typeName.type}`);
   }
 }
 function typeNameToExternalSymbols(typeName) {
@@ -3431,11 +3432,11 @@ var commandModule8 = {
       path: path7,
       basename: basename2(path7, ".sol")
     }));
-    const worldConfig = await loadWorldConfig(
+    const worldConfig = await loadWorldConfig2(
       configPath,
       existingContracts.map(({ basename: basename3 }) => basename3)
     );
-    const storeConfig = await loadStoreConfig(configPath);
+    const storeConfig = await loadStoreConfig4(configPath);
     const mudConfig = { ...worldConfig, ...storeConfig };
     const outputBaseDirectory = path5.join(srcDir, mudConfig.codegenDirectory);
     if (clean)
@@ -3450,11 +3451,12 @@ var worldgen_default = commandModule8;
 import chalk4 from "chalk";
 import { existsSync, readFileSync as readFileSync3, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "fs";
 import path6 from "path";
+import { MUDError as MUDError3 } from "@latticexyz/config";
 
 // package.json
 var package_default = {
   name: "@latticexyz/cli",
-  version: "2.0.0-alpha.78+cf5f4bfe",
+  version: "2.0.0-alpha.80+3eb8b70a",
   description: "Command line interface for mud",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -3471,33 +3473,34 @@ var package_default = {
   },
   scripts: {
     prepare: "yarn build",
-    codegen: "ts-node --esm --files ./scripts/codegen.ts",
+    codegen: "tsx ./scripts/codegen.ts",
     lint: "eslint . --ext .ts",
     dev: "tsup --watch",
     build: "tsup",
     link: "yarn link",
-    test: "vitest typecheck --run && yarn test:contracts",
+    test: "tsc --noEmit && yarn test:contracts",
     "test:contracts": "yarn codegen && forge test",
     release: "npm publish --access=public"
   },
   devDependencies: {
-    "@latticexyz/store": "^2.0.0-alpha.78+cf5f4bfe",
+    "@latticexyz/store": "^2.0.0-alpha.80+3eb8b70a",
     "@types/ejs": "^3.1.1",
     "@types/glob": "^7.2.0",
     "@types/node": "^17.0.34",
     "@types/openurl": "^1.0.0",
     "@types/yargs": "^17.0.10",
-    esbuild: "^0.15.16",
     tsup: "^6.6.3",
+    tsx: "^3.12.6",
     vitest: "^0.29.8"
   },
   dependencies: {
     "@improbable-eng/grpc-web": "^0.15.0",
     "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
-    "@latticexyz/schema-type": "^2.0.0-alpha.78+cf5f4bfe",
-    "@latticexyz/services": "^2.0.0-alpha.78+cf5f4bfe",
-    "@latticexyz/solecs": "^2.0.0-alpha.78+cf5f4bfe",
-    "@latticexyz/std-contracts": "^2.0.0-alpha.78+cf5f4bfe",
+    "@latticexyz/config": "^2.0.0-alpha.80+3eb8b70a",
+    "@latticexyz/schema-type": "^2.0.0-alpha.80+3eb8b70a",
+    "@latticexyz/services": "^2.0.0-alpha.80+3eb8b70a",
+    "@latticexyz/solecs": "^2.0.0-alpha.80+3eb8b70a",
+    "@latticexyz/std-contracts": "^2.0.0-alpha.80+3eb8b70a",
     "@solidity-parser/parser": "^0.16.0",
     "@typechain/ethers-v5": "^10.1.1",
     chalk: "^5.0.1",
@@ -3505,10 +3508,8 @@ var package_default = {
     dotenv: "^16.0.3",
     "ds-test": "https://github.com/dapphub/ds-test.git#c9ce3f25bde29fc5eb9901842bf02850dfd2d084",
     ejs: "^3.1.8",
-    esbuild: "^0.17.14",
     ethers: "^5.7.2",
     execa: "^7.0.0",
-    "find-up": "^6.3.0",
     "forge-std": "https://github.com/foundry-rs/forge-std.git#b4f121555729b3afb3c5ffccb62ff4b6e2818fd3",
     glob: "^8.0.3",
     "nice-grpc-web": "^2.0.1",
@@ -3517,14 +3518,13 @@ var package_default = {
     prettier: "^2.8.4",
     "prettier-plugin-solidity": "^1.1.2",
     table: "^6.8.1",
-    "ts-node": "^10.9.1",
     typechain: "^8.1.1",
     typescript: "^4.9.5",
     yargs: "^17.7.1",
     zod: "^3.21.4",
-    "zod-validation-error": "^1.0.1"
+    "zod-validation-error": "^1.3.0"
   },
-  gitHead: "cf5f4bfe0d1d14e70efbf10ebef47d39f39e7239"
+  gitHead: "3eb8b70a5f324f9b2fc98ecaf9c85fe8a9108dbd"
 };
 
 // src/commands/set-version.ts
@@ -3547,7 +3547,7 @@ var commandModule9 = {
   async handler(options) {
     try {
       if (!options.mudVersion && !options.restore) {
-        throw new MUDError(`Version parameter is required unless --restore is provided.`);
+        throw new MUDError3(`Version parameter is required unless --restore is provided.`);
       }
       options.mudVersion = options.mudVersion === "canary" ? await getCanaryVersion(package_default.name) : options.mudVersion;
       const rootPath = "./package.json";
@@ -3569,7 +3569,7 @@ function updatePackageJson(filePath, options) {
   const { backup, restore, force, mudVersion } = options;
   const backupFilePath = path6.join(path6.dirname(filePath), BACKUP_FILE);
   if (backup && !force && existsSync(backupFilePath)) {
-    throw new MUDError(
+    throw new MUDError3(
       `A backup file already exists at ${backupFilePath}.
 Use --force to overwrite it or --restore to restore it.`
     );
@@ -3620,7 +3620,7 @@ function readPackageJson(path7) {
     const jsonString = readFileSync3(path7, "utf8");
     return JSON.parse(jsonString);
   } catch {
-    throw new MUDError("Could not read JSON at " + path7);
+    throw new MUDError3("Could not read JSON at " + path7);
   }
 }
 async function getCanaryVersion(pkg) {
@@ -3631,7 +3631,7 @@ async function getCanaryVersion(pkg) {
     console.log(chalk4.green("MUD canary version:", canary));
     return canary;
   } catch (e) {
-    throw new MUDError(`Could not fetch canary version of ${pkg}`);
+    throw new MUDError3(`Could not fetch canary version of ${pkg}`);
   }
 }
 function logComparison(prev, curr) {

package/dist/{chunk-DO7OWTMM.js → chunk-K25KS5QJ.js}

@@ -1,12 +1,10 @@
 import {
+  SchemaTypeArrayToElement,
   formatAndWriteSolidity,
   getSchemaTypeInfo,
   importForAbiOrUserType,
   resolveAbiOrUserType
-} from "./chunk-5NC2OON2.js";
-import {
-  SchemaTypeArrayToElement
-} from "./chunk-KPBNUPK6.js";
+} from "./chunk-SKNB74MT.js";
 
 // src/render-solidity/tableOptions.ts
 import path from "path";

package/dist/{chunk-TPZUS44H.js → chunk-SADK4UCO.js}

@@ -1,7 +1,7 @@
 import {
   formatAndWriteTypescript,
   resolveAbiOrUserType
-} from "./chunk-5NC2OON2.js";
+} from "./chunk-SKNB74MT.js";
 
 // src/render-ts/schemaTypesToRecsTypeStrings.ts
 var schemaTypesToRecsTypeStrings = {

package/dist/{chunk-KPBNUPK6.js → chunk-SKNB74MT.js}

@@ -1,145 +1,3 @@
-// src/config/validation.ts
-import { ethers } from "ethers";
-import { ZodIssueCode } from "zod";
-function validateName(name, ctx) {
-  if (!/^\w+$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must contain only alphanumeric & underscore characters`
-    });
-  }
-}
-function validateCapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[A-Z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a capital letter`
-    });
-  }
-}
-function validateUncapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[a-z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a lowercase letter`
-    });
-  }
-}
-function validateEnum(members, ctx) {
-  if (members.length === 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not be empty`
-    });
-  }
-  if (members.length >= 256) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Length of enum must be < 256`
-    });
-  }
-  const duplicates = getDuplicates(members);
-  if (duplicates.length > 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not have duplicate names for: ${duplicates.join(", ")}`
-    });
-  }
-}
-function _factoryForValidateRoute(requireNonEmpty, requireSingleLevel) {
-  return (route, ctx) => {
-    if (route === "") {
-      if (requireNonEmpty) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not be empty`
-        });
-      }
-      return;
-    }
-    if (route[0] !== "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must start with "/"`
-      });
-    }
-    if (route[route.length - 1] === "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must not end with "/"`
-      });
-    }
-    const parts = route.split("/");
-    if (requireSingleLevel && parts.length > 2) {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must only have one level (e.g. "/foo")`
-      });
-    }
-    for (let i = 1; i < parts.length; i++) {
-      if (parts[i] === "") {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not contain empty route fragments (e.g. "//")`
-        });
-      }
-      if (!/^\w+$/.test(parts[i])) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must contain only alphanumeric & underscore characters`
-        });
-      }
-    }
-  };
-}
-var validateRoute = _factoryForValidateRoute(true, false);
-var validateBaseRoute = _factoryForValidateRoute(false, false);
-var validateSingleLevelRoute = _factoryForValidateRoute(true, true);
-function validateEthereumAddress(address, ctx) {
-  if (!ethers.utils.isAddress(address)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Address must be a valid Ethereum address`
-    });
-  }
-}
-function getDuplicates(array) {
-  const checked = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const element of array) {
-    if (checked.has(element)) {
-      duplicates.add(element);
-    }
-    checked.add(element);
-  }
-  return [...duplicates];
-}
-function validateSelector(name, ctx) {
-  if (name.length > 16) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Selector must be <= 16 characters`
-    });
-  }
-  if (!/^\w*$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Selector must contain only alphanumeric & underscore characters`
-    });
-  }
-}
-function parseStaticArray(abiType) {
-  const matches = abiType.match(/^(\w+)\[(\d+)\]$/);
-  if (!matches)
-    return null;
-  return {
-    elementType: matches[1],
-    staticLength: Number.parseInt(matches[2])
-  };
-}
-
 // ../schema-type/src/typescript/SchemaType.ts
 var SchemaType = /* @__PURE__ */ ((SchemaType2) => {
   SchemaType2[SchemaType2["UINT8"] = 0] = "UINT8";
@@ -707,24 +565,162 @@ var StaticAbiTypes = AbiTypes.filter(
   (abiType) => getStaticByteLength(AbiTypeToSchemaType[abiType]) > 0
 );
 
+// src/render-solidity/userType.ts
+import { parseStaticArray } from "@latticexyz/config";
+function resolveAbiOrUserType(abiOrUserType, config) {
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    const schemaType = AbiTypeToSchemaType[abiOrUserType];
+    return {
+      schemaType,
+      renderTableType: getSchemaTypeInfo(schemaType)
+    };
+  }
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    if (staticArray.elementType in AbiTypeToSchemaType) {
+      return getStaticArrayTypeInfo(abiOrUserType, staticArray.elementType, staticArray.staticLength);
+    } else {
+      throw new Error("Static arrays of user types are not supported");
+    }
+  }
+  return getUserTypeInfo(abiOrUserType, config);
+}
+function importForAbiOrUserType(abiOrUserType, usedInDirectory, config) {
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    return void 0;
+  }
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    return void 0;
+  }
+  return {
+    symbol: abiOrUserType,
+    fromPath: config.userTypesPath + ".sol",
+    usedInPath: usedInDirectory
+  };
+}
+function getSchemaTypeInfo(schemaType) {
+  const staticByteLength = getStaticByteLength(schemaType);
+  const isDynamic = staticByteLength === 0;
+  const typeId = SchemaTypeToAbiType[schemaType];
+  return {
+    typeId,
+    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
+    enumName: SchemaType[schemaType],
+    staticByteLength,
+    isDynamic,
+    typeWrap: "",
+    typeUnwrap: "",
+    internalTypeId: typeId
+  };
+}
+function getUserTypeInfo(userType, config) {
+  if (userType in config.enums) {
+    const schemaType = 0 /* UINT8 */;
+    const staticByteLength = getStaticByteLength(schemaType);
+    const isDynamic = staticByteLength === 0;
+    const typeId = userType;
+    return {
+      schemaType,
+      renderTableType: {
+        typeId,
+        typeWithLocation: typeId,
+        enumName: SchemaType[schemaType],
+        staticByteLength,
+        isDynamic,
+        typeWrap: `${userType}`,
+        typeUnwrap: `uint8`,
+        internalTypeId: `${SchemaTypeToAbiType[schemaType]}`
+      }
+    };
+  }
+  throw new Error(`User type "${userType}" does not exist`);
+}
+function getStaticArrayTypeInfo(abiType, elementType, staticLength) {
+  const internalTypeId = elementType + "[]";
+  const schemaType = AbiTypeToSchemaType[internalTypeId];
+  return {
+    schemaType,
+    renderTableType: {
+      typeId: abiType,
+      typeWithLocation: `${abiType} memory`,
+      enumName: SchemaType[schemaType],
+      staticByteLength: 0,
+      isDynamic: true,
+      typeWrap: `toStaticArray_${elementType}_${staticLength}`,
+      typeUnwrap: `fromStaticArray_${elementType}_${staticLength}`,
+      typeWrappingData: {
+        kind: "staticArray",
+        elementType,
+        staticLength
+      },
+      internalTypeId
+    }
+  };
+}
+
+// src/utils/format.ts
+import chalk from "chalk";
+import prettier from "prettier";
+import prettierPluginSolidity from "prettier-plugin-solidity";
+async function formatSolidity(content, prettierConfigPath) {
+  let config;
+  if (prettierConfigPath) {
+    config = await prettier.resolveConfig(prettierConfigPath);
+  }
+  try {
+    return prettier.format(content, {
+      plugins: [prettierPluginSolidity],
+      parser: "solidity-parse",
+      printWidth: 120,
+      semi: true,
+      tabWidth: 2,
+      useTabs: false,
+      bracketSpacing: true,
+      ...config
+    });
+  } catch (error) {
+    let message;
+    if (error instanceof Error) {
+      message = error.message;
+    } else {
+      message = error;
+    }
+    console.log(chalk.yellow(`Error during output formatting: ${message}`));
+    return content;
+  }
+}
+async function formatTypescript(content) {
+  return prettier.format(content, {
+    parser: "typescript"
+  });
+}
+
+// src/utils/formatAndWrite.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+async function formatAndWriteSolidity(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatSolidity(output);
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}
+async function formatAndWriteTypescript(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatTypescript(output);
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}
+
 export {
-  SchemaType,
-  getStaticByteLength,
   encodeSchema,
   SchemaTypeArrayToElement,
-  SchemaTypeToAbiType,
-  AbiTypeToSchemaType,
-  AbiTypes,
-  StaticAbiTypes,
-  validateName,
-  validateCapitalizedName,
-  validateUncapitalizedName,
-  validateEnum,
-  validateRoute,
-  validateBaseRoute,
-  validateSingleLevelRoute,
-  validateEthereumAddress,
-  getDuplicates,
-  validateSelector,
-  parseStaticArray
+  resolveAbiOrUserType,
+  importForAbiOrUserType,
+  getSchemaTypeInfo,
+  getUserTypeInfo,
+  formatSolidity,
+  formatTypescript,
+  formatAndWriteSolidity,
+  formatAndWriteTypescript
 };