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

package/dist/chunk-MN3HYFJK.js

@@ -1,442 +0,0 @@
-import {
-  AbiTypes,
-  StaticAbiTypes,
-  getDuplicates,
-  parseStaticArray,
-  validateBaseRoute,
-  validateCapitalizedName,
-  validateEnum,
-  validateEthereumAddress,
-  validateName,
-  validateRoute,
-  validateSelector,
-  validateSingleLevelRoute,
-  validateUncapitalizedName
-} from "./chunk-KPBNUPK6.js";
-
-// src/config/commonSchemas.ts
-import { z } from "zod";
-var zObjectName = z.string().superRefine(validateCapitalizedName);
-var zValueName = z.string().superRefine(validateUncapitalizedName);
-var zAnyCaseName = z.string().superRefine(validateName);
-var zUserEnum = z.array(zObjectName).superRefine(validateEnum);
-var zOrdinaryRoute = z.string().superRefine(validateRoute);
-var zSingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
-var zBaseRoute = z.string().superRefine(validateBaseRoute);
-var zEthereumAddress = z.string().superRefine(validateEthereumAddress);
-var zSelector = z.string().superRefine(validateSelector);
-
-// src/config/loadConfig.ts
-import { findUp } from "find-up";
-import path from "path";
-
-// src/utils/errors.ts
-import chalk from "chalk";
-import { z as z2, ZodError, ZodIssueCode } from "zod";
-import { fromZodError, ValidationError } from "zod-validation-error";
-function fromZodErrorCustom(error, prefix) {
-  return fromZodError(error, {
-    prefix: chalk.red(prefix),
-    prefixSeparator: "\n- ",
-    issueSeparator: "\n- "
-  });
-}
-var NotInsideProjectError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "NotInsideProjectError";
-    this.message = "You are not inside a MUD project";
-  }
-};
-var MUDError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "MUDError";
-  }
-};
-function UnrecognizedSystemErrorFactory(path2, systemName) {
-  return new z2.ZodError([{ code: ZodIssueCode.custom, path: path2, message: `Unrecognized system: "${systemName}"` }]);
-}
-function logError(error) {
-  if (error instanceof ValidationError) {
-    console.log(chalk.redBright(error.message));
-  } else if (error instanceof ZodError) {
-    const validationError = fromZodError(error, {
-      prefixSeparator: "\n- ",
-      issueSeparator: "\n- "
-    });
-    console.log(chalk.redBright(validationError.message));
-  } else if (error instanceof NotInsideProjectError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    console.log(chalk.blue(`To learn more about MUD's configuration, please go to https://mud.dev/packages/cli/`));
-  } else if (error instanceof MUDError) {
-    console.log(chalk.red(error));
-  } else {
-    console.log(error);
-  }
-}
-
-// src/config/loadConfig.ts
-import esbuild from "esbuild";
-import { rmSync } from "fs";
-var configFiles = ["mud.config.js", "mud.config.mjs", "mud.config.ts", "mud.config.mts"];
-var TEMP_CONFIG = "mud.config.temp.mjs";
-async function loadConfig(configPath) {
-  configPath = await resolveConfigPath(configPath);
-  try {
-    await esbuild.build({ entryPoints: [configPath], format: "esm", outfile: TEMP_CONFIG });
-    configPath = await resolveConfigPath(TEMP_CONFIG);
-    return (await import(configPath)).default;
-  } finally {
-    rmSync(TEMP_CONFIG);
-  }
-}
-async function resolveConfigPath(configPath) {
-  if (configPath === void 0) {
-    configPath = await getUserConfigPath();
-  } else {
-    if (!path.isAbsolute(configPath)) {
-      configPath = path.join(process.cwd(), configPath);
-      configPath = path.normalize(configPath);
-    }
-  }
-  return configPath;
-}
-async function getUserConfigPath() {
-  const tsConfigPath = await findUp(configFiles);
-  if (tsConfigPath === void 0) {
-    throw new NotInsideProjectError();
-  }
-  return tsConfigPath;
-}
-
-// src/config/loadStoreConfig.ts
-import { ZodError as ZodError2 } from "zod";
-
-// src/config/parseStoreConfig.ts
-import { z as z3, ZodIssueCode as ZodIssueCode2 } from "zod";
-var zTableName = zObjectName;
-var zKeyName = zValueName;
-var zColumnName = zValueName;
-var zUserEnumName = zObjectName;
-var zFieldData = z3.string();
-var zPrimaryKey = z3.string();
-var zPrimaryKeys = z3.record(zKeyName, zPrimaryKey).default({ key: "bytes32" });
-var zFullSchemaConfig = z3.record(zColumnName, zFieldData).refine((arg) => Object.keys(arg).length > 0, "Table schema may not be empty");
-var zShorthandSchemaConfig = zFieldData.transform((fieldData) => {
-  return zFullSchemaConfig.parse({
-    value: fieldData
-  });
-});
-var zSchemaConfig = zFullSchemaConfig.or(zShorthandSchemaConfig);
-var zFullTableConfig = z3.object({
-  directory: z3.string().default("tables"),
-  fileSelector: zSelector.optional(),
-  tableIdArgument: z3.boolean().default(false),
-  storeArgument: z3.boolean().default(true),
-  primaryKeys: zPrimaryKeys,
-  schema: zSchemaConfig,
-  dataStruct: z3.boolean().optional()
-}).transform((arg) => {
-  if (Object.keys(arg.schema).length === 1) {
-    arg.dataStruct ??= false;
-  } else {
-    arg.dataStruct ??= true;
-  }
-  return arg;
-});
-var zShorthandTableConfig = zFieldData.transform((fieldData) => {
-  return zFullTableConfig.parse({
-    schema: {
-      value: fieldData
-    }
-  });
-});
-var zTableConfig = zFullTableConfig.or(zShorthandTableConfig);
-var zTablesConfig = z3.record(zTableName, zTableConfig).transform((tables) => {
-  for (const tableName of Object.keys(tables)) {
-    const table = tables[tableName];
-    table.fileSelector ??= tableName;
-    tables[tableName] = table;
-  }
-  return tables;
-});
-var zEnumsConfig = z3.object({
-  enums: z3.record(zUserEnumName, zUserEnum).default({})
-});
-function storeConfig(config) {
-  return config;
-}
-var StoreConfigUnrefined = z3.object({
-  namespace: zSelector.default(""),
-  storeImportPath: z3.string().default("@latticexyz/store/src/"),
-  tables: zTablesConfig,
-  userTypesPath: z3.string().default("Types"),
-  codegenDirectory: z3.string().default("codegen")
-}).merge(zEnumsConfig);
-var zStoreConfig = StoreConfigUnrefined.superRefine(validateStoreConfig);
-function parseStoreConfig(config) {
-  return zStoreConfig.parse(config);
-}
-function validateStoreConfig(config, ctx) {
-  for (const table of Object.values(config.tables)) {
-    const primaryKeyNames = Object.keys(table.primaryKeys);
-    const fieldNames = Object.keys(table.schema);
-    const duplicateVariableNames = getDuplicates([...primaryKeyNames, ...fieldNames]);
-    if (duplicateVariableNames.length > 0) {
-      ctx.addIssue({
-        code: ZodIssueCode2.custom,
-        message: `Field and primary key names within one table must be unique: ${duplicateVariableNames.join(", ")}`
-      });
-    }
-  }
-  const tableNames = Object.keys(config.tables);
-  const staticUserTypeNames = Object.keys(config.enums);
-  const userTypeNames = staticUserTypeNames;
-  const globalNames = [...tableNames, ...userTypeNames];
-  const duplicateGlobalNames = getDuplicates(globalNames);
-  if (duplicateGlobalNames.length > 0) {
-    ctx.addIssue({
-      code: ZodIssueCode2.custom,
-      message: `Table, enum names must be globally unique: ${duplicateGlobalNames.join(", ")}`
-    });
-  }
-  for (const table of Object.values(config.tables)) {
-    for (const primaryKeyType of Object.values(table.primaryKeys)) {
-      validateStaticAbiOrUserType(staticUserTypeNames, primaryKeyType, ctx);
-    }
-    for (const fieldType of Object.values(table.schema)) {
-      validateAbiOrUserType(userTypeNames, staticUserTypeNames, fieldType, ctx);
-    }
-  }
-}
-function validateAbiOrUserType(userTypeNames, staticUserTypeNames, type, ctx) {
-  if (!AbiTypes.includes(type) && !userTypeNames.includes(type)) {
-    const staticArray = parseStaticArray(type);
-    if (staticArray) {
-      validateStaticArray(staticUserTypeNames, staticArray.elementType, staticArray.staticLength, ctx);
-    } else {
-      ctx.addIssue({
-        code: ZodIssueCode2.custom,
-        message: `${type} is not a valid abi type, and is not defined in userTypes`
-      });
-    }
-  }
-}
-function validateStaticAbiOrUserType(staticUserTypeNames, type, ctx) {
-  if (!StaticAbiTypes.includes(type) && !staticUserTypeNames.includes(type)) {
-    ctx.addIssue({
-      code: ZodIssueCode2.custom,
-      message: `${type} is not a static type`
-    });
-  }
-}
-function validateStaticArray(staticUserTypeNames, elementType, staticLength, ctx) {
-  validateStaticAbiOrUserType(staticUserTypeNames, elementType, ctx);
-  if (staticLength === 0) {
-    ctx.addIssue({
-      code: ZodIssueCode2.custom,
-      message: `Static array length must not be 0`
-    });
-  } else if (staticLength >= 2 ** 16) {
-    ctx.addIssue({
-      code: ZodIssueCode2.custom,
-      message: `Static array length must be less than 2**16`
-    });
-  }
-}
-
-// src/config/loadStoreConfig.ts
-async function loadStoreConfig(configPath) {
-  const config = await loadConfig(configPath);
-  try {
-    return parseStoreConfig(config);
-  } catch (error) {
-    if (error instanceof ZodError2) {
-      throw fromZodErrorCustom(error, "StoreConfig Validation Error");
-    } else {
-      throw error;
-    }
-  }
-}
-
-// src/config/world/loadWorldConfig.ts
-import { ZodError as ZodError3 } from "zod";
-
-// src/config/world/parseWorldConfig.ts
-import { z as z4 } from "zod";
-
-// src/config/dynamicResolution.ts
-var DynamicResolutionType = /* @__PURE__ */ ((DynamicResolutionType2) => {
-  DynamicResolutionType2[DynamicResolutionType2["TABLE_ID"] = 0] = "TABLE_ID";
-  DynamicResolutionType2[DynamicResolutionType2["SYSTEM_ADDRESS"] = 1] = "SYSTEM_ADDRESS";
-  return DynamicResolutionType2;
-})(DynamicResolutionType || {});
-function resolveTableId(tableName) {
-  return {
-    type: 0 /* TABLE_ID */,
-    input: tableName
-  };
-}
-function isDynamicResolution(value) {
-  return typeof value === "object" && value !== null && "type" in value && "input" in value;
-}
-async function resolveWithContext(unresolved, context) {
-  if (!isDynamicResolution(unresolved))
-    return unresolved;
-  let resolved = void 0;
-  if (unresolved.type === 0 /* TABLE_ID */) {
-    const tableId = context.tableIds?.[unresolved.input];
-    resolved = tableId && { value: tableId, type: "bytes32" };
-  }
-  if (resolved === void 0) {
-    throw new MUDError(`Could not resolve dynamic resolution: 
-${JSON.stringify(unresolved, null, 2)}`);
-  }
-  return resolved;
-}
-
-// src/config/world/parseWorldConfig.ts
-var zSystemName = zObjectName;
-var zModuleName = zObjectName;
-var zSystemAccessList = z4.array(zSystemName.or(zEthereumAddress)).default([]);
-var zSystemConfig = z4.intersection(
-  z4.object({
-    fileSelector: zSelector,
-    registerFunctionSelectors: z4.boolean().default(true)
-  }),
-  z4.discriminatedUnion("openAccess", [
-    z4.object({
-      openAccess: z4.literal(true)
-    }),
-    z4.object({
-      openAccess: z4.literal(false),
-      accessList: zSystemAccessList
-    })
-  ])
-);
-var zValueWithType = z4.object({
-  value: z4.union([z4.string(), z4.number(), z4.instanceof(Uint8Array)]),
-  type: z4.string()
-});
-var zDynamicResolution = z4.object({ type: z4.nativeEnum(DynamicResolutionType), input: z4.string() });
-var zModuleConfig = z4.object({
-  name: zModuleName,
-  root: z4.boolean().default(false),
-  args: z4.array(z4.union([zValueWithType, zDynamicResolution])).default([])
-});
-var zWorldConfig = z4.object({
-  namespace: zSelector.default(""),
-  worldContractName: z4.string().optional(),
-  worldInterfaceName: z4.string().default("IWorld"),
-  overrideSystems: z4.record(zSystemName, zSystemConfig).default({}),
-  excludeSystems: z4.array(zSystemName).default([]),
-  postDeployScript: z4.string().default("PostDeploy"),
-  deploysDirectory: z4.string().default("./deploys"),
-  worldgenDirectory: z4.string().default("world"),
-  worldImportPath: z4.string().default("@latticexyz/world/src/"),
-  modules: z4.array(zModuleConfig).default([])
-});
-async function parseWorldConfig(config) {
-  return zWorldConfig.parse(config);
-}
-
-// src/config/world/resolveWorldConfig.ts
-function resolveWorldConfig(config, existingContracts) {
-  const defaultSystemNames = existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !name.match(/^I[A-Z]/)) ?? [];
-  const overriddenSystemNames = Object.keys(config.overrideSystems);
-  if (existingContracts) {
-    for (const systemName of overriddenSystemNames) {
-      if (!existingContracts.includes(systemName) || systemName === "World") {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
-      }
-    }
-  }
-  const systemNames = [.../* @__PURE__ */ new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
-    (name) => !config.excludeSystems.includes(name)
-  );
-  const resolvedSystems = systemNames.reduce((acc, systemName) => {
-    return {
-      ...acc,
-      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts)
-    };
-  }, {});
-  const { overrideSystems, excludeSystems, ...otherConfig } = config;
-  return { ...otherConfig, systems: resolvedSystems };
-}
-function resolveSystemConfig(systemName, config, existingContracts) {
-  const fileSelector = config?.fileSelector ?? systemName;
-  const registerFunctionSelectors = config?.registerFunctionSelectors ?? true;
-  const openAccess = config?.openAccess ?? true;
-  const accessListAddresses = [];
-  const accessListSystems = [];
-  const accessList = config && !config.openAccess ? config.accessList : [];
-  for (const accessListItem of accessList) {
-    if (accessListItem.startsWith("0x")) {
-      accessListAddresses.push(accessListItem);
-    } else {
-      if (existingContracts && !existingContracts.includes(accessListItem)) {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
-      }
-      accessListSystems.push(accessListItem);
-    }
-  }
-  return { fileSelector, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
-}
-
-// src/config/world/loadWorldConfig.ts
-async function loadWorldConfig(configPath, existingContracts) {
-  const config = await loadConfig(configPath);
-  try {
-    const parsedConfig = zWorldConfig.parse(config);
-    return resolveWorldConfig(parsedConfig, existingContracts);
-  } catch (error) {
-    if (error instanceof ZodError3) {
-      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
-    } else {
-      throw error;
-    }
-  }
-}
-
-// src/config/index.ts
-function mudConfig(config) {
-  return config;
-}
-
-export {
-  fromZodErrorCustom,
-  NotInsideProjectError,
-  MUDError,
-  UnrecognizedSystemErrorFactory,
-  logError,
-  loadConfig,
-  zObjectName,
-  zValueName,
-  zAnyCaseName,
-  zUserEnum,
-  zOrdinaryRoute,
-  zSingleLevelRoute,
-  zBaseRoute,
-  zEthereumAddress,
-  zSelector,
-  zSchemaConfig,
-  zTableConfig,
-  zTablesConfig,
-  zEnumsConfig,
-  storeConfig,
-  zStoreConfig,
-  parseStoreConfig,
-  loadStoreConfig,
-  DynamicResolutionType,
-  resolveTableId,
-  isDynamicResolution,
-  resolveWithContext,
-  zWorldConfig,
-  parseWorldConfig,
-  resolveWorldConfig,
-  resolveSystemConfig,
-  loadWorldConfig,
-  mudConfig
-};