@latticexyz/cli 1.40.0 → 1.41.1-alpha.0

package/dist/chunk-JNGSW4AP.js

@@ -1,493 +0,0 @@
-import {
-  SchemaType,
-  SchemaTypeArrayToElement,
-  SchemaTypeId,
-  getStaticByteLength
-} from "./chunk-6AQ6LFVZ.js";
-
-// src/render-table/common.ts
-function renderList(list, renderItem) {
-  return internalRenderList("", list, renderItem);
-}
-function renderArguments(args) {
-  const filteredArgs = args.filter((arg) => arg !== void 0 && arg !== "");
-  return internalRenderList(",", filteredArgs, (arg) => arg);
-}
-function renderCommonData({ staticRouteData, primaryKeys }) {
-  const _tableId = staticRouteData ? "" : "_tableId";
-  const _typedTableId = staticRouteData ? "" : "uint256 _tableId";
-  const _keyArgs = renderArguments(primaryKeys.map(({ name }) => name));
-  const _typedKeyArgs = renderArguments(primaryKeys.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  const _primaryKeysDefinition = `
-    bytes32[] memory _primaryKeys = new bytes32[](${primaryKeys.length});
-    ${renderList(
-    primaryKeys,
-    ({ name, typeId, staticByteLength }, index) => `
-    _primaryKeys[${index}] = ${renderValueTypeToBytes32(name, typeId, staticByteLength)};
-    `
-  )}
-  `;
-  return {
-    _tableId,
-    _typedTableId,
-    _keyArgs,
-    _typedKeyArgs,
-    _primaryKeysDefinition
-  };
-}
-function renderValueTypeToBytes32(innerText, typeId, staticByteLength) {
-  const bits = staticByteLength * 8;
-  if (typeId.match(/^uint\d{1,3}$/)) {
-    return `bytes32(uint256(${innerText}))`;
-  } else if (typeId.match(/^int\d{1,3}$/)) {
-    return `bytes32(uint256(uint${bits}(${innerText})))`;
-  } else if (typeId.match(/^bytes\d{1,2}$/)) {
-    return `bytes32(${innerText})`;
-  } else if (typeId === "address") {
-    return `bytes32(bytes20(${innerText}))`;
-  } else if (typeId === "bool") {
-    return `_boolToBytes32(${innerText})`;
-  } else {
-    throw new Error(`Unknown value type id ${typeId}`);
-  }
-}
-function internalRenderList(lineTerminator, list, renderItem) {
-  return list.map((item, index) => renderItem(item, index) + (index === list.length - 1 ? "" : lineTerminator)).join("\n");
-}
-
-// src/render-table/field.ts
-function renderFieldMethods(options) {
-  const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-  let result = "";
-  for (const [index, field] of options.fields.entries()) {
-    const _typedFieldName = `${field.typeWithLocation} ${field.name}`;
-    result += `
-    /** Get ${field.name} */
-    function get${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs
-    ])}) internal view returns (${_typedFieldName}) {
-      ${_primaryKeysDefinition}
-      bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-      return ${renderDecodeFieldSingle(field)};
-    }
-    `;
-    if (options.storeArgument) {
-      result += `
-      /** Get ${field.name} from the specified store */
-      function get${field.methodNameSuffix}(${renderArguments([
-        _typedTableId,
-        `IStore _store`,
-        _typedKeyArgs
-      ])}) internal view returns (${_typedFieldName}) {
-        ${_primaryKeysDefinition}
-        bytes memory _blob = _store.getField(_tableId, _primaryKeys, ${index});
-        return ${renderDecodeFieldSingle(field)};
-      }
-      `;
-    }
-    result += `
-    /** Set ${field.name} */
-    function set${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs,
-      _typedFieldName
-    ])}) internal {
-      ${_primaryKeysDefinition}
-      StoreSwitch.setField(_tableId, _primaryKeys, ${index}, ${renderEncodeField(field)});
-    }
-    `;
-    if (field.isDynamic) {
-      const portionData = fieldPortionData(field);
-      result += `
-      /** Push ${portionData.title} to ${field.name} */
-      function push${field.methodNameSuffix}(${renderArguments([
-        _typedTableId,
-        _typedKeyArgs,
-        `${portionData.typeWithLocation} ${portionData.name}`
-      ])}) internal {
-        ${_primaryKeysDefinition}
-        bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-        bytes memory _newBlob = abi.encodePacked(_blob, ${portionData.encodeFunc}(${portionData.name}));
-        StoreSwitch.setField(_tableId, _primaryKeys, ${index}, _newBlob);
-      }
-      `;
-    }
-  }
-  return result;
-}
-function renderEncodeField(field) {
-  let func;
-  if (field.arrayElement) {
-    func = "EncodeArray.encode";
-  } else if (field.isDynamic) {
-    func = "bytes";
-  } else {
-    func = "abi.encodePacked";
-  }
-  return `${func}(${field.name})`;
-}
-function renderDecodeValueType(typeId, staticByteLength, offset) {
-  const innerSlice = `Bytes.slice${staticByteLength}(_blob, ${offset})`;
-  const bits = staticByteLength * 8;
-  if (typeId.match(/^uint\d{1,3}$/) || typeId === "address") {
-    return `${typeId}(${innerSlice})`;
-  } else if (typeId.match(/^int\d{1,3}$/)) {
-    return `${typeId}(uint${bits}(${innerSlice}))`;
-  } else if (typeId.match(/^bytes\d{1,2}$/)) {
-    return innerSlice;
-  } else if (typeId === "bool") {
-    return `_toBool(uint8(${innerSlice}))`;
-  } else {
-    throw new Error(`Unknown value type id ${typeId}`);
-  }
-}
-function fieldPortionData(field) {
-  if (field.arrayElement) {
-    return {
-      typeWithLocation: field.arrayElement.typeWithLocation,
-      name: "_element",
-      encodeFunc: "abi.encodePacked",
-      title: "an element"
-    };
-  } else {
-    return {
-      typeWithLocation: `${field.typeId} memory`,
-      name: "_slice",
-      encodeFunc: "bytes",
-      title: "a slice"
-    };
-  }
-}
-function renderDecodeFieldSingle(field) {
-  const { typeId, isDynamic, arrayElement } = field;
-  if (arrayElement) {
-    return `SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.typeId}()`;
-  } else if (isDynamic) {
-    return `${typeId}(_blob)`;
-  } else {
-    return renderDecodeValueType(typeId, field.staticByteLength, 0);
-  }
-}
-
-// src/render-table/record.ts
-function renderRecordMethods(options) {
-  const { staticFields, dynamicFields, structName, storeArgument } = options;
-  const { _tableId, _typedTableId, _keyArgs, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-  let result = `
-  /** Get the full data */
-  function get(${renderArguments([_typedTableId, _typedKeyArgs])}) internal view returns (${renderDecodedRecord(
-    options
-  )}) {
-    ${_primaryKeysDefinition}
-    bytes memory _blob = StoreSwitch.getRecord(_tableId, _primaryKeys, getSchema());
-    return decode(_blob);
-  }
-  `;
-  if (storeArgument) {
-    result += `
-    /** Get the full data from the specified store */
-    function get(${renderArguments([
-      _typedTableId,
-      `IStore _store`,
-      _typedKeyArgs
-    ])}) internal view returns (${renderDecodedRecord(options)}) {
-      ${_primaryKeysDefinition}
-      bytes memory _blob = _store.getRecord(_tableId, _primaryKeys);
-      return decode(_blob);
-    }
-    `;
-  }
-  result += `
-  /** Set the full data using individual values */
-  function set(${renderArguments([
-    _typedTableId,
-    _typedKeyArgs,
-    renderArguments(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`))
-  ])}) internal {
-    ${renderEncodedLengths(dynamicFields)}
-    bytes memory _data = abi.encodePacked(${renderArguments([
-    renderArguments(staticFields.map(({ name }) => name)),
-    // TODO try gas optimization (preallocate for all, encodePacked statics, and direct encode dynamics)
-    // (see https://github.com/latticexyz/mud/issues/444)
-    ...dynamicFields.length === 0 ? [] : ["_encodedLengths.unwrap()", renderArguments(dynamicFields.map((field) => renderEncodeField(field)))]
-  ])});
-
-    ${_primaryKeysDefinition}
-
-    StoreSwitch.setRecord(_tableId, _primaryKeys, _data);
-  }
-  `;
-  if (structName !== void 0) {
-    result += `
-    /** Set the full data using the data struct */
-    function set(${renderArguments([_typedTableId, _typedKeyArgs, `${structName} memory _table`])}) internal {
-      set(${renderArguments([
-      _tableId,
-      _keyArgs,
-      renderArguments(options.fields.map(({ name }) => `_table.${name}`))
-    ])});
-    }
-    `;
-  }
-  result += renderDecodeFunction(options);
-  return result;
-}
-function renderDecodeFunction({ structName, fields, staticFields, dynamicFields }) {
-  const renderedDecodedRecord = structName ? `${structName} memory _table` : renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  const fieldNamePrefix = structName ? "_table." : "";
-  const staticOffsets = staticFields.map(() => 0);
-  let _acc = 0;
-  for (const [index, field] of staticFields.entries()) {
-    staticOffsets[index] = _acc;
-    _acc += field.staticByteLength;
-  }
-  if (dynamicFields.length > 0) {
-    const totalStaticLength = staticFields.reduce((acc, { staticByteLength }) => acc + staticByteLength, 0);
-    return `
-    /** Decode the tightly packed blob using this table's schema */
-    function decode(bytes memory _blob) internal view returns (${renderedDecodedRecord}) {
-      // ${totalStaticLength} is the total byte length of static data
-      PackedCounter _encodedLengths = PackedCounter.wrap(Bytes.slice32(_blob, ${totalStaticLength})); 
-
-      ${renderList(
-      staticFields,
-      (field, index) => `
-        ${fieldNamePrefix}${field.name} = ${renderDecodeStaticFieldPartial(field, staticOffsets[index])};
-        `
-    )}
-      uint256 _start;
-      uint256 _end = ${totalStaticLength + 32};
-      ${renderList(
-      dynamicFields,
-      (field, index) => `
-        _start = _end;
-        _end += _encodedLengths.atIndex(${index});
-        ${fieldNamePrefix}${field.name} = ${renderDecodeDynamicFieldPartial(field)};
-        `
-    )}
-    }
-  `;
-  } else {
-    return `
-    /** Decode the tightly packed blob using this table's schema */
-    function decode(bytes memory _blob) internal pure returns (${renderedDecodedRecord}) {
-      ${renderList(
-      staticFields,
-      (field, index) => `
-        ${fieldNamePrefix}${field.name} = ${renderDecodeStaticFieldPartial(field, staticOffsets[index])};
-        `
-    )}
-    }
-    `;
-  }
-}
-function renderDecodedRecord({ structName, fields }) {
-  if (structName) {
-    return `${structName} memory _table`;
-  } else {
-    return renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  }
-}
-function renderDecodeDynamicFieldPartial(field) {
-  const { typeId, arrayElement } = field;
-  if (arrayElement) {
-    return `SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()`;
-  } else {
-    return `${typeId}(SliceLib.getSubslice(_blob, _start, _end).toBytes())`;
-  }
-}
-function renderDecodeStaticFieldPartial(field, start) {
-  const { typeId, staticByteLength } = field;
-  return renderDecodeValueType(typeId, staticByteLength, start);
-}
-function renderEncodedLengths(dynamicFields) {
-  if (dynamicFields.length > 0) {
-    return `
-    uint16[] memory _counters = new uint16[](${dynamicFields.length});
-    ${renderList(dynamicFields, ({ name, arrayElement }, index) => {
-      if (arrayElement) {
-        return `_counters[${index}] = uint16(${name}.length * ${arrayElement.staticByteLength});`;
-      } else {
-        return `_counters[${index}] = uint16(bytes(${name}).length);`;
-      }
-    })}
-    PackedCounter _encodedLengths = PackedCounterLib.pack(_counters);
-    `;
-  } else {
-    return "";
-  }
-}
-
-// src/render-table/renderTable.ts
-function renderTable(options) {
-  const { libraryName, structName, staticRouteData, storeImportPath, fields, withRecordMethods } = options;
-  const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-  return `// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.0;
-
-/* Autogenerated file. Do not edit manually. */
-
-import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
-
-import { IStore } from "${storeImportPath}IStore.sol";
-import { StoreSwitch } from "${storeImportPath}StoreSwitch.sol";
-import { StoreCore } from "${storeImportPath}StoreCore.sol";
-import { Bytes } from "${storeImportPath}Bytes.sol";
-import { SliceLib } from "${storeImportPath}Slice.sol";
-import { EncodeArray } from "${storeImportPath}tightcoder/EncodeArray.sol";
-import { Schema, SchemaLib } from "${storeImportPath}Schema.sol";
-import { PackedCounter, PackedCounterLib } from "${storeImportPath}PackedCounter.sol";
-
-${!staticRouteData ? "" : `
-  uint256 constant _tableId = uint256(keccak256("${staticRouteData.baseRoute + staticRouteData.subRoute}"));
-  uint256 constant ${staticRouteData.tableIdName} = _tableId;
-`}
-
-${!structName ? "" : `
-  struct ${structName} {
-    ${renderList(fields, ({ name, typeId }) => `${typeId} ${name};`)}
-  }
-`}
-
-library ${libraryName} {
-  /** Get the table's schema */
-  function getSchema() internal pure returns (Schema) {
-    SchemaType[] memory _schema = new SchemaType[](${fields.length});
-    ${renderList(fields, ({ enumName }, index) => `_schema[${index}] = SchemaType.${enumName};`)}
-
-    return SchemaLib.encode(_schema);
-  }
-
-  /** Register the table's schema */
-  function registerSchema(${_typedTableId}) internal {
-    StoreSwitch.registerSchema(_tableId, getSchema());
-  }
-
-${!options.storeArgument ? "" : `
-  /** Register the table's schema for the specified store */
-  function registerSchema(${renderArguments([_typedTableId, "IStore _store"])}) internal {
-    _store.registerSchema(_tableId, getSchema());
-  }
-`}
-
-${renderFieldMethods(options)}
-
-${withRecordMethods ? renderRecordMethods(options) : ""}
-
-  /* Delete all data for given keys */
-  function deleteRecord(${renderArguments([_typedTableId, _typedKeyArgs])}) internal {
-    ${_primaryKeysDefinition}
-    StoreSwitch.deleteRecord(_tableId, _primaryKeys);
-  }
-}
-
-${// nothing can be cast to bool, so an assembly helper is required
-  !fields.some(({ typeId }) => typeId === "bool") ? "" : `
-  function _toBool(uint8 value) pure returns (bool result) {
-    assembly {
-      result := value
-    }
-  }
-`}
-
-${// nothing can be cast from bool, so an assembly helper is required
-  !options.primaryKeys.some(({ typeId }) => typeId === "bool") ? "" : `
-  function _boolToBytes32(bool value) pure returns (bytes32 result) {
-    assembly {
-      result := value
-    }
-  }
-`}
-
-`;
-}
-
-// src/render-table/renderTablesFromConfig.ts
-function renderTablesFromConfig(config) {
-  const storeImportPath = config.storeImportPath;
-  const renderedTables = [];
-  for (const tableName of Object.keys(config.tables)) {
-    const tableData = config.tables[tableName];
-    const withStruct = tableData.dataStruct;
-    const withRecordMethods = withStruct || Object.keys(tableData.schema).length > 1;
-    const noFieldMethodSuffix = !withRecordMethods && Object.keys(tableData.schema).length === 1;
-    const primaryKeys = Object.keys(tableData.primaryKeys).map((name) => {
-      const type = tableData.primaryKeys[name];
-      const typeInfo = getSchemaTypeInfo(type);
-      if (typeInfo.isDynamic)
-        throw new Error("Parsing error: found dynamic primary key");
-      const primaryKey = {
-        ...typeInfo,
-        name,
-        isDynamic: false
-      };
-      return primaryKey;
-    });
-    const fields = Object.keys(tableData.schema).map((name) => {
-      const type = tableData.schema[name];
-      const elementType = SchemaTypeArrayToElement[type];
-      const field = {
-        ...getSchemaTypeInfo(type),
-        arrayElement: elementType ? getSchemaTypeInfo(elementType) : void 0,
-        name,
-        methodNameSuffix: noFieldMethodSuffix ? "" : `${name[0].toUpperCase()}${name.slice(1)}`
-      };
-      return field;
-    });
-    const staticFields = fields.filter(({ isDynamic }) => !isDynamic);
-    const dynamicFields = fields.filter(({ isDynamic }) => isDynamic);
-    const staticRouteData = (() => {
-      if (tableData.tableIdArgument) {
-        return;
-      } else {
-        return {
-          tableIdName: tableName + "TableId",
-          baseRoute: config.baseRoute + tableData.route,
-          subRoute: `/${tableName}`
-        };
-      }
-    })();
-    renderedTables.push({
-      tableName,
-      tableData,
-      output: renderTable({
-        libraryName: tableName,
-        structName: withStruct ? tableName + "Data" : void 0,
-        staticRouteData,
-        storeImportPath,
-        primaryKeys,
-        fields,
-        staticFields,
-        dynamicFields,
-        withRecordMethods,
-        storeArgument: tableData.storeArgument
-      })
-    });
-  }
-  return renderedTables;
-}
-function getSchemaTypeInfo(schemaType) {
-  const staticByteLength = getStaticByteLength(schemaType);
-  const isDynamic = staticByteLength === 0;
-  const typeId = SchemaTypeId[schemaType];
-  return {
-    typeId,
-    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
-    enumName: SchemaType[schemaType],
-    staticByteLength,
-    isDynamic
-  };
-}
-
-export {
-  renderList,
-  renderArguments,
-  renderCommonData,
-  renderFieldMethods,
-  renderEncodeField,
-  renderDecodeValueType,
-  renderRecordMethods,
-  renderTable,
-  renderTablesFromConfig
-};

package/dist/chunk-PJ6GS2R4.js

@@ -1,22 +0,0 @@
-// src/utils/forgeConfig.ts
-import { execa } from "execa";
-async function getForgeConfig() {
-  const { stdout } = await execa("forge", ["config", "--json"], { stdio: ["inherit", "pipe", "pipe"] });
-  return JSON.parse(stdout);
-}
-async function getSrcDirectory() {
-  return (await getForgeConfig()).src;
-}
-async function getTestDirectory() {
-  return (await getForgeConfig()).test;
-}
-async function getOutDirectory() {
-  return (await getForgeConfig()).out;
-}
-
-export {
-  getForgeConfig,
-  getSrcDirectory,
-  getTestDirectory,
-  getOutDirectory
-};

package/dist/chunk-UC3QPOON.js

@@ -1,35 +0,0 @@
-// 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;
-  }
-}
-
-export {
-  formatSolidity
-};