@taqueria/plugin-ligo 0.40.10 → 0.40.13

package/index.mjs

@@ -1,666 +1,61 @@
-// index.ts
-import { Option, Plugin, PositionalArg, Task, Template } from "@taqueria/node-sdk";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// createContract.ts
-import { sendAsyncErr } from "@taqueria/node-sdk";
-import { writeFile } from "fs/promises";
+// index.ts
+import { configurePlugin } from "@taqueria/lib-ligo";
 
 // ligo_templates.ts
+var ligo_templates_exports = {};
+__export(ligo_templates_exports, {
+  jsligo_template: () => jsligo_template,
+  mligo_template: () => mligo_template
+});
 var mligo_template = `
-type storage = int
-type return = operation list * storage
-
-(* Three entrypoints *)
-[@entry] let increment (delta : int) (store : storage) : return =
-  [], store + delta
-[@entry] let decrement (delta : int) (store : storage) : return =
-  [], store - delta
-[@entry] let reset (() : unit) (_ : storage) : return =
-  [], 0
-`;
-var jsligo_template = `
-type storage = int;
-type ret = [list<operation>, storage];
-
-// Three entrypoints
-
-// @entry
-const increment = (delta : int, store : storage) : ret =>
-  [list([]), store + delta];
-
-// @entry
-const decrement = (delta : int, store : storage) : ret =>
-  [list([]), store - delta];
-
-// @entry
-const reset = (_ : unit, _ : storage) : ret =>
-  [list([]), 0];
-`;
-
-// createContract.ts
-var getLigoTemplate = async (contractName, syntax) => {
-  const matchResult = contractName.match(/\.[^.]+$/);
-  const ext = matchResult ? matchResult[0].substring(1) : null;
-  if (syntax === "mligo")
-    return mligo_template;
-  if (syntax === "jsligo")
-    return jsligo_template;
-  if (syntax === void 0) {
-    if (ext === "mligo")
-      return mligo_template;
-    if (ext === "jsligo")
-      return jsligo_template;
-    return sendAsyncErr(
-      `Unable to infer LIGO syntax from "${contractName}". Please specify a LIGO syntax via the --syntax option`
-    );
-  } else {
-    return sendAsyncErr(`"${syntax}" is not a valid syntax. Please specify a valid LIGO syntax`);
-  }
-};
-var createContract = (args) => {
-  const unsafeOpts = args;
-  const contractName = unsafeOpts.sourceFileName;
-  const syntax = unsafeOpts.syntax;
-  const contractsDir = `${args.config.projectDir}/${args.config.contractsDir}`;
-  return getLigoTemplate(contractName, syntax).then((ligo_template) => writeFile(`${contractsDir}/${contractName}`, ligo_template));
-};
-var createContract_default = createContract;
+module Counter = struct
+  type storage = int
 
