@latticexyz/cli 2.0.0-alpha.68 → 2.0.0-alpha.7

package/src/utils/errors.ts

@@ -1,28 +1,8 @@
 import chalk from "chalk";
-import { z, ZodError, ZodIssueCode } from "zod";
+import { ZodError } from "zod";
 import { fromZodError, ValidationError } from "zod-validation-error";
-
-// Wrapper with preset styles, only requires a `prefix`
-export function fromZodErrorCustom(error: ZodError, prefix: string) {
-  return fromZodError(error, {
-    prefix: chalk.red(prefix),
-    prefixSeparator: "\n- ",
-    issueSeparator: "\n- ",
-  });
-}
-
-export class NotInsideProjectError extends Error {
-  name = "NotInsideProjectError";
-  message = "You are not inside a MUD project";
-}
-
-export class MUDError extends Error {
-  name = "MUDError";
-}
-
-export function UnrecognizedSystemErrorFactory(path: string[], systemName: string) {
-  return new z.ZodError([{ code: ZodIssueCode.custom, path: path, message: `Unrecognized system: "${systemName}"` }]);
-}
+import { NotInsideProjectError } from "@latticexyz/config";
+import { MUDError } from "@latticexyz/config";
 
 export function logError(error: unknown) {
   if (error instanceof ValidationError) {

package/dist/chunk-5NC2OON2.js

@@ -1,164 +0,0 @@
-import {
-  AbiTypeToSchemaType,
-  SchemaType,
-  SchemaTypeToAbiType,
-  getStaticByteLength,
-  parseStaticArray
-} from "./chunk-KPBNUPK6.js";
-
-// src/render-solidity/userType.ts
-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 {
-  resolveAbiOrUserType,
-  importForAbiOrUserType,
-  getSchemaTypeInfo,
-  getUserTypeInfo,
-  formatSolidity,
-  formatTypescript,
-  formatAndWriteSolidity,
-  formatAndWriteTypescript
-};