ic-mops 1.12.0 → 2.0.0

package/dist/commands/bump.js

@@ -1,30 +1,39 @@
-import process from 'node:process';
-import prompts from 'prompts';
-import chalk from 'chalk';
-import { checkConfigFile, readConfig, writeConfig } from '../mops.js';
+import process from "node:process";
+import prompts from "prompts";
+import chalk from "chalk";
+import { checkConfigFile, readConfig, writeConfig } from "../mops.js";
 export async function bump(part) {
     if (!checkConfigFile()) {
         return;
     }
-    if (part && !['major', 'minor', 'patch'].includes(part)) {
-        console.log(chalk.red('Unknown version part. Available parts: major, minor, patch'));
+    if (part && !["major", "minor", "patch"].includes(part)) {
+        console.log(chalk.red("Unknown version part. Available parts: major, minor, patch"));
         process.exit(1);
     }
     let config = readConfig();
     if (!config.package) {
-        console.log(chalk.red('No [package] section found in mops.toml.'));
+        console.log(chalk.red("No [package] section found in mops.toml."));
         process.exit(1);
     }
     console.log(`Current version: ${chalk.yellow.bold(config.package.version)}`);
     if (!part) {
         let res = await prompts({
-            type: 'select',
-            name: 'part',
-            message: 'Select new version:',
+            type: "select",
+            name: "part",
+            message: "Select new version:",
             choices: [
-                { title: `${updateVersion(config.package.version, 'major')} ${chalk.dim('(major, breaking changes)')}`, value: 'major' },
-                { title: `${updateVersion(config.package.version, 'minor')} ${chalk.dim('(minor, new features)')}`, value: 'minor' },
-                { title: `${updateVersion(config.package.version, 'patch')} ${chalk.dim('(patch, bug fixes)')}`, value: 'patch' },
+                {
+                    title: `${updateVersion(config.package.version, "major")} ${chalk.dim("(major, breaking changes)")}`,
+                    value: "major",
+                },
+                {
+                    title: `${updateVersion(config.package.version, "minor")} ${chalk.dim("(minor, new features)")}`,
+                    value: "minor",
+                },
+                {
+                    title: `${updateVersion(config.package.version, "patch")} ${chalk.dim("(patch, bug fixes)")}`,
+                    value: "patch",
+                },
             ],
             initial: 2,
         });
@@ -38,14 +47,14 @@ export async function bump(part) {
     console.log(`Updated version: ${chalk.green.bold(config.package.version)}`);
 }
 function updateVersion(version, part) {
-    let parts = version.split('.');
-    let idx = ['major', 'minor', 'patch'].indexOf(part);
+    let parts = version.split(".");
+    let idx = ["major", "minor", "patch"].indexOf(part);
     if (!parts[idx]) {
         throw new Error(`Invalid version part: ${part}`);
     }
-    parts[idx] = String(parseInt(parts[idx] || '0') + 1);
+    parts[idx] = String(parseInt(parts[idx] || "0") + 1);
     for (let i = idx + 1; i < parts.length; i++) {
-        parts[i] = '0';
+        parts[i] = "0";
     }
-    return parts.join('.');
+    return parts.join(".");
 }

package/dist/commands/check-candid.d.ts

@@ -0,0 +1,4 @@
+export interface CheckCandidOptions {
+    verbose?: boolean;
+}
+export declare function checkCandid(newPath: string, originalPath: string): Promise<void>;

package/dist/commands/check-candid.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
+import { cliError } from "../error.js";
+export async function checkCandid(newPath, originalPath) {
+    try {
+        const compatible = await isCandidCompatible(newPath, originalPath);
+        if (!compatible) {
+            cliError("✖ Candid compatibility check failed");
+        }
+        console.log(chalk.green("✓ Candid compatibility check passed"));
+    }
+    catch (error) {
+        cliError(`Error while checking Candid compatibility${error?.message ? `\n${error.message}` : ""}`);
+    }
+}

package/dist/commands/docs-coverage.d.ts

@@ -1,4 +1,4 @@
-export type DocsCoverageReporter = 'compact' | 'files' | 'missing' | 'verbose' | 'silent';
+export type DocsCoverageReporter = "compact" | "files" | "missing" | "verbose" | "silent";
 type DocsCoverageOptions = {
     source: string;
     reporter: DocsCoverageReporter;

package/dist/commands/docs-coverage.js

@@ -1,51 +1,55 @@
-import { readFileSync } from 'node:fs';
-import chalk from 'chalk';
-import { globSync } from 'glob';
-import { JSDOM } from 'jsdom';
-import { docs } from './docs.js';
+import { readFileSync } from "node:fs";
+import chalk from "chalk";
+import { globSync } from "glob";
+import { JSDOM } from "jsdom";
+import { docs } from "./docs.js";
 export async function docsCoverage(options = {}) {
-    let docsDir = '.mops/.docs';
+    let docsDir = ".mops/.docs";
     let { source, reporter, threshold } = {
-        source: 'src',
-        reporter: 'files',
+        source: "src",
+        reporter: "files",
         threshold: 0,
         ...options,
     };
     await docs({
         source,
         output: docsDir,
-        format: 'html',
+        format: "html",
         silent: true,
     });
-    let files = globSync(`${docsDir}/**/*.html`, { ignore: [`${docsDir}/**/index.html`] });
+    let files = globSync(`${docsDir}/**/*.html`, {
+        ignore: [`${docsDir}/**/index.html`],
+    });
     let coverages = [];
     for (let file of files) {
         let coverage = docFileCoverage(file);
         coverages.push(coverage);
-        if (reporter === 'silent') {
+        if (reporter === "silent") {
             continue;
         }
-        if (reporter !== 'compact' && (reporter !== 'missing' || coverage.coverage < 100)) {
+        if (reporter !== "compact" &&
+            (reporter !== "missing" || coverage.coverage < 100)) {
             console.log(`• ${coverage.file} ${colorizeCoverage(coverage.coverage)}`);
         }
-        if (reporter === 'missing' && coverage.coverage < 100) {
+        if (reporter === "missing" && coverage.coverage < 100) {
             for (let item of coverage.items) {
                 if (!item.covered) {
-                    console.log(`  ${item.covered ? chalk.green('✓') : chalk.red('✖')} ${item.id} ${chalk.gray(item.type)}`);
+                    console.log(`  ${item.covered ? chalk.green("✓") : chalk.red("✖")} ${item.id} ${chalk.gray(item.type)}`);
                 }
             }
         }
-        else if (reporter === 'verbose') {
+        else if (reporter === "verbose") {
             for (let item of coverage.items) {
-                console.log(`  ${item.covered ? chalk.green('✓') : chalk.red('✖')} ${item.id} ${chalk.gray(item.type)}`);
+                console.log(`  ${item.covered ? chalk.green("✓") : chalk.red("✖")} ${item.id} ${chalk.gray(item.type)}`);
             }
         }
     }
-    if (reporter !== 'compact' && reporter !== 'silent') {
-        console.log('-'.repeat(50));
+    if (reporter !== "compact" && reporter !== "silent") {
+        console.log("-".repeat(50));
     }
-    let totalCoverage = coverages.reduce((acc, coverage) => acc + coverage.coverage, 0) / (coverages.length || 1);
-    if (reporter !== 'silent') {
+    let totalCoverage = coverages.reduce((acc, coverage) => acc + coverage.coverage, 0) /
+        (coverages.length || 1);
+    if (reporter !== "silent") {
         console.log(`Documentation coverage: ${colorizeCoverage(totalCoverage)}`);
     }
     if (threshold > 0 && totalCoverage < threshold) {
@@ -54,33 +58,43 @@ export async function docsCoverage(options = {}) {
     return totalCoverage;
 }
 function docFileCoverage(file) {
-    let dom = new JSDOM(readFileSync(file, 'utf-8'));
-    let module = dom.window.document.querySelector('h1')?.textContent || '';
+    let dom = new JSDOM(readFileSync(file, "utf-8"));
+    let module = dom.window.document.querySelector("h1")?.textContent || "";
     let moduleFile = `${module}.mo`;
-    let items = [...dom.window.document.querySelectorAll('h4')].map(h4 => {
-        let id = h4.getAttribute('id')?.replace('type.', '');
-        let type = h4.className.replace('-declaration', '').replace('function', 'func');
+    let items = [...dom.window.document.querySelectorAll("h4")].map((h4) => {
+        let id = h4.getAttribute("id")?.replace("type.", "");
+        let type = h4.className
+            .replace("-declaration", "")
+            .replace("function", "func");
         let definition = h4.textContent;
-        let comment = h4.parentElement?.querySelector('p + p')?.textContent;
-        return { file: moduleFile, id, type, definition, comment, covered: (comment || '').length >= 5 };
+        let comment = h4.parentElement?.querySelector("p + p")?.textContent;
+        return {
+            file: moduleFile,
+            id,
+            type,
+            definition,
+            comment,
+            covered: (comment || "").length >= 5,
+        };
     });
     let coverage = 0;
     if (!items.length) {
         coverage = 100;
     }
     else {
-        coverage = items.filter(item => item.covered).length / items.length * 100;
+        coverage =
+            (items.filter((item) => item.covered).length / items.length) * 100;
     }
     return { file: moduleFile, coverage, items };
 }
 function colorizeCoverage(coverage) {
     if (coverage >= 90) {
-        return chalk.green(coverage.toFixed(2) + '%');
+        return chalk.green(coverage.toFixed(2) + "%");
     }
     else if (coverage >= 50) {
-        return chalk.yellow(coverage.toFixed(2) + '%');
+        return chalk.yellow(coverage.toFixed(2) + "%");
     }
     else {
-        return chalk.red(coverage.toFixed(2) + '%');
+        return chalk.red(coverage.toFixed(2) + "%");
     }
 }

package/dist/commands/docs.d.ts

@@ -1,7 +1,7 @@
 type DocsOptions = {
     source: string;
     output: string;
-    format: 'md' | 'adoc' | 'html';
+    format: "md" | "adoc" | "html";
     silent: boolean;
     archive: boolean;
 };

package/dist/commands/docs.js

@@ -1,39 +1,40 @@
-import process from 'node:process';
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import chalk from 'chalk';
-import { globSync } from 'glob';
-import { deleteSync } from 'del';
-import { create as createTar } from 'tar';
-import streamToPromise from 'stream-to-promise';
-import { getRootDir } from '../mops.js';
-import { toolchain } from './toolchain/index.js';
+import process from "node:process";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { globSync } from "glob";
+import { deleteSync } from "del";
+import { create as createTar } from "tar";
+import streamToPromise from "stream-to-promise";
+import { getRootDir } from "../mops.js";
+import { toolchain } from "./toolchain/index.js";
 let moDocPath;
 export async function docs(options = {}) {
     let { source, output, format, silent, archive } = {
-        source: 'src',
-        output: '.mops/.docs',
-        format: 'adoc',
+        source: "src",
+        output: ".mops/.docs",
+        format: "adoc",
         silent: false,
         archive: false,
         ...options,
     };
-    if (format === 'md') {
-        format = 'plain';
+    if (format === "md") {
+        format = "plain";
     }
     let rootDir = getRootDir();
     let docsDir = path.join(rootDir, output);
     let docsDirRelative = path.relative(process.cwd(), docsDir);
     deleteSync([docsDir], { force: true });
     // detect mocv (legacy)
-    if (process.env.DFX_MOC_PATH && process.env.DFX_MOC_PATH.includes('mocv/versions')) {
-        moDocPath = process.env.DFX_MOC_PATH.replace(/\/moc$/, '/mo-doc');
+    if (process.env.DFX_MOC_PATH &&
+        process.env.DFX_MOC_PATH.includes("mocv/versions")) {
+        moDocPath = process.env.DFX_MOC_PATH.replace(/\/moc$/, "/mo-doc");
     }
     else {
         // fallbacks to dfx moc if not specified in config
-        let mocPath = await toolchain.bin('moc', { fallback: true });
-        moDocPath = mocPath.replace(/\/moc$/, '/mo-doc');
+        let mocPath = await toolchain.bin("moc", { fallback: true });
+        moDocPath = mocPath.replace(/\/moc$/, "/mo-doc");
     }
     // generate docs
     await new Promise((resolve) => {
@@ -43,37 +44,39 @@ export async function docs(options = {}) {
             `--format=${format}`,
         ]);
         // stdout
-        proc.stdout.on('data', (data) => {
+        proc.stdout.on("data", (data) => {
             let text = data.toString().trim();
-            let failedText = 'Failed to extract documentation';
+            let failedText = "Failed to extract documentation";
             if (text.includes(failedText)) {
-                silent || console.log(text.replaceAll(failedText, chalk.yellow('Warning: ') + failedText));
+                silent ||
+                    console.log(text.replaceAll(failedText, chalk.yellow("Warning: ") + failedText));
             }
-            silent || console.log('stdout', text);
+            silent || console.log("stdout", text);
         });
         // stderr
-        let stderr = '';
-        proc.stderr.on('data', (data) => {
+        let stderr = "";
+        proc.stderr.on("data", (data) => {
             let text = data.toString().trim();
-            if (text.includes('syntax error')) {
-                console.log(chalk.red('Error:'), text);
+            if (text.includes("syntax error")) {
+                console.log(chalk.red("Error:"), text);
                 process.exit(1);
             }
-            if (text.includes('No such file or directory') || text.includes('Couldn\'t find a module expression')) {
+            if (text.includes("No such file or directory") ||
+                text.includes("Couldn't find a module expression")) {
                 silent || console.log(text);
                 return;
             }
             stderr += text;
         });
         // exit
-        proc.on('exit', (code) => {
+        proc.on("exit", (code) => {
             // if no source files found
             if (code === 2 && !stderr) {
                 resolve();
                 return;
             }
             if (code !== 0) {
-                console.log(chalk.red('Error:'), code, stderr);
+                console.log(chalk.red("Error:"), code, stderr);
                 process.exit(1);
             }
             resolve();
@@ -81,20 +84,18 @@ export async function docs(options = {}) {
     });
     // create archive
     if (archive) {
-        let ignore = [
-            `${docsDir}/**/*.test.adoc`,
-            `${docsDir}/test/**/*`,
-        ];
-        let files = globSync(`${docsDir}/**/*.adoc`, { ignore }).map(f => path.relative(docsDir, f));
+        let ignore = [`${docsDir}/**/*.test.adoc`, `${docsDir}/test/**/*`];
+        let files = globSync(`${docsDir}/**/*.adoc`, { ignore }).map((f) => path.relative(docsDir, f));
         files.sort();
         if (files.length) {
             let stream = createTar({
                 cwd: docsDir,
                 gzip: true,
                 portable: true,
-            }, files).pipe(fs.createWriteStream(path.join(docsDir, 'docs.tgz')));
+            }, files).pipe(fs.createWriteStream(path.join(docsDir, "docs.tgz")));
             await streamToPromise(stream);
         }
     }
-    silent || console.log(`${chalk.green('Documentation generated')} at ${docsDirRelative}`);
+    silent ||
+        console.log(`${chalk.green("Documentation generated")} at ${docsDirRelative}`);
 }

package/dist/commands/format.js

@@ -1,18 +1,18 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { globSync } from 'glob';
-import chalk from 'chalk';
-import * as prettier from 'prettier';
-import motokoPlugin from 'prettier-plugin-motoko';
-import { getRootDir } from '../mops.js';
-import { absToRel } from './test/utils.js';
-import { parallel } from '../parallel.js';
+import fs from "node:fs/promises";
+import path from "node:path";
+import { globSync } from "glob";
+import chalk from "chalk";
+import * as prettier from "prettier";
+import motokoPlugin from "prettier-plugin-motoko";
+import { getRootDir } from "../mops.js";
+import { absToRel } from "./test/utils.js";
+import { parallel } from "../parallel.js";
 let ignore = [
-    '**/node_modules/**',
-    '**/.mops/**',
-    '**/.vessel/**',
-    '**/.git/**',
-    '**/dist/**',
+    "**/node_modules/**",
+    "**/.mops/**",
+    "**/.vessel/**",
+    "**/.git/**",
+    "**/dist/**",
 ];
 let globConfig = {
     nocase: true,
@@ -21,7 +21,7 @@ let globConfig = {
 export async function format(filter, options = {}, signal, onProgress) {
     let startTime = Date.now();
     let rootDir = getRootDir();
-    let globStr = '**/*.mo';
+    let globStr = "**/*.mo";
     if (filter) {
         globStr = `**/*${filter}*.mo`;
     }
@@ -49,7 +49,7 @@ export async function format(filter, options = {}, signal, onProgress) {
             return getResult(false);
         }
         if (!options.silent) {
-            console.log('No *.mo files found');
+            console.log("No *.mo files found");
         }
         return getResult(false);
     }
@@ -76,30 +76,34 @@ export async function format(filter, options = {}, signal, onProgress) {
         // }
         // add motoko parser plugin
         Object.assign(prettierConfig, {
-            parser: 'motoko-tt-parse',
+            parser: "motoko-tt-parse",
             plugins: [motokoPlugin],
             filepath: file,
         });
         // check file
-        let code = await fs.readFile(file, 'utf8');
+        let code = await fs.readFile(file, "utf8");
         let formatted = await prettier.format(code, prettierConfig);
         let ok = formatted === code;
         invalidFiles += Number(!ok);
         if (options.check) {
             if (ok) {
-                options.silent || console.log(`${chalk.green('✓')} ${absToRel(file)} ${chalk.gray('valid')}`);
+                options.silent ||
+                    console.log(`${chalk.green("✓")} ${absToRel(file)} ${chalk.gray("valid")}`);
             }
             else {
-                options.silent || console.log(`${chalk.red('✖')} ${absToRel(file)} ${chalk.gray('invalid')}`);
+                options.silent ||
+                    console.log(`${chalk.red("✖")} ${absToRel(file)} ${chalk.gray("invalid")}`);
             }
         }
         else {
             if (ok) {
-                options.silent || console.log(`${chalk.green('✓')} ${absToRel(file)} ${chalk.gray('valid')}`);
+                options.silent ||
+                    console.log(`${chalk.green("✓")} ${absToRel(file)} ${chalk.gray("valid")}`);
             }
             else {
                 await fs.writeFile(file, formatted);
-                options.silent || console.log(`${chalk.yellow('*')} ${absToRel(file)} ${chalk.gray('formatted')}`);
+                options.silent ||
+                    console.log(`${chalk.yellow("*")} ${absToRel(file)} ${chalk.gray("formatted")}`);
             }
         }
         checkedFiles += 1;
@@ -110,9 +114,9 @@ export async function format(filter, options = {}, signal, onProgress) {
         return getResult(false);
     }
     if (!options.silent) {
-        console.log('-'.repeat(50));
-        let plural = (n) => n === 1 ? '' : 's';
-        let str = `Checked ${chalk.gray(files.length)} file${plural(files.length)} in ${chalk.gray(((Date.now() - startTime) / 1000).toFixed(2) + 's')}`;
+        console.log("-".repeat(50));
+        let plural = (n) => (n === 1 ? "" : "s");
+        let str = `Checked ${chalk.gray(files.length)} file${plural(files.length)} in ${chalk.gray(((Date.now() - startTime) / 1000).toFixed(2) + "s")}`;
         if (invalidFiles) {
             str += options.check
                 ? `, invalid ${chalk.redBright(invalidFiles)} file${plural(invalidFiles)}`
@@ -120,11 +124,11 @@ export async function format(filter, options = {}, signal, onProgress) {
         }
         console.log(str);
         if (!invalidFiles) {
-            console.log(chalk.green('✓ All files have valid formatting'));
+            console.log(chalk.green("✓ All files have valid formatting"));
         }
     }
     if (options.check && invalidFiles && !options.silent) {
-        console.log(`${(`Run '${chalk.yellow('mops format' + (filter ? ` ${filter}` : ''))}' to format your code`)}`);
+        console.log(`${`Run '${chalk.yellow("mops format" + (filter ? ` ${filter}` : ""))}' to format your code`}`);
         return getResult(false);
     }
     return getResult(true);