-// main.ts
-import { sendAsyncErr as sendAsyncErr5, sendAsyncRes } from "@taqueria/node-sdk";
-
-// common.ts
-import { getDockerImage, sendErr } from "@taqueria/node-sdk";
-import { join } from "path";
-var LIGO_DEFAULT_IMAGE = "ligolang/ligo:0.73.0";
-var LIGO_IMAGE_ENV_VAR = "TAQ_LIGO_IMAGE";
-var getLigoDockerImage = () => getDockerImage(LIGO_DEFAULT_IMAGE, LIGO_IMAGE_ENV_VAR);
-var getInputFilenameAbsPath = (parsedArgs, sourceFile) => join(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts", sourceFile);
-var getInputFilenameRelPath = (parsedArgs, sourceFile) => join(parsedArgs.config.contractsDir ?? "contracts", sourceFile);
-var formatLigoError = (err) => {
-  let result = err.message.replace(/Command failed.+?\n/, "");
-  if (result.includes("An internal error ocurred. Please, contact the developers.") && result.includes("Module Contract not found with last Contract.")) {
-    result = `By convention, Taqueria expects you to import your contract with Contract as the module name.
-For instance, if you have a contract in a file called "increment.mligo", in your parameter/storage list file you must include #import "Increment.mligo" "Contract" for compilation to be successful.`;
-  }
-  err.message = result.replace(
-    "An internal error ocurred. Please, contact the developers.",
-    "The LIGO compiler experienced an internal error. Please contact the LIGO developers."
-  );
-  return err;
-};
-var emitExternalError = (errs, sourceFile) => {
-  sendErr(`
-=== Error messages for ${sourceFile} ===`);
-  const errors = Array.isArray(errs) ? errs : [errs];
-  errors.map((err) => {
-    err instanceof Error ? sendErr(err.message) : sendErr(err);
-  });
-  sendErr(`===`);
-};
-
-// compile.ts
-import {
-  execCmd,
-  getArch,
-  getArtifactsDir,
-  sendErr as sendErr2,
-  sendJsonRes,
-  sendWarn
-} from "@taqueria/node-sdk";
-import { createReadStream } from "fs";
-import { access, writeFile as writeFile2 } from "fs/promises";
-import { basename, join as join2 } from "path";
-import * as readline from "readline";
-var COMPILE_ERR_MSG = "Not compiled";
-var isStorageKind = (exprKind) => exprKind === "storage" || exprKind === "default_storage";
-var isSupportedLigoSyntax = (sourceFile) => /\.(mligo|jsligo)$/.test(sourceFile);
-var isUnsupportedLigoSyntax = (sourceFile) => /\.(ligo|religo)$/.test(sourceFile);
-var isLIGOFile = (sourceFile) => isSupportedLigoSyntax(sourceFile) || isUnsupportedLigoSyntax(sourceFile);
-var isStorageListFile = (sourceFile) => /.+\.(storageList|storages)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
-var isParameterListFile = (sourceFile) => /.+\.(parameterList|parameters)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
-var listContractModules = async (parsedArgs, sourceFile) => {
-  try {
-    await getArch();
-    const cmd = await getListDeclarationsCmd(parsedArgs, sourceFile);
-    const { stderr, stdout } = await execCmd(cmd);
-    if (stderr.length > 0)
-      return Promise.reject(stderr);
-    return JSON.parse(stdout).declarations.reduce(
-      (acc, decl) => {
-        const srcFile = removeExt(basename(sourceFile));
-        const syntax = extractExt(sourceFile).replace(".", "");
-        if (decl === "main") {
-          return [...acc, { moduleName: srcFile, sourceName: sourceFile, sourceFile, type: "file-main", syntax }];
-        } else if (decl === "$main") {
-          return [...acc, { moduleName: srcFile, sourceName: sourceFile, sourceFile, type: "file-entry", syntax }];
-        } else if (decl.endsWith(".main")) {
-          const moduleName = decl.replace(/\.main$/, "");
-          return [...acc, {
-            moduleName,
-            sourceName: `${sourceFile}/${moduleName}`,
-            sourceFile,
-            type: "module-main",
-            syntax
-          }];
-        } else if (decl.endsWith(".$main")) {
-          const moduleName = decl.replace(/\.\$main$/, "");
-          return [...acc, {
-            moduleName,
-            sourceName: `${sourceFile}/${moduleName}`,
-            sourceFile,
-            type: "module-entry",
-            syntax
-          }];
-        }
-        return acc;
-      },
-      []
-    );
-  } catch (err) {
-    emitExternalError(err, sourceFile);
-    return [];
-  }
-};
-var getListDeclarationsCmd = async (parsedArgs, sourceFile) => {
-  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
-  if (!projectDir)
-    throw new Error(`No project directory provided`);
-  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} info list-declarations`;
-  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
-  const flags = "--display-format json";
-  const cmd = `${baseCmd} ${inputFile} ${flags}`;
-  return cmd;
-};
-var extractExt = (path) => {
-  const matchResult = path.match(/\.(ligo|religo|mligo|jsligo)$/);
-  return matchResult ? matchResult[0] : "";
-};
-var removeExt = (path) => {
-  const extRegex = new RegExp(extractExt(path));
-  return path.replace(extRegex, "");
-};
-var isOutputFormatJSON = (parsedArgs) => parsedArgs.json;
-var getOutputContractFilename = (parsedArgs, module) => {
-  const ext = isOutputFormatJSON(parsedArgs) ? ".json" : ".tz";
-  return join2(getArtifactsDir(parsedArgs), `${module.moduleName}${ext}`);
-};
-var getOutputExprFilename = (parsedArgs, module, exprKind, exprName) => {
-  const contractName = module.moduleName;
-  const ext = isOutputFormatJSON(parsedArgs) ? ".json" : ".tz";
-  const outputFile = exprKind === "default_storage" ? `${contractName}.default_storage${ext}` : `${contractName}.${exprKind}.${exprName}${ext}`;
-  return join2(getArtifactsDir(parsedArgs), `${outputFile}`);
-};
-var getCompileContractCmd = async (parsedArgs, sourceFile, module) => {
-  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
-  if (!projectDir)
-    throw new Error(`No project directory provided`);
-  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile contract`;
-  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
-  const outputFile = `-o ${getOutputContractFilename(parsedArgs, module)}`;
-  const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
-  const moduleFlag = module.type.startsWith("file-") ? "" : `-m ${module.moduleName}`;
-  const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}${moduleFlag}`;
-  return cmd;
-};
-var getCompileExprCmd = (parsedArgs, sourceFile, module, exprKind, exprName) => {
-  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
-  if (!projectDir)
-    throw new Error(`No project directory provided`);
-  const compilerType = isStorageKind(exprKind) ? "storage" : "parameter";
-  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile ${compilerType}`;
-  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
-  const outputFile = `-o ${getOutputExprFilename(parsedArgs, module, exprKind, exprName)}`;
-  const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
-  const moduleFlag = (() => {
-    switch (module.type) {
-      case "file-main":
-      case "file-entry":
-        return "-m Contract";
-      default:
-        return `-m Contract.${module.moduleName}`;
-    }
-  })();
-  const cmd = `${baseCmd} ${inputFile} ${exprName} ${outputFile} ${flags} ${moduleFlag}`;
-  return cmd;
-};
-var compileContract = async (parsedArgs, sourceFile, module) => {
-  try {
-    await getArch();
-    const cmd = await getCompileContractCmd(parsedArgs, sourceFile, module);
-    const { stderr } = await execCmd(cmd);
-    if (stderr.length > 0)
-      sendWarn(stderr);
-    return {
-      source: module.sourceName,
-      artifact: getOutputContractFilename(parsedArgs, module)
-    };
-  } catch (err) {
-    emitExternalError(err, sourceFile);
-    return {
-      source: module.sourceName,
-      artifact: COMPILE_ERR_MSG
-    };
-  }
-};
-var compileExpr = (parsedArgs, sourceFile, module, exprKind) => (exprName) => {
-  return getArch().then(() => getCompileExprCmd(parsedArgs, sourceFile, module, exprKind, exprName)).then(execCmd).then(({ stderr }) => {
-    if (stderr.length > 0)
-      sendWarn(stderr);
-    const artifactName = getOutputExprFilename(parsedArgs, module, exprKind, exprName);
-    return {
-      source: module.sourceName,
-      artifact: artifactName
-    };
-  }).catch((err) => {
-    return {
-      source: module.sourceName,
-      artifact: `${exprName} in ${sourceFile} not compiled`,
-      err
-    };
-  });
-};
-var getExprNames = (parsedArgs, sourceFile) => {
-  return new Promise((resolve, reject) => {
-    const inputFilePath = getInputFilenameAbsPath(parsedArgs, sourceFile);
-    const readInterface = readline.createInterface({
-      input: createReadStream(inputFilePath),
-      output: process.stdout
-    });
-    const variableNames = [];
-    readInterface.on("line", function(line) {
-      if (!line.trim().startsWith("//")) {
-        const matches = line.match(/(?<=\s*(let|const)\s+)[a-zA-Z0-9_]+/g);
-        if (matches) {
-          variableNames.push(...matches);
-        }
-      }
-    });
-    readInterface.on("close", function() {
-      resolve(variableNames);
-    });
-  });
-};
-var compileExprs = async (parsedArgs, sourceFile, module, exprKind) => {
-  let exprs = [];
-  try {
-    exprs = await getExprNames(parsedArgs, sourceFile);
-  } catch (err) {
-    emitExternalError(err, sourceFile);
-    return [{
-      source: module.sourceName,
-      artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} expressions compiled`
-    }];
-  }
-  const results = await Promise.all(exprs.map(async (exprName, index) => {
-    const compileResult = await compileExpr(
-      parsedArgs,
-      sourceFile,
-      module,
-      exprKind === "storage" && index === 0 ? "default_storage" : exprKind
-    )(exprName);
-    return compileResult;
-  }));
-  const errors = results.reduce(
-    (acc, result) => {
-      if (result.err) {
-        if (!(result.err instanceof Error))
-          return [...acc, result.err];
-        const ligoErrs = acc.filter((err) => err instanceof Error).map((err) => err.message);
-        const formattedError = formatLigoError(result.err);
-        return ligoErrs.includes(formattedError.message) ? acc : [...acc, formattedError];
-      }
-      return acc;
-    },
-    []
-  );
-  const retval = results.map(({ source, artifact }) => ({ source, artifact }));
-  if (errors.length)
-    emitExternalError(errors, sourceFile);
-  return retval;
-};
-var getInitialMessage = (pair, module) => {
-  const messages = {
-    "mligo-file-main": `// When this file was created, the smart contract was defined with a main function that was not within a named module. As such, the examples below are written with that assumption in mind.`,
-    "mligo-file-entry": `// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was not within a named module. As such, the examples below are written with that assumption in mind.`,
-    "mligo-module-main": `// When this file was created, the smart contract was defined with a main function that was within a named module. As such, the examples below are written with that assumption in mind.`,
-    "mligo-module-entry": `// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was within a named module. As such, the examples below are written with that assumption in mind.`,
-    "jsligo-file-main": `// When this file was created, the smart contract was defined with a main function that was not within a namespace. As such, the examples below are written with that assumption in mind.
-// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
-    "jsligo-file-entry": `// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was not within a namespace. As such, the examples below are written with that assumption in mind.`,
-    "jsligo-module-main": `// When this file was created, the smart contract was defined with a main function that was within a namespace. As such, the examples below are written with that assumption in mind.
-// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
-    "jsligo-module-entry": `// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was within a namespace. As such, the examples below are written with that assumption in mind.`
-    // ... any other combinations
-  };
-  return messages[pair] || "// This file was created by Taqueria.";
-};
-var getCommonMsg = (langType, listType) => {
-  const varKeyword = langType === "mligo" ? "let" : "const";
-  const commonMsgForStorage = `// IMPORTANT: We suggest always explicitly typing your storage values:
-// E.g.: \`${varKeyword} storage: int = 10\` or \`${varKeyword} storage: Contract.storage = 10\``;
-  const commonMsgForParameter = `// IMPORTANT: We suggest always explicitly typing your parameter values:
-// E.g.: \`${varKeyword} parameter: int = 10\` or \`${varKeyword} parameter: Contract.parameter = 10\``;
-  return listType === "storage" ? commonMsgForStorage : commonMsgForParameter;
-};
-var getContent = (moduleInfo, listType) => {
-  const linkToContract = `#import "${moduleInfo.sourceFile}" "Contract"`;
-  const pair = `${moduleInfo.syntax}-${moduleInfo.type}`;
-  const initialMsg = getInitialMessage(pair, moduleInfo);
-  const commonMsg = getCommonMsg(moduleInfo.syntax, listType);
-  return `${linkToContract}
+  type ret = operation list * storage
 
-${initialMsg}
+  (* Three entrypoints *)
 
-${commonMsg}`;
-};
-var initContentForStorage = (moduleInfo) => getContent(moduleInfo, "storage");
-var initContentForParameter = (moduleInfo) => getContent(moduleInfo, "parameter");
-var compileContractWithStorageAndParameter = async (parsedArgs, sourceFile, module) => {
-  const contractCompileResult = await compileContract(parsedArgs, sourceFile, module);
-  if (contractCompileResult.artifact === COMPILE_ERR_MSG)
-    return [contractCompileResult];
-  debugger;
-  const storageListFile = `${module.moduleName}.storageList${extractExt(sourceFile)}`;
-  const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);
-  const storageCompileResult = await access(storageListFilename).then(() => compileExprs(parsedArgs, storageListFile, module, "storage")).catch(() => {
-    sendWarn(
-      `Note: storage file associated with "${module.moduleName}" can't be found, so "${storageListFile}" has been created for you. Use this file to define all initial storage values for this contract
-`
-    );
-    return writeFile2(storageListFilename, initContentForStorage(module), "utf8");
-  });
-  const parameterListFile = `${module.moduleName}.parameterList${extractExt(sourceFile)}`;
-  const parameterListFilename = getInputFilenameAbsPath(parsedArgs, parameterListFile);
-  const parameterCompileResult = await access(parameterListFilename).then(() => compileExprs(parsedArgs, parameterListFile, module, "parameter")).catch(() => {
-    sendWarn(
-      `Note: parameter file associated with "${module.moduleName}" can't be found, so "${parameterListFile}" has been created for you. Use this file to define all parameter values for this contract
-`
-    );
-    return writeFile2(parameterListFilename, initContentForParameter(module), "utf8");
-  });
-  const storageArtifacts = storageCompileResult ? storageCompileResult.map((res) => res.artifact).join("\n") : "";
-  const parameterArtifacts = parameterCompileResult ? parameterCompileResult.map((res) => res.artifact).join("\n") : "";
-  const combinedArtifact = [
-    contractCompileResult.artifact,
-    storageArtifacts,
-    parameterArtifacts
-  ].filter(Boolean).join("\n");
-  const combinedRow = {
-    source: module.sourceName,
-    artifact: combinedArtifact
-  };
-  return [combinedRow];
-};
-var compile = async (parsedArgs) => {
-  const sourceFile = parsedArgs.sourceFile;
-  if (!isLIGOFile(sourceFile)) {
-    sendErr2(`${sourceFile} is not a LIGO file`);
-    return;
-  }
-  if (isStorageListFile(sourceFile) || isParameterListFile(sourceFile)) {
-    sendErr2(`Storage and parameter list files are not meant to be compiled directly`);
-    return;
-  }
-  if (isUnsupportedLigoSyntax(sourceFile)) {
-    sendErr2(`Unsupported LIGO syntax detected in ${sourceFile}. Note, we only support .jsligo and .mligo files.`);
-    return;
-  }
-  try {
-    const modules = await listContractModules(parsedArgs, sourceFile);
-    if (modules.length === 0) {
-      return sendJsonRes([
-        {
-          source: sourceFile,
-          artifact: `No contract modules found in "${sourceFile}"`
-        }
-      ]);
-    }
-    let allCompileResults = [];
-    for (const module of modules) {
-      if (parsedArgs.module && parsedArgs.module !== module.moduleName)
-        continue;
-      const compileResults = await compileContractWithStorageAndParameter(parsedArgs, sourceFile, module);
-      allCompileResults = allCompileResults.concat(compileResults);
-    }
-    sendJsonRes(allCompileResults, { footer: `
-Compiled ${allCompileResults.length} contract(s) in "${sourceFile}"` });
-  } catch (err) {
-    sendErr2(`Error processing "${sourceFile}": ${err}`);
-  }
-};
-var compile_default = compile;
+  [@entry]
+  let increment (delta : int) (store : storage) : ret = [], store + delta
 
