@latticexyz/cli 2.0.0-alpha.0 → 2.0.0-alpha.1

package/dist/chunk-WZFXLDPK.js

@@ -0,0 +1,761 @@
+import {
+  SchemaTypeArrayToElement,
+  formatAndWriteSolidity,
+  getSchemaTypeInfo,
+  importForAbiOrUserType,
+  resolveAbiOrUserType
+} from "./chunk-SKNB74MT.js";
+
+// src/render-solidity/tableOptions.ts
+import path from "path";
+function getTableOptions(config) {
+  const storeImportPath = config.storeImportPath;
+  const options = [];
+  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 imports = [];
+    const primaryKeys = Object.keys(tableData.primaryKeys).map((name) => {
+      const abiOrUserType = tableData.primaryKeys[name];
+      const { renderTableType } = resolveAbiOrUserType(abiOrUserType, config);
+      const importDatum = importForAbiOrUserType(abiOrUserType, tableData.directory, config);
+      if (importDatum)
+        imports.push(importDatum);
+      if (renderTableType.isDynamic)
+        throw new Error(`Parsing error: found dynamic primary key ${name} in table ${tableName}`);
+      const primaryKey = {
+        ...renderTableType,
+        name,
+        isDynamic: false
+      };
+      return primaryKey;
+    });
+    const fields = Object.keys(tableData.schema).map((name) => {
+      const abiOrUserType = tableData.schema[name];
+      const { renderTableType, schemaType } = resolveAbiOrUserType(abiOrUserType, config);
+      const importDatum = importForAbiOrUserType(abiOrUserType, tableData.directory, config);
+      if (importDatum)
+        imports.push(importDatum);
+      const elementType = SchemaTypeArrayToElement[schemaType];
+      const field = {
+        ...renderTableType,
+        arrayElement: elementType !== void 0 ? 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 staticResourceData = (() => {
+      if (tableData.tableIdArgument) {
+        return;
+      } else {
+        return {
+          tableIdName: tableName + "TableId",
+          namespace: config.namespace,
+          name: tableData.name
+        };
+      }
+    })();
+    options.push({
+      outputPath: path.join(tableData.directory, `${tableName}.sol`),
+      tableName,
+      renderOptions: {
+        imports,
+        libraryName: tableName,
+        structName: withStruct ? tableName + "Data" : void 0,
+        staticResourceData,
+        storeImportPath,
+        primaryKeys,
+        fields,
+        staticFields,
+        dynamicFields,
+        withRecordMethods,
+        storeArgument: tableData.storeArgument
+      }
+    });
+  }
+  return options;
+}
+
+// src/render-solidity/common.ts
+import path2 from "path";
+var renderedSolidityHeader = `// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/* Autogenerated file. Do not edit manually. */`;
+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({
+  staticResourceData,
+  primaryKeys
+}) {
+  const _tableId = staticResourceData ? "" : "_tableId";
+  const _typedTableId = staticResourceData ? "" : "bytes32 _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,
+    (primaryKey, index) => `_primaryKeys[${index}] = ${renderValueTypeToBytes32(primaryKey.name, primaryKey)};`
+  )}
+  `;
+  return {
+    _tableId,
+    _typedTableId,
+    _keyArgs,
+    _typedKeyArgs,
+    _primaryKeysDefinition
+  };
+}
+function solidityRelativeImportPath(fromPath, usedInPath) {
+  return "./" + path2.relative("./" + usedInPath, "./" + fromPath);
+}
+function renderImports(imports) {
+  const aggregatedImports = /* @__PURE__ */ new Map();
+  for (const { symbol, fromPath, usedInPath } of imports) {
+    const path4 = solidityRelativeImportPath(fromPath, usedInPath);
+    if (!aggregatedImports.has(path4)) {
+      aggregatedImports.set(path4, /* @__PURE__ */ new Set());
+    }
+    aggregatedImports.get(path4)?.add(symbol);
+  }
+  const renderedImports = [];
+  for (const [path4, symbols] of aggregatedImports) {
+    const renderedSymbols = [...symbols].join(", ");
+    renderedImports.push(`import { ${renderedSymbols} } from "${path4}";`);
+  }
+  return renderedImports.join("\n");
+}
+function renderWithStore(storeArgument, callback) {
+  let result = "";
+  result += callback(void 0, "StoreSwitch", "", void 0);
+  if (storeArgument) {
+    result += "\n" + callback("IStore _store", "_store", " (using the specified store)", "_store");
+  }
+  return result;
+}
+function renderTableId(staticResourceData) {
+  const hardcodedTableId = `bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.name}")))`;
+  const tableIdDefinition = `
+    bytes32 constant _tableId = ${hardcodedTableId};
+    bytes32 constant ${staticResourceData.tableIdName} = _tableId;
+  `;
+  return {
+    hardcodedTableId,
+    tableIdDefinition
+  };
+}
+function renderValueTypeToBytes32(name, { staticByteLength, typeUnwrap, internalTypeId }) {
+  const bits = staticByteLength * 8;
+  const innerText = `${typeUnwrap}(${name})`;
+  if (internalTypeId.match(/^uint\d{1,3}$/)) {
+    return `bytes32(uint256(${innerText}))`;
+  } else if (internalTypeId.match(/^int\d{1,3}$/)) {
+    return `bytes32(uint256(uint${bits}(${innerText})))`;
+  } else if (internalTypeId.match(/^bytes\d{1,2}$/)) {
+    return `bytes32(${innerText})`;
+  } else if (internalTypeId === "address") {
+    return `bytes32(bytes20(${innerText}))`;
+  } else if (internalTypeId === "bool") {
+    return `_boolToBytes32(${innerText})`;
+  } else {
+    throw new Error(`Unknown value type id ${internalTypeId}`);
+  }
+}
+function internalRenderList(lineTerminator, list, renderItem) {
+  return list.map((item, index) => renderItem(item, index) + (index === list.length - 1 ? "" : lineTerminator)).join("\n");
+}
+
+// src/render-solidity/field.ts
+function renderFieldMethods(options) {
+  const storeArgument = options.storeArgument;
+  const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
+  let result = "";
+  for (const [index, field] of options.fields.entries()) {
+    const _typedFieldName = `${field.typeWithLocation} ${field.name}`;
+    result += renderWithStore(
+      storeArgument,
+      (_typedStore, _store, _commentSuffix) => `
+      /** Get ${field.name}${_commentSuffix} */
+      function get${field.methodNameSuffix}(${renderArguments([
+        _typedStore,
+        _typedTableId,
+        _typedKeyArgs
+      ])}) internal view returns (${_typedFieldName}) {
+        ${_primaryKeysDefinition}
+        bytes memory _blob = ${_store}.getField(_tableId, _primaryKeys, ${index});
+        return ${renderDecodeFieldSingle(field)};
+      }
+    `
+    );
+    result += renderWithStore(
+      storeArgument,
+      (_typedStore, _store, _commentSuffix) => `
+      /** Set ${field.name}${_commentSuffix} */
+      function set${field.methodNameSuffix}(${renderArguments([
+        _typedStore,
+        _typedTableId,
+        _typedKeyArgs,
+        _typedFieldName
+      ])}) internal {
+        ${_primaryKeysDefinition}
+        ${_store}.setField(_tableId, _primaryKeys, ${index}, ${renderEncodeField(field)});
+      }
+    `
+    );
+    if (field.isDynamic) {
+      const portionData = fieldPortionData(field);
+      result += renderWithStore(
+        storeArgument,
+        (_typedStore, _store, _commentSuffix) => `
+        /** Push ${portionData.title} to ${field.name}${_commentSuffix} */
+        function push${field.methodNameSuffix}(${renderArguments([
+          _typedStore,
+          _typedTableId,
+          _typedKeyArgs,
+          `${portionData.typeWithLocation} ${portionData.name}`
+        ])}) internal {
+          ${_primaryKeysDefinition}
+          ${_store}.pushToField(_tableId, _primaryKeys, ${index}, ${portionData.encoded});
+        }
+      `
+      );
+      result += renderWithStore(
+        storeArgument,
+        (_typedStore, _store, _commentSuffix) => `
+        /** Update ${portionData.title} of ${field.name}${_commentSuffix} at \`_index\` */
+        function update${field.methodNameSuffix}(${renderArguments([
+          _typedStore,
+          _typedTableId,
+          _typedKeyArgs,
+          "uint256 _index",
+          `${portionData.typeWithLocation} ${portionData.name}`
+        ])}) internal {
+          ${_primaryKeysDefinition}
+          ${_store}.updateInField(
+            _tableId,
+            _primaryKeys,
+            ${index},
+            _index * ${portionData.elementLength},
+            ${portionData.encoded}
+          );
+        }
+      `
+      );
+    }
+  }
+  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.typeUnwrap}(${field.name}))`;
+}
+function renderDecodeValueType(field, offset) {
+  const { staticByteLength, internalTypeId } = field;
+  const innerSlice = `Bytes.slice${staticByteLength}(_blob, ${offset})`;
+  const bits = staticByteLength * 8;
+  let result;
+  if (internalTypeId.match(/^uint\d{1,3}$/) || internalTypeId === "address") {
+    result = `${internalTypeId}(${innerSlice})`;
+  } else if (internalTypeId.match(/^int\d{1,3}$/)) {
+    result = `${internalTypeId}(uint${bits}(${innerSlice}))`;
+  } else if (internalTypeId.match(/^bytes\d{1,2}$/)) {
+    result = innerSlice;
+  } else if (internalTypeId === "bool") {
+    result = `_toBool(uint8(${innerSlice}))`;
+  } else {
+    throw new Error(`Unknown value type id ${internalTypeId}`);
+  }
+  return `${field.typeWrap}(${result})`;
+}
+function fieldPortionData(field) {
+  const methodNameSuffix = "";
+  if (field.arrayElement) {
+    const name = "_element";
+    return {
+      typeWithLocation: field.arrayElement.typeWithLocation,
+      name: "_element",
+      encoded: renderEncodeField({ ...field.arrayElement, arrayElement: void 0, name, methodNameSuffix }),
+      title: "an element",
+      elementLength: field.arrayElement.staticByteLength
+    };
+  } else {
+    const name = "_slice";
+    return {
+      typeWithLocation: `${field.typeId} memory`,
+      name,
+      encoded: renderEncodeField({ ...field, name, methodNameSuffix }),
+      title: "a slice",
+      elementLength: 1
+    };
+  }
+}
+function renderDecodeFieldSingle(field) {
+  const { isDynamic, arrayElement } = field;
+  if (arrayElement) {
+    return `${field.typeWrap}(
+      SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.internalTypeId}()
+    )`;
+  } else if (isDynamic) {
+    return `${field.typeWrap}(${field.internalTypeId}(_blob))`;
+  } else {
+    return renderDecodeValueType(field, 0);
+  }
+}
+
+// src/render-solidity/record.ts
+function renderRecordMethods(options) {
+  const { structName, storeArgument } = options;
+  const { _tableId, _typedTableId, _keyArgs, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
+  let result = renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Get the full data${_commentSuffix} */
+    function get(${renderArguments([
+      _typedStore,
+      _typedTableId,
+      _typedKeyArgs
+    ])}) internal view returns (${renderDecodedRecord(options)}) {
+      ${_primaryKeysDefinition}
+      bytes memory _blob = ${_store}.getRecord(_tableId, _primaryKeys, getSchema());
+      return decode(_blob);
+    }
+  `
+  );
+  result += renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Set the full data using individual values${_commentSuffix} */
+    function set(${renderArguments([
+      _typedStore,
+      _typedTableId,
+      _typedKeyArgs,
+      renderArguments(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`))
+    ])}) internal {
+      bytes memory _data = encode(${renderArguments(options.fields.map(({ name }) => name))});
+
+      ${_primaryKeysDefinition}
+
+      ${_store}.setRecord(_tableId, _primaryKeys, _data);
+    }
+  `
+  );
+  if (structName !== void 0) {
+    result += renderWithStore(
+      storeArgument,
+      (_typedStore, _store, _commentSuffix, _untypedStore) => `
+      /** Set the full data using the data struct${_commentSuffix} */
+      function set(${renderArguments([
+        _typedStore,
+        _typedTableId,
+        _typedKeyArgs,
+        `${structName} memory _table`
+      ])}) internal {
+        set(${renderArguments([
+        _untypedStore,
+        _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} = ${renderDecodeValueType(field, staticOffsets[index])};
+        `
+    )}
+      // Store trims the blob if dynamic fields are all empty
+      if (_blob.length > ${totalStaticLength}) {
+        uint256 _start;
+        // skip static data length + dynamic lengths word
+        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} = ${renderDecodeValueType(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, typeWrap } = field;
+  if (arrayElement) {
+    return `${typeWrap}(
+      SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()
+    )`;
+  } else {
+    return `${typeWrap}(
+      ${typeId}(
+        SliceLib.getSubslice(_blob, _start, _end).toBytes()
+      )
+    )`;
+  }
+}
+
+// src/render-solidity/renderTypeHelpers.ts
+function renderTypeHelpers(options) {
+  const { fields, primaryKeys } = options;
+  let result = "";
+  for (const wrappingHelper of getWrappingHelpers([...fields, ...primaryKeys])) {
+    result += wrappingHelper;
+  }
+  if (fields.some(({ typeId }) => typeId === "bool")) {
+    result += `
+    function _toBool(uint8 value) pure returns (bool result) {
+      assembly {
+        result := value
+      }
+    }
+    `;
+  }
+  if (primaryKeys.some(({ typeId }) => typeId === "bool")) {
+    result += `
+    function _boolToBytes32(bool value) pure returns (bytes32 result) {
+      assembly {
+        result := value
+      }
+    }
+    `;
+  }
+  return result;
+}
+function getWrappingHelpers(array) {
+  const wrappers = /* @__PURE__ */ new Map();
+  const unwrappers = /* @__PURE__ */ new Map();
+  for (const { typeWrappingData, typeWrap, typeUnwrap, internalTypeId } of array) {
+    if (!typeWrappingData)
+      continue;
+    const { kind } = typeWrappingData;
+    if (kind === "staticArray") {
+      const { elementType, staticLength } = typeWrappingData;
+      wrappers.set(typeWrap, renderWrapperStaticArray(typeWrap, elementType, staticLength, internalTypeId));
+      unwrappers.set(typeUnwrap, renderUnwrapperStaticArray(typeUnwrap, elementType, staticLength, internalTypeId));
+    }
+  }
+  return [...wrappers.values(), ...unwrappers.values()];
+}
+function renderWrapperStaticArray(functionName, elementType, staticLength, internalTypeId) {
+  return `
+    function ${functionName}(
+      ${internalTypeId} memory _value
+    ) pure returns (
+      ${elementType}[${staticLength}] memory _result
+    ) {
+      // in memory static arrays are just dynamic arrays without the length byte
+      assembly {
+        _result := add(_value, 0x20)
+      }
+    }
+  `;
+}
+function renderUnwrapperStaticArray(functionName, elementType, staticLength, internalTypeId) {
+  const byteLength = staticLength * 32;
+  return `
+    function ${functionName}(
+      ${elementType}[${staticLength}] memory _value
+    ) view returns (
+      ${internalTypeId} memory _result
+    ) {
+      _result = new ${internalTypeId}(${staticLength});
+      uint256 fromPointer;
+      uint256 toPointer;
+      assembly {
+        fromPointer := _value
+        toPointer := add(_result, 0x20)
+      }
+      Memory.copy(fromPointer, toPointer, ${byteLength});
+    }
+  `;
+}
+
+// src/render-solidity/renderTable.ts
+function renderTable(options) {
+  const {
+    imports,
+    libraryName,
+    structName,
+    staticResourceData,
+    storeImportPath,
+    fields,
+    staticFields,
+    dynamicFields,
+    withRecordMethods,
+    storeArgument,
+    primaryKeys
+  } = options;
+  const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
+  return `${renderedSolidityHeader}
+
+// Import schema type
+import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
+
+// Import store internals
+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 { Memory } from "${storeImportPath}Memory.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";
+
+${imports.length > 0 ? `
+      // Import user types
+      ${renderImports(imports)}
+    ` : ""}
+
+${staticResourceData ? renderTableId(staticResourceData).tableIdDefinition : ""}
+
+${!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);
+  }
+
+  function getKeySchema() internal pure returns (Schema) {
+    SchemaType[] memory _schema = new SchemaType[](${primaryKeys.length});
+    ${renderList(primaryKeys, ({ enumName }, index) => `_schema[${index}] = SchemaType.${enumName};`)}
+
+    return SchemaLib.encode(_schema);
+  }
+
+  /** Get the table's metadata */
+  function getMetadata() internal pure returns (string memory, string[] memory) {
+    string[] memory _fieldNames = new string[](${fields.length});
+    ${renderList(fields, (field, index) => `_fieldNames[${index}] = "${field.name}";`)}
+    return ("${libraryName}", _fieldNames);
+  }
+
+  ${renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Register the table's schema${_commentSuffix} */
+    function registerSchema(${renderArguments([_typedStore, _typedTableId])}) internal {
+      ${_store}.registerSchema(_tableId, getSchema(), getKeySchema());
+    }
+  `
+  )}
+  ${renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Set the table's metadata${_commentSuffix} */
+    function setMetadata(${renderArguments([_typedStore, _typedTableId])}) internal {
+      (string memory _tableName, string[] memory _fieldNames) = getMetadata();
+      ${_store}.setMetadata(_tableId, _tableName, _fieldNames);
+    }
+  `
+  )}
+
+  ${renderFieldMethods(options)}
+
+  ${withRecordMethods ? renderRecordMethods(options) : ""}
+
+  /** Tightly pack full data using this table's schema */
+  function encode(${renderArguments(
+    options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
+  )}) internal view returns (bytes memory) {
+    ${renderEncodedLengths(dynamicFields)}
+    return 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)))]
+  ])});
+  }
+
+  ${renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /* Delete all data for given keys${_commentSuffix} */
+    function deleteRecord(${renderArguments([_typedStore, _typedTableId, _typedKeyArgs])}) internal {
+      ${_primaryKeysDefinition}
+      ${_store}.deleteRecord(_tableId, _primaryKeys);
+    }
+  `
+  )}
+}
+
+${renderTypeHelpers(options)}
+
+`;
+}
+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-solidity/renderTypes.ts
+function renderTypes(options) {
+  const { enums } = options;
+  return `${renderedSolidityHeader}
+
+${renderList(
+    enums,
+    ({ name, memberNames }) => `
+  enum ${name} {
+    ${renderArguments(memberNames)}
+  }
+`
+  )}
+
+`;
+}
+
+// src/render-solidity/renderTypesFromConfig.ts
+function renderTypesFromConfig(config) {
+  const enums = Object.keys(config.enums).map((name) => ({
+    name,
+    memberNames: config.enums[name]
+  }));
+  return renderTypes({
+    enums
+  });
+}
+
+// src/render-solidity/tablegen.ts
+import path3 from "path";
+
+// src/render-solidity/renderTableIndex.ts
+function renderTableIndex(options) {
+  return `${renderedSolidityHeader}
+
+${renderList(options, ({ outputPath, tableName, renderOptions: { structName, staticResourceData } }) => {
+    const imports = [tableName];
+    if (structName)
+      imports.push(structName);
+    if (staticResourceData)
+      imports.push(`${tableName}TableId`);
+    return `import { ${imports.join(", ")} } from "./${outputPath}";`;
+  })}
+`;
+}
+
+// src/render-solidity/tablegen.ts
+import { rmSync } from "fs";
+async function tablegen(config, outputBaseDirectory) {
+  const allTableOptions = getTableOptions(config);
+  const uniqueTableDirectories = new Set(allTableOptions.map(({ outputPath }) => path3.dirname(outputPath)));
+  for (const tableDir of uniqueTableDirectories) {
+    rmSync(path3.join(outputBaseDirectory, tableDir), { recursive: true, force: true });
+  }
+  for (const { outputPath, renderOptions } of allTableOptions) {
+    const fullOutputPath2 = path3.join(outputBaseDirectory, outputPath);
+    const output2 = renderTable(renderOptions);
+    formatAndWriteSolidity(output2, fullOutputPath2, "Generated table");
+  }
+  if (Object.keys(config.enums).length > 0) {
+    const fullOutputPath2 = path3.join(outputBaseDirectory, `${config.userTypesPath}.sol`);
+    const output2 = renderTypesFromConfig(config);
+    formatAndWriteSolidity(output2, fullOutputPath2, "Generated types file");
+  }
+  const fullOutputPath = path3.join(outputBaseDirectory, `Tables.sol`);
+  const output = renderTableIndex(allTableOptions);
+  formatAndWriteSolidity(output, fullOutputPath, "Generated table index");
+}
+
+export {
+  getTableOptions,
+  renderedSolidityHeader,
+  renderList,
+  renderArguments,
+  renderCommonData,
+  solidityRelativeImportPath,
+  renderImports,
+  renderWithStore,
+  renderTableId,
+  renderFieldMethods,
+  renderEncodeField,
+  renderDecodeValueType,
+  renderRecordMethods,
+  renderTable,
+  renderTypes,
+  renderTypesFromConfig,
+  tablegen
+};