@secondlayer/cli 1.3.0 → 1.4.1

package/dist/index.js

@@ -1,5 +1,20 @@
 import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -377,12 +392,12 @@ ${JSON.stringify(content, null, 2)}`;
 }
 // src/plugins/clarinet/index.ts
 import { initSimnet } from "@hirosystems/clarinet-sdk";
-import { toCamelCase as toCamelCase4 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase5 } from "@secondlayer/stacks/clarity";
 
 // src/generators/contract.ts
 init_format();
 import {
-  toCamelCase as toCamelCase3
+  toCamelCase as toCamelCase4
 } from "@secondlayer/stacks/clarity";
 
 // src/utils/type-mapping.ts
@@ -599,6 +614,37 @@ function generateClarityConversion(argName, argType) {
   return `${argName}`;
 }
 
+// src/utils/generator-helpers.ts
+import { toCamelCase as toCamelCase3, isAbiTuple as isAbiTuple3 } from "@secondlayer/stacks/clarity";
+function generateArgsSignature(args) {
+  if (args.length === 0)
+    return "";
+  const argsTypes = args.map((arg) => {
+    const camelName = toCamelCase3(arg.name);
+    return `${camelName}: ${getTypeForArg(arg)}`;
+  }).join("; ");
+  return `args: { ${argsTypes} }, `;
+}
+function generateClarityArgs(args) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => {
+    const argName = `args.${toCamelCase3(arg.name)}`;
+    return generateClarityConversion(argName, arg);
+  }).join(", ");
+}
+function generateMapKeyConversion(keyType) {
+  if (isAbiTuple3(keyType)) {
+    const fields = keyType.tuple.map((field) => {
+      const camelFieldName = toCamelCase3(field.name);
+      const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
+      return `"${field.name}": ${fieldConversion}`;
+    }).join(", ");
+    return `Cl.tuple({ ${fields} })`;
+  }
+  return generateClarityConversion("key", { type: keyType });
+}
+
 // src/generators/contract.ts
 function generateNetworkUtils() {
   return `/**
@@ -690,7 +736,7 @@ function generateAbiConstant(name, abi) {
   return `export const ${name}Abi = ${abiJson} as const`;
 }
 function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase3(func.name);
+  const methodName = toCamelCase4(func.name);
   if (func.args.length === 0) {
     return `${methodName}() {
     return {
@@ -703,7 +749,7 @@ function generateMethod(func, address, contractName) {
   }
   if (func.args.length === 1) {
     const originalArgName = func.args[0].name;
-    const argName = toCamelCase3(originalArgName);
+    const argName = toCamelCase4(originalArgName);
     const argType = getTypeForArg(func.args[0]);
     const clarityConversion = generateClarityConversion(argName, func.args[0]);
     return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
@@ -719,17 +765,17 @@ function generateMethod(func, address, contractName) {
     }
   }`;
   }
-  const argsList = func.args.map((arg) => toCamelCase3(arg.name)).join(", ");
+  const argsList = func.args.map((arg) => toCamelCase4(arg.name)).join(", ");
   const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase3(arg.name);
+    const camelName = toCamelCase4(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase3(arg.name);
+    const argName = toCamelCase4(arg.name);
     return generateClarityConversion(argName, arg);
   }).join(", ");
   const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase3(arg.name);
+    const camelName = toCamelCase4(arg.name);
     return `args[0].${camelName}`;
   }).join(", ");
   const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
@@ -751,7 +797,7 @@ function generateMapsObject(maps, address, contractName) {
     return "";
   }
   const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase3(map.name);
+    const methodName = toCamelCase4(map.name);
     const keyType = getTypeForArg({ type: map.key });
     const valueType = getTypeForArg({ type: map.value });
     const keyConversion = generateMapKeyConversion(map.key);
@@ -812,7 +858,7 @@ function generateVarsObject(variables, address, contractName) {
     return "";
   }
   const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase3(variable.name);
+    const methodName = toCamelCase4(variable.name);
     const valueType = getTypeForArg({ type: variable.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -857,7 +903,7 @@ function generateConstantsObject(variables, address, contractName) {
     return "";
   }
   const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase3(constant.name);
+    const methodName = toCamelCase4(constant.name);
     const valueType = getTypeForArg({ type: constant.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -893,17 +939,6 @@ function generateConstantsObject(variables, address, contractName) {
     `)}
   }`;
 }
-function generateMapKeyConversion(keyType) {
-  if (keyType.tuple) {
-    const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase3(field.name);
-      const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
-      return `"${field.name}": ${fieldConversion}`;
-    }).join(", ");
-    return `Cl.tuple({ ${fields} })`;
-  }
-  return generateClarityConversion("key", { type: keyType });
-}
 
 // src/utils/abi-compat.ts
 function normalizeAccess(access) {
@@ -1060,7 +1095,7 @@ function normalizeAbi(abi) {
 
 // src/plugins/clarinet/index.ts
 function sanitizeContractName(name) {
-  return toCamelCase4(name);
+  return toCamelCase5(name);
 }
 async function isUserDefinedContract(contractId, manifestPath) {
   const { address, contractName } = parseContractId(contractId);
@@ -1171,28 +1206,6 @@ async function hasClarinetProject(path2 = "./Clarinet.toml") {
 }
 // src/plugins/actions/generators.ts
 import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
-
-// src/utils/generator-helpers.ts
-import { toCamelCase as toCamelCase5 } from "@secondlayer/stacks/clarity";
-function generateArgsSignature(args) {
-  if (args.length === 0)
-    return "";
-  const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase5(arg.name);
-    return `${camelName}: ${getTypeForArg(arg)}`;
-  }).join("; ");
-  return `args: { ${argsTypes} }, `;
-}
-function generateClarityArgs(args) {
-  if (args.length === 0)
-    return "";
-  return args.map((arg) => {
-    const argName = `args.${toCamelCase5(arg.name)}`;
-    return generateClarityConversion(argName, arg);
-  }).join(", ");
-}
-
-// src/plugins/actions/generators.ts
 function generateReadHelpers(contract, options) {
   const { abi } = contract;
   const functions = abi.functions || [];
@@ -2483,7 +2496,7 @@ var react = (options = {}) => {
 // src/plugins/testing/generators.ts
 import {
   toCamelCase as toCamelCase8,
-  isAbiTuple as isAbiTuple3
+  isAbiTuple as isAbiTuple4
 } from "@secondlayer/stacks/clarity";
 function toPascalCase(str) {
   const camel = toCamelCase8(str);
@@ -2539,27 +2552,16 @@ function generateDataVarHelper(variable, contractId) {
     }`;
 }
 function getMapKeyType(keyType) {
-  if (isAbiTuple3(keyType)) {
+  if (isAbiTuple4(keyType)) {
     const fields = keyType.tuple.map((field) => `${toCamelCase8(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
     return `{ ${fields} }`;
   }
   return getTypeForArg({ type: keyType });
 }
-function generateMapKeyConversion2(keyType) {
-  if (isAbiTuple3(keyType)) {
-    const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase8(field.name);
-      const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
-      return `"${field.name}": ${fieldConversion}`;
-    }).join(", ");
-    return `Cl.tuple({ ${fields} })`;
-  }
-  return generateClarityConversion("key", { type: keyType });
-}
 function generateMapEntryHelper(map, contractId) {
   const methodName = toCamelCase8(map.name);
   const keyType = getMapKeyType(map.key);
-  const keyConversion = generateMapKeyConversion2(map.key);
+  const keyConversion = generateMapKeyConversion(map.key);
   return `${methodName}: (key: ${keyType}) => {
       return simnet.getMapEntry(
         '${contractId}',
@@ -2755,5 +2757,5 @@ export {
   PluginManager
 };
 
-//# debugId=217DF2A543BBE57564756E2164756E21
+//# debugId=A0CB31E87C48058164756E2164756E21
 //# sourceMappingURL=index.js.map