-// compile-all.ts
-import { sendErr as sendErr3, sendJsonRes as sendJsonRes2 } from "@taqueria/node-sdk";
-import glob from "fast-glob";
-import { join as join3 } from "path";
-var compileAll = async (parsedArgs) => {
-  let compilePromises = [];
-  const contractFilenames = await glob(
-    ["**/*.ligo", "**/*.religo", "**/*.mligo", "**/*.jsligo"],
-    {
-      cwd: join3(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts"),
-      absolute: false
-    }
-  );
-  for (const filename of contractFilenames) {
-    if (isStorageListFile(filename) || isParameterListFile(filename))
-      continue;
-    const moduleNames = await listContractModules(parsedArgs, filename);
-    for (const moduleName of moduleNames) {
-      compilePromises.push(compileContractWithStorageAndParameter(parsedArgs, filename, moduleName));
-    }
-  }
-  return Promise.all(compilePromises).then((tables) => tables.flat()).then(sendJsonRes2).catch((err) => sendErr3(err, false));
-};
-var compile_all_default = compileAll;
+  [@entry]
+  let decrement (delta : int) (store : storage) : ret = [], store - delta
 
-// ligo.ts
-import { execCmd as execCmd2, getArch as getArch2, sendAsyncErr as sendAsyncErr3, sendRes as sendRes2, spawnCmd } from "@taqueria/node-sdk";
-import { readJsonFile, writeJsonFile } from "@taqueria/node-sdk";
-import { join as join4 } from "path";
-var getArbitraryLigoCmd = (parsedArgs, uid, gid, userArgs) => {
-  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
-  if (!projectDir)
-    throw `No project directory provided`;
-  const userMap = uid && gid ? `${uid}:${gid}` : uid;
-  const userMapArgs = uid ? ["-u", userMap] : [];
-  const binary = "docker";
-  const baseArgs = [
-    "run",
-    "--rm",
-    "-v",
-    `${projectDir}:/project`,
-    "-w",
-    "/project",
-    ...userMapArgs,
-    getLigoDockerImage()
-  ];
-  const processedUserArgs = userArgs.split(" ").map((arg) => arg.startsWith("\\-") ? arg.substring(1) : arg).filter(
-    (arg) => arg
-  );
-  const args = [...baseArgs, ...processedUserArgs, "--skip-analytics"];
-  const envVars = { "DOCKER_DEFAULT_PLATFORM": "linux/amd64" };
-  return [
-    [binary, ...args].join(" "),
-    envVars
-  ];
-};
-var ensureEsyExists = async (parsedArgs) => {
-  const esyJsonPath = join4(parsedArgs.projectDir, "esy.json");
-  try {
-    return await readJsonFile(esyJsonPath);
-  } catch {
-    return await writeJsonFile(esyJsonPath)({});
-  }
-};
-var runArbitraryLigoCmd = (parsedArgs, cmd) => ensureEsyExists(parsedArgs).then(getArch2).then(async () => {
-  const uid = await execCmd2("id -u");
-  const gid = await execCmd2("id -g");
-  return [uid.stdout.trim(), gid.stdout.trim()];
-}).then(([uid, gid]) => getArbitraryLigoCmd(parsedArgs, uid, gid, cmd)).then(([cmd2, envVars]) => spawnCmd(cmd2, envVars)).then(
-  (code) => code !== null && code === 0 ? `Command "${cmd}" ran successfully by LIGO` : `Command "${cmd}" failed. Please check your command`
-).catch((err) => sendAsyncErr3(`An internal error has occurred: ${err.message}`));
-var ligo = (parsedArgs) => {
-  const args = parsedArgs.command;
-  return runArbitraryLigoCmd(parsedArgs, args).then(sendRes2).catch((err) => sendAsyncErr3(err, false));
-};
-var ligo_default = ligo;
+  [@entry]
+  let reset (() : unit) (_ : storage) : ret = [], 0
 
-// test.ts
-import { execCmd as execCmd3, getArch as getArch3, sendAsyncErr as sendAsyncErr4, sendJsonRes as sendJsonRes3, sendWarn as sendWarn2 } from "@taqueria/node-sdk";
-var getTestContractCmd = (parsedArgs, sourceFile) => {
-  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
-  if (!projectDir)
-    throw `No project directory provided`;
-  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} run test`;
-  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
-  const cmd = `${baseCmd} ${inputFile}`;
-  return cmd;
-};
-var testContract = (parsedArgs, sourceFile) => getArch3().then(() => getTestContractCmd(parsedArgs, sourceFile)).then(execCmd3).then(({ stdout, stderr }) => {
-  if (stderr.length > 0)
-    sendWarn2(stderr);
-  const result = "\u{1F389} All tests passed \u{1F389}";
-  return {
-    contract: sourceFile,
-    testResults: stdout.length > 0 ? `${stdout}
-${result}` : result
-  };
-}).catch((err) => {
-  emitExternalError(err, sourceFile);
-  return {
-    contract: sourceFile,
-    testResults: "Some tests failed :("
+end
+`;
+var jsligo_template = `
+export namespace Counter {
+    export type storage = int;
+    type ret = [list<operation>, storage];
+    // Three entrypoints
+  
+    @entry
+    const increment = (delta: int, store: storage): ret =>
+      [list([]), store + delta];
+    @entry
+    const decrement = (delta: int, store: storage): ret =>
+      [list([]), store - delta];
+    @entry
+    const reset = (_p: unit, _s: storage): ret => [list([]), 0]
   };
-});
-var test = (parsedArgs) => {
-  const sourceFile = parsedArgs.sourceFile;
-  if (!sourceFile)
-    return sendAsyncErr4(`No source file provided`);
-  return testContract(parsedArgs, sourceFile).then((result) => [result]).then(sendJsonRes3).catch(
-    (err) => sendAsyncErr4(err, false)
-  );
-};
-var test_default = test;
-
-// main.ts
-var main = (parsedArgs) => {
-  const unsafeOpts = parsedArgs;
-  switch (unsafeOpts.task) {
-    case "ligo":
-      return ligo_default(unsafeOpts);
-    case "compile":
-      return compile_default(unsafeOpts);
-    case "compile-all":
-      return compile_all_default(unsafeOpts);
-    case "test":
-      return test_default(parsedArgs);
-    case "get-image":
-      return sendAsyncRes(getLigoDockerImage());
-    default:
-      return sendAsyncErr5(`${unsafeOpts.task} is not an understood task by the LIGO plugin`);
-  }
-};
-var main_default = main;
+`;
 
 // index.ts
-Plugin.create((i18n) => ({
-  schema: "1.0",
-  version: "0.1",
+configurePlugin({
+  name: "@taqueria/plugin-ligo",
   alias: "ligo",
-  tasks: [
-    Task.create({
-      task: "ligo",
-      command: "ligo",
-      description: "This task allows you to run arbitrary LIGO native commands. Note that they might not benefit from the abstractions provided by Taqueria",
-      options: [
-        Option.create({
-          shortFlag: "c",
-          flag: "command",
-          type: "string",
-          description: "The command to be passed to the underlying LIGO binary, wrapped in quotes",
-          required: true
-        })
-      ],
-      handler: "proxy",
-      encoding: "none"
-    }),
-    Task.create({
-      task: "compile",
-      command: "compile <sourceFile>",
-      aliases: ["c", "compile-ligo"],
-      description: "Compile a smart contract written in a LIGO syntax to Michelson code, along with its associated storage/parameter list files if they are found",
-      options: [
-        Option.create({
-          flag: "json",
-          boolean: true,
-          description: "Emit JSON-encoded Michelson"
-        }),
-        Option.create({
-          flag: "module",
-          shortFlag: "m",
-          type: "string",
-          description: "The LIGO module to be compiled"
-        })
-      ],
-      handler: "proxy",
-      encoding: "json"
-    }),
-    Task.create({
-      task: "compile-all",
-      command: "compile-all",
-      description: "Compile all main smart contracts written in a LIGO syntax to Michelson code, along with their associated storage/parameter list files if they are found",
-      options: [
-        Option.create({
-          flag: "json",
-          boolean: true,
-          description: "Emit JSON-encoded Michelson"
-        })
-      ],
-      handler: "proxy",
-      encoding: "json"
-    }),
-    Task.create({
-      task: "test",
-      command: "test <sourceFile>",
-      description: "Test a smart contract written in LIGO",
-      handler: "proxy",
-      encoding: "json"
-    }),
-    Task.create({
-      task: "get-image",
-      command: "get-image",
-      description: "Gets the name of the image to be used",
-      handler: "proxy",
-      hidden: true
-    })
-  ],
-  templates: [
-    Template.create({
-      template: "contract",
-      command: "contract <sourceFileName>",
-      description: "Create a LIGO contract with boilerplate code",
-      positionals: [
-        PositionalArg.create({
-          placeholder: "sourceFileName",
-          type: "string",
-          description: "The name of the LIGO contract to generate"
-        })
-      ],
-      options: [
-        Option.create({
-          shortFlag: "s",
-          flag: "syntax",
-          type: "string",
-          description: "The syntax used in the contract"
-        })
-      ],
-      handler: createContract_default
-    })
-  ],
-  proxy: main_default,
-  postInstall: `node ${__dirname}/postinstall.js`
-}), process.argv);
+  dockerImage: "ligolang/ligo:1.0.0",
+  dockerImageEnvVar: "TAQ_LIGO_IMAGE",
+  unparsedArgs: process.argv,
+  templates: ligo_templates_exports
+});
 //# sourceMappingURL=index.mjs.map