@latticexyz/cli 2.0.0-alpha.49 → 2.0.0-alpha.5

package/dist/{chunk-MXDV47JM.js → chunk-WZFXLDPK.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";
@@ -58,7 +56,7 @@ function getTableOptions(config) {
         return {
           tableIdName: tableName + "TableId",
           namespace: config.namespace,
-          fileSelector: tableData.fileSelector
+          name: tableData.name
         };
       }
     })();
@@ -101,7 +99,7 @@ function renderCommonData({
   primaryKeys
 }) {
   const _tableId = staticResourceData ? "" : "_tableId";
-  const _typedTableId = staticResourceData ? "" : "uint256 _tableId";
+  const _typedTableId = staticResourceData ? "" : "bytes32 _tableId";
   const _keyArgs = renderArguments(primaryKeys.map(({ name }) => name));
   const _typedKeyArgs = renderArguments(primaryKeys.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
   const _primaryKeysDefinition = `
@@ -147,10 +145,10 @@ function renderWithStore(storeArgument, callback) {
   return result;
 }
 function renderTableId(staticResourceData) {
-  const hardcodedTableId = `uint256(bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.fileSelector}"))))`;
+  const hardcodedTableId = `bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.name}")))`;
   const tableIdDefinition = `
-    uint256 constant _tableId = ${hardcodedTableId};
-    uint256 constant ${staticResourceData.tableIdName} = _tableId;
+    bytes32 constant _tableId = ${hardcodedTableId};
+    bytes32 constant ${staticResourceData.tableIdName} = _tableId;
   `;
   return {
     hardcodedTableId,
@@ -232,6 +230,28 @@ function renderFieldMethods(options) {
         }
       `
       );
+      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;
@@ -273,7 +293,8 @@ function fieldPortionData(field) {
       typeWithLocation: field.arrayElement.typeWithLocation,
       name: "_element",
       encoded: renderEncodeField({ ...field.arrayElement, arrayElement: void 0, name, methodNameSuffix }),
-      title: "an element"
+      title: "an element",
+      elementLength: field.arrayElement.staticByteLength
     };
   } else {
     const name = "_slice";
@@ -281,7 +302,8 @@ function fieldPortionData(field) {
       typeWithLocation: `${field.typeId} memory`,
       name,
       encoded: renderEncodeField({ ...field, name, methodNameSuffix }),
-      title: "a slice"
+      title: "a slice",
+      elementLength: 1
     };
   }
 }
@@ -382,16 +404,20 @@ function renderDecodeFunction({ structName, fields, staticFields, dynamicFields
         ${fieldNamePrefix}${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
         `
     )}
-      uint256 _start;
-      uint256 _end = ${totalStaticLength + 32};
-      ${renderList(
+      // 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)};
-        `
+          _start = _end;
+          _end += _encodedLengths.atIndex(${index});
+          ${fieldNamePrefix}${field.name} = ${renderDecodeDynamicFieldPartial(field)};
+          `
     )}
+      }
     }
   `;
   } else {
@@ -675,18 +701,43 @@ function renderTypesFromConfig(config) {
 
 // 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 fullOutputPath = path3.join(outputBaseDirectory, outputPath);
-    const output = renderTable(renderOptions);
-    formatAndWriteSolidity(output, fullOutputPath, "Generated table");
+    const fullOutputPath2 = path3.join(outputBaseDirectory, outputPath);
+    const output2 = renderTable(renderOptions);
+    formatAndWriteSolidity(output2, fullOutputPath2, "Generated table");
   }
   if (Object.keys(config.enums).length > 0) {
-    const fullOutputPath = path3.join(outputBaseDirectory, `${config.userTypesPath}.sol`);
-    const output = renderTypesFromConfig(config);
-    formatAndWriteSolidity(output, fullOutputPath, "Generated types file");
+    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 {