ic-mops 1.12.0 → 2.0.0

package/dist/commands/init.js

@@ -1,39 +1,39 @@
-import process from 'node:process';
-import { execSync } from 'node:child_process';
-import path from 'node:path';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import chalk from 'chalk';
-import prompts from 'prompts';
-import { checkApiCompatibility, writeConfig } from '../mops.js';
-import { mainActor } from '../api/actors.js';
-import { installAll } from './install/install-all.js';
-import { readVesselConfig } from '../vessel.js';
-import { template } from './template.js';
-import { kebabCase } from 'change-case';
+import process from "node:process";
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import chalk from "chalk";
+import prompts from "prompts";
+import { checkApiCompatibility, writeConfig } from "../mops.js";
+import { mainActor } from "../api/actors.js";
+import { installAll } from "./install/install-all.js";
+import { readVesselConfig } from "../vessel.js";
+import { template } from "./template.js";
+import { kebabCase } from "change-case";
 export async function init({ yes = false } = {}) {
-    let configFile = path.join(process.cwd(), 'mops.toml');
+    let configFile = path.join(process.cwd(), "mops.toml");
     let exists = existsSync(configFile);
     if (exists) {
-        console.log(chalk.yellow('mops.toml already exists'));
+        console.log(chalk.yellow("mops.toml already exists"));
         return;
     }
-    console.log('Initializing...');
+    console.log("Initializing...");
     let config = {};
     if (yes) {
         await applyInit({
-            type: 'project',
+            type: "project",
             config,
             setupWorkflow: true,
             addTest: false,
-            copyrightOwner: '',
+            copyrightOwner: "",
         });
         return;
     }
     // migrate from vessel
-    let vesselFile = path.join(process.cwd(), 'vessel.dhall');
-    let vesselConfig = { dependencies: [], 'dev-dependencies': [] };
+    let vesselFile = path.join(process.cwd(), "vessel.dhall");
+    let vesselConfig = { dependencies: [], "dev-dependencies": [] };
     if (existsSync(vesselFile)) {
-        console.log('Reading vessel.dhall file');
+        console.log("Reading vessel.dhall file");
         let res = await readVesselConfig(process.cwd(), { cache: false });
         if (res) {
             vesselConfig = { ...res };
@@ -42,7 +42,7 @@ export async function init({ yes = false } = {}) {
     if (vesselConfig.dependencies) {
         let deps = {};
         deps = {};
-        for (const dep of (vesselConfig.dependencies || [])) {
+        for (const dep of vesselConfig.dependencies || []) {
             deps[dep.name] = dep;
         }
         if (Object.keys(deps).length) {
@@ -51,88 +51,96 @@ export async function init({ yes = false } = {}) {
     }
     let promptsConfig = {
         onCancel() {
-            console.log('aborted');
+            console.log("aborted");
             process.exit(0);
         },
     };
     // type
     let { type } = await prompts({
-        type: 'select',
-        name: 'type',
-        message: 'Select type:',
+        type: "select",
+        name: "type",
+        message: "Select type:",
         choices: [
-            { title: `Project ${chalk.dim('(I just want to use mops packages in my project)')}`, value: 'project' },
-            { title: `Package ${chalk.dim('(I plan to publish this package on mops)')}`, value: 'package' },
+            {
+                title: `Project ${chalk.dim("(I just want to use mops packages in my project)")}`,
+                value: "project",
+            },
+            {
+                title: `Package ${chalk.dim("(I plan to publish this package on mops)")}`,
+                value: "package",
+            },
         ],
     }, promptsConfig);
     let addTest = false;
-    let copyrightOwner = '';
+    let copyrightOwner = "";
     // package details
-    if (type === 'package') {
+    if (type === "package") {
         let res = await prompts([
             {
-                type: 'text',
-                name: 'name',
-                message: 'Enter package name:',
+                type: "text",
+                name: "name",
+                message: "Enter package name:",
                 initial: kebabCase(path.basename(process.cwd())),
             },
             {
-                type: 'text',
-                name: 'description',
-                message: 'Enter package description:',
-                initial: '',
+                type: "text",
+                name: "description",
+                message: "Enter package description:",
+                initial: "",
             },
             {
-                type: 'text',
-                name: 'repository',
-                message: 'Enter package repository url:',
-                initial: '',
+                type: "text",
+                name: "repository",
+                message: "Enter package repository url:",
+                initial: "",
             },
             {
-                type: 'text',
-                name: 'keywords',
-                message: 'Enter keywords separated by spaces:',
-                initial: '',
+                type: "text",
+                name: "keywords",
+                message: "Enter keywords separated by spaces:",
+                initial: "",
             },
             {
-                type: 'select',
-                name: 'license',
-                message: 'Choose a license:',
+                type: "select",
+                name: "license",
+                message: "Choose a license:",
                 choices: [
-                    { title: 'MIT', value: 'MIT' },
-                    { title: 'Apache-2.0', value: 'Apache-2.0' },
+                    { title: "MIT", value: "MIT" },
+                    { title: "Apache-2.0", value: "Apache-2.0" },
                 ],
                 initial: 0,
             },
             {
-                type: 'text',
-                name: 'copyrightOwner',
-                message: 'Enter license copyright owner:',
-                initial: '',
+                type: "text",
+                name: "copyrightOwner",
+                message: "Enter license copyright owner:",
+                initial: "",
             },
             {
-                type: 'confirm',
-                name: 'addTest',
-                message: `Add example test file? ${chalk.dim('(test/lib.test.mo)')}`,
+                type: "confirm",
+                name: "addTest",
+                message: `Add example test file? ${chalk.dim("(test/lib.test.mo)")}`,
                 initial: true,
             },
         ], promptsConfig);
         config.package = {
-            name: kebabCase((res.name || '').trim()),
-            version: '1.0.0',
-            description: (res.description || '').trim(),
-            repository: (res.repository || '').trim(),
-            keywords: [...new Set(res.keywords.split(' ').filter(Boolean))],
-            license: (res.license || '').trim(),
+            name: kebabCase((res.name || "").trim()),
+            version: "1.0.0",
+            description: (res.description || "").trim(),
+            repository: (res.repository || "").trim(),
+            keywords: [
+                ...new Set(res.keywords.split(" ").filter(Boolean)),
+            ],
+            license: (res.license || "").trim(),
         };
         addTest = res.addTest;
         copyrightOwner = res.copyrightOwner;
     }
     // GitHub workflow
     let { setupWorkflow } = await prompts({
-        type: 'confirm',
-        name: 'setupWorkflow',
-        message: `Setup GitHub workflow? ${chalk.dim('(run `mops test` on push)')}`,
+        type: "confirm",
+        name: "setupWorkflow",
+        message: `Setup GitHub workflow? ${chalk.dim("(run `mops test` on push)")}`,
         initial: true,
     }, promptsConfig);
     await applyInit({
@@ -143,9 +151,9 @@ export async function init({ yes = false } = {}) {
         copyrightOwner,
     });
 }
-async function applyInit({ type, config, setupWorkflow, addTest, copyrightOwner }) {
+async function applyInit({ type, config, setupWorkflow, addTest, copyrightOwner, }) {
     // set packtool in dfx.json
-    let dfxJson = path.resolve(process.cwd(), 'dfx.json');
+    let dfxJson = path.resolve(process.cwd(), "dfx.json");
     let dfxJsonData;
     if (existsSync(dfxJson)) {
         let dfxJsonText = readFileSync(dfxJson).toString();
@@ -153,30 +161,30 @@ async function applyInit({ type, config, setupWorkflow, addTest, copyrightOwner
             dfxJsonData = JSON.parse(dfxJsonText);
         }
         catch (err) {
-            console.log(chalk.yellow('Failed to parse dfx.json'));
+            console.log(chalk.yellow("Failed to parse dfx.json"));
         }
         if (dfxJsonData) {
-            console.log('Setting packtool in dfx.json...');
+            console.log("Setting packtool in dfx.json...");
             dfxJsonData.defaults = dfxJsonData.defaults || {};
             dfxJsonData.defaults.build = dfxJsonData.defaults.build || {};
-            if (dfxJsonData.defaults.build.packtool !== 'mops sources') {
-                dfxJsonData.defaults.build.packtool = 'mops sources';
-                let indent = dfxJsonText.match(/([ \t]+)"/)?.[1] || '  ';
-                writeFileSync(path.join(process.cwd(), 'dfx.json'), JSON.stringify(dfxJsonData, null, indent));
+            if (dfxJsonData.defaults.build.packtool !== "mops sources") {
+                dfxJsonData.defaults.build.packtool = "mops sources";
+                let indent = dfxJsonText.match(/([ \t]+)"/)?.[1] || "  ";
+                writeFileSync(path.join(process.cwd(), "dfx.json"), JSON.stringify(dfxJsonData, null, indent));
                 console.log(chalk.green('packtool set to "mops sources"'));
             }
         }
     }
     // get default packages
-    if (type === 'project') {
+    if (type === "project") {
         let compatible = await checkApiCompatibility();
         if (!compatible) {
             return;
         }
-        let dfxVersion = dfxJsonData?.dfx || '';
+        let dfxVersion = dfxJsonData?.dfx || "";
         if (!dfxVersion) {
             try {
-                let res = execSync('dfx --version').toString();
+                let res = execSync("dfx --version").toString();
                 let match = res.match(/\d+\.\d+\.\d+/);
                 if (match) {
                     dfxVersion = match[0];
@@ -195,43 +203,45 @@ async function applyInit({ type, config, setupWorkflow, addTest, copyrightOwner
         }
     }
     // save config
-    let configFile = path.join(process.cwd(), 'mops.toml');
+    let configFile = path.join(process.cwd(), "mops.toml");
     writeConfig(config, configFile);
-    console.log(chalk.green('Created'), 'mops.toml');
+    console.log(chalk.green("Created"), "mops.toml");
     // add src/lib.mo
-    if (type === 'package' && !existsSync(path.join(process.cwd(), 'src'))) {
-        await template('lib.mo');
+    if (type === "package" && !existsSync(path.join(process.cwd(), "src"))) {
+        await template("lib.mo");
     }
     // add src/lib.test.mo
-    if (addTest && !existsSync(path.join(process.cwd(), 'test'))) {
-        await template('lib.test.mo');
+    if (addTest && !existsSync(path.join(process.cwd(), "test"))) {
+        await template("lib.test.mo");
     }
     // add license
     if (config.package?.license) {
         await template(`license:${config.package.license}`, { copyrightOwner });
     }
     // add readme
-    if (type === 'package') {
-        await template('readme');
+    if (type === "package") {
+        await template("readme");
     }
     // add GitHub workflow
     if (setupWorkflow) {
-        await template('github-workflow:mops-test');
+        await template("github-workflow:mops-test");
     }
     // add .mops to .gitignore
     {
-        let gitignore = path.join(process.cwd(), '.gitignore');
-        let gitignoreData = existsSync(gitignore) ? readFileSync(gitignore).toString() : '';
-        let lf = gitignoreData.endsWith('\n') ? '\n' : '';
-        if (!gitignoreData.includes('.mops')) {
+        let gitignore = path.join(process.cwd(), ".gitignore");
+        let gitignoreData = existsSync(gitignore)
+            ? readFileSync(gitignore).toString()
+            : "";
+        let lf = gitignoreData.endsWith("\n") ? "\n" : "";
+        if (!gitignoreData.includes(".mops")) {
             writeFileSync(gitignore, `${gitignoreData}\n.mops${lf}`.trimStart());
-            console.log(chalk.green('Added'), '.mops to .gitignore');
+            console.log(chalk.green("Added"), ".mops to .gitignore");
         }
     }
     // install deps
     if (Object.keys(config.dependencies || {}).length) {
-        console.log('Installing dependencies...');
+        console.log("Installing dependencies...");
         await installAll({ verbose: true });
     }
-    console.log(chalk.green('Done!'));
+    console.log(chalk.green("Done!"));
 }

package/dist/commands/install/install-all.d.ts

@@ -1,9 +1,9 @@
 type InstallAllOptions = {
     verbose?: boolean;
     silent?: boolean;
-    lock?: 'check' | 'update' | 'ignore';
+    lock?: "check" | "update" | "ignore";
     threads?: number;
     installFromLockFile?: boolean;
 };
-export declare function installAll({ verbose, silent, threads, lock, installFromLockFile }?: InstallAllOptions): Promise<boolean>;
+export declare function installAll({ verbose, silent, threads, lock, installFromLockFile, }?: InstallAllOptions): Promise<boolean>;
 export {};

package/dist/commands/install/install-all.js

@@ -1,31 +1,36 @@
-import process from 'node:process';
-import chalk from 'chalk';
-import { createLogUpdate } from 'log-update';
-import { checkConfigFile, parseDepValue, readConfig } from '../../mops.js';
-import { checkIntegrity, checkLockFileLight, readLockFile } from '../../integrity.js';
-import { installDeps } from './install-deps.js';
-import { checkRequirements } from '../../check-requirements.js';
-import { syncLocalCache } from './sync-local-cache.js';
-import { notifyInstalls } from '../../notify-installs.js';
-export async function installAll({ verbose = false, silent = false, threads, lock, installFromLockFile } = {}) {
+import process from "node:process";
+import chalk from "chalk";
+import { createLogUpdate } from "log-update";
+import { checkConfigFile, parseDepValue, readConfig } from "../../mops.js";
+import { checkIntegrity, checkLockFileLight, readLockFile, } from "../../integrity.js";
+import { installDeps } from "./install-deps.js";
+import { checkRequirements } from "../../check-requirements.js";
+import { syncLocalCache } from "./sync-local-cache.js";
+import { notifyInstalls } from "../../notify-installs.js";
+export async function installAll({ verbose = false, silent = false, threads, lock, installFromLockFile, } = {}) {
     if (!checkConfigFile()) {
         return false;
     }
     let config = readConfig();
     let deps = Object.values(config.dependencies || {});
-    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let devDeps = Object.values(config["dev-dependencies"] || {});
     let allDeps = [...deps, ...devDeps];
     let installedFromLockFile = false;
     // install from lock file to avoid installing intermediate dependencies
-    if ((lock !== 'ignore' || installFromLockFile) && checkLockFileLight()) {
+    if ((lock !== "ignore" || installFromLockFile) && checkLockFileLight()) {
         let lockFileJson = readLockFile();
         if (lockFileJson && lockFileJson.version === 3) {
-            verbose && console.log('Installing from lock file...');
+            verbose && console.log("Installing from lock file...");
             installedFromLockFile = true;
             let lockedDeps = Object.entries(lockFileJson.deps).map(([name, version]) => {
                 return parseDepValue(name, version);
             });
-            let ok = await installDeps(lockedDeps, { silent, verbose, threads, ignoreTransitive: true });
+            let ok = await installDeps(lockedDeps, {
+                silent,
+                verbose,
+                threads,
+                ignoreTransitive: true,
+            });
             if (!ok) {
                 return false;
             }
@@ -38,18 +43,15 @@ export async function installAll({ verbose = false, silent = false, threads, loc
         }
     }
     let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
-    if (!silent && lock !== 'ignore') {
-        logUpdate('Checking integrity...');
+    if (!silent && lock !== "ignore") {
+        logUpdate("Checking integrity...");
     }
     let installedPackages = await syncLocalCache({ verbose });
-    await Promise.all([
-        notifyInstalls(installedPackages),
-        checkIntegrity(lock),
-    ]);
+    await Promise.all([notifyInstalls(installedPackages), checkIntegrity(lock)]);
     if (!silent) {
         logUpdate.clear();
         await checkRequirements();
-        console.log(chalk.green('Packages installed'));
+        console.log(chalk.green("Packages installed"));
     }
     return true;
 }

package/dist/commands/install/install-dep.d.ts

@@ -1,4 +1,4 @@
-import { Dependency } from '../../types.js';
+import { Dependency } from "../../types.js";
 type InstallDepOptions = {
     verbose?: boolean;
     silent?: boolean;

package/dist/commands/install/install-dep.js

@@ -1,13 +1,17 @@
-import path from 'node:path';
-import { installFromGithub } from '../../vessel.js';
-import { installMopsDep } from './install-mops-dep.js';
-import { installLocalDep } from './install-local-dep.js';
-import { getRootDir } from '../../mops.js';
+import path from "node:path";
+import { installFromGithub } from "../../vessel.js";
+import { installMopsDep } from "./install-mops-dep.js";
+import { installLocalDep } from "./install-local-dep.js";
+import { getRootDir } from "../../mops.js";
 // install dependency
 // returns false if failed
 export async function installDep(dep, { verbose, silent, threads, ignoreTransitive } = {}, parentPkgPath) {
     if (dep.repo) {
-        await installFromGithub(dep.name, dep.repo, { silent, verbose, ignoreTransitive });
+        await installFromGithub(dep.name, dep.repo, {
+            silent,
+            verbose,
+            ignoreTransitive,
+        });
         return true;
     }
     else if (dep.path) {
@@ -16,10 +20,19 @@ export async function installDep(dep, { verbose, silent, threads, ignoreTransiti
         if (parentPkgPath) {
             depPath = path.resolve(parentPkgPath, dep.path);
         }
-        return installLocalDep(dep.name, depPath, { silent, verbose, ignoreTransitive });
+        return installLocalDep(dep.name, depPath, {
+            silent,
+            verbose,
+            ignoreTransitive,
+        });
     }
     else if (dep.version) {
-        return installMopsDep(dep.name, dep.version, { silent, verbose, threads, ignoreTransitive });
+        return installMopsDep(dep.name, dep.version, {
+            silent,
+            verbose,
+            threads,
+            ignoreTransitive,
+        });
     }
     return true;
 }

package/dist/commands/install/install-deps.d.ts

@@ -1,4 +1,4 @@
-import { Dependency } from '../../types.js';
+import { Dependency } from "../../types.js";
 type InstallDepsOptions = {
     verbose?: boolean;
     silent?: boolean;

package/dist/commands/install/install-deps.js

@@ -1,4 +1,4 @@
-import { installDep } from './install-dep.js';
+import { installDep } from "./install-dep.js";
 // install all dependencies
 // returns actual installed dependencies
 // returns false if failed

package/dist/commands/install/install-local-dep.js

@@ -1,12 +1,12 @@
-import process from 'node:process';
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { createLogUpdate } from 'log-update';
-import { getRootDir, readConfig } from '../../mops.js';
-import { installDeps } from './install-deps.js';
+import process from "node:process";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { createLogUpdate } from "log-update";
+import { getRootDir, readConfig } from "../../mops.js";
+import { installDeps } from "./install-deps.js";
 // skip install and just find non-local dependencies to install
 // pkgPath should be relative to the current root dir or absolute
-export async function installLocalDep(pkg, pkgPath = '', { verbose, silent, ignoreTransitive } = {}) {
+export async function installLocalDep(pkg, pkgPath = "", { verbose, silent, ignoreTransitive } = {}) {
     if (!silent) {
         let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
         logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
@@ -19,8 +19,10 @@ export async function installLocalDep(pkg, pkgPath = '', { verbose, silent, igno
     }
     // install dependencies
     if (!ignoreTransitive) {
-        let dir = path.resolve(getRootDir(), pkgPath).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
-        let mopsToml = path.join(dir, 'mops.toml');
+        let dir = path
+            .resolve(getRootDir(), pkgPath)
+            .replaceAll("{MOPS_ENV}", process.env.MOPS_ENV || "local");
+        let mopsToml = path.join(dir, "mops.toml");
         if (!existsSync(mopsToml)) {
             return true;
         }

package/dist/commands/install/install-mops-dep.d.ts

@@ -5,5 +5,5 @@ type InstallMopsDepOptions = {
     threads?: number;
     ignoreTransitive?: boolean;
 };
-export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads, ignoreTransitive }?: InstallMopsDepOptions): Promise<boolean>;
+export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads, ignoreTransitive, }?: InstallMopsDepOptions): Promise<boolean>;
 export {};

package/dist/commands/install/install-mops-dep.js

@@ -1,19 +1,19 @@
-import process from 'node:process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { Buffer } from 'node:buffer';
-import { createLogUpdate } from 'log-update';
-import chalk from 'chalk';
-import { deleteSync } from 'del';
-import { checkConfigFile, progressBar, readConfig } from '../../mops.js';
-import { getHighestVersion } from '../../api/getHighestVersion.js';
-import { storageActor } from '../../api/actors.js';
-import { parallel } from '../../parallel.js';
-import { getDepCacheDir, getMopsDepCacheName, isDepCached } from '../../cache.js';
-import { downloadFile, getPackageFilesInfo } from '../../api/downloadPackageFiles.js';
-import { installDeps } from './install-deps.js';
-import { getDepName } from '../../helpers/get-dep-name.js';
-export async function installMopsDep(pkg, version = '', { verbose, silent, dep, threads, ignoreTransitive } = {}) {
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import { createLogUpdate } from "log-update";
+import chalk from "chalk";
+import { deleteSync } from "del";
+import { checkConfigFile, progressBar, readConfig } from "../../mops.js";
+import { getHighestVersion } from "../../api/getHighestVersion.js";
+import { storageActor } from "../../api/actors.js";
+import { parallel } from "../../parallel.js";
+import { getDepCacheDir, getMopsDepCacheName, isDepCached, } from "../../cache.js";
+import { downloadFile, getPackageFilesInfo, } from "../../api/downloadPackageFiles.js";
+import { installDeps } from "./install-deps.js";
+import { getDepName } from "../../helpers/get-dep-name.js";
+export async function installMopsDep(pkg, version = "", { verbose, silent, dep, threads, ignoreTransitive, } = {}) {
     threads = threads || 12;
     let depName = getDepName(pkg);
     if (!checkConfigFile()) {
@@ -25,13 +25,14 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
     let step = 0;
     let progress = () => {
         step++;
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${depName}@${version} ${progressBar(step, total)}`);
+        silent ||
+            logUpdate(`${dep ? "Dependency" : "Installing"} ${depName}@${version} ${progressBar(step, total)}`);
     };
     progress();
     if (!version) {
         let versionRes = await getHighestVersion(depName);
-        if ('err' in versionRes) {
-            console.log(chalk.red('Error: ') + versionRes.err);
+        if ("err" in versionRes) {
+            console.log(chalk.red("Error: ") + versionRes.err);
             return false;
         }
         version = versionRes.ok;
@@ -40,7 +41,8 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
     let cacheDir = getDepCacheDir(cacheName);
     // global cache hit
     if (isDepCached(cacheName)) {
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${depName}@${version} (cache)`);
+        silent ||
+            logUpdate(`${dep ? "Dependency" : "Installing"} ${depName}@${version} (cache)`);
     }
     // download
     else {
@@ -51,7 +53,7 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
         try {
             let { storageId, fileIds } = await getPackageFilesInfo(depName, version);
             total = fileIds.length + 2;
-            let filesData = new Map;
+            let filesData = new Map();
             let storage = await storageActor(storageId);
             await parallel(threads, fileIds, async (fileId) => {
                 let { path, data } = await downloadFile(storage, fileId);
@@ -62,7 +64,7 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
                 deleteSync([cacheDir], { force: true });
                 process.exit();
             };
-            process.on('SIGINT', onSigInt);
+            process.on("SIGINT", onSigInt);
             // write files to global cache
             try {
                 await Promise.all(Array.from(filesData.entries()).map(async ([filePath, data]) => {
@@ -71,14 +73,14 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
                 }));
             }
             catch (err) {
-                console.error(chalk.red('Error: ') + err);
+                console.error(chalk.red("Error: ") + err);
                 deleteSync([cacheDir], { force: true });
                 return false;
             }
-            process.off('SIGINT', onSigInt);
+            process.off("SIGINT", onSigInt);
         }
         catch (err) {
-            console.error(chalk.red('Error: ') + err);
+            console.error(chalk.red("Error: ") + err);
             return false;
         }
         progress();
@@ -91,8 +93,11 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
     }
     // install dependencies
     if (!ignoreTransitive) {
-        let config = readConfig(path.join(cacheDir, 'mops.toml'));
-        let res = await installDeps(Object.values(config.dependencies || {}), { silent, verbose });
+        let config = readConfig(path.join(cacheDir, "mops.toml"));
+        let res = await installDeps(Object.values(config.dependencies || {}), {
+            silent,
+            verbose,
+        });
         if (!res) {
             return false;
         }