ic-mops 1.11.1 → 2.0.0

package/dist/commands/update.js

@@ -1,27 +1,30 @@
-import chalk from 'chalk';
-import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig } from '../mops.js';
-import { add } from './add.js';
-import { getAvailableUpdates } from './available-updates.js';
-import { checkIntegrity } from '../integrity.js';
+import chalk from "chalk";
+import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig, } from "../mops.js";
+import { add } from "./add.js";
+import { getAvailableUpdates } from "./available-updates.js";
+import { checkIntegrity } from "../integrity.js";
+import { getDepName, getDepPinnedVersion } from "../helpers/get-dep-name.js";
 export async function update(pkg, { lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
     let config = readConfig();
-    if (pkg && !config.dependencies?.[pkg] && !config['dev-dependencies']?.[pkg]) {
+    if (pkg &&
+        !config.dependencies?.[pkg] &&
+        !config["dev-dependencies"]?.[pkg]) {
         console.log(chalk.red(`Package "${pkg}" is not installed!`));
         return;
     }
     // update github packages
     let deps = Object.values(config.dependencies || {});
-    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let devDeps = Object.values(config["dev-dependencies"] || {});
     let githubDeps = [...deps, ...devDeps].filter((dep) => dep.repo);
     if (pkg) {
         githubDeps = githubDeps.filter((dep) => dep.name === pkg);
     }
     for (let dep of githubDeps) {
-        let { org, gitName, branch, commitHash } = parseGithubURL(dep.repo || '');
-        let dev = !!config['dev-dependencies']?.[dep.name];
+        let { org, gitName, branch, commitHash } = parseGithubURL(dep.repo || "");
+        let dev = !!config["dev-dependencies"]?.[dep.name];
         let commit = await getGithubCommit(`${org}/${gitName}`, branch);
         if (commit.sha !== commitHash) {
             await add(`https://github.com/${org}/${gitName}#${branch}@${commit.sha}`, { dev }, dep.name);
@@ -34,13 +37,28 @@ export async function update(pkg, { lock } = {}) {
             console.log(chalk.green(`Package "${pkg}" is up to date!`));
         }
         else {
-            console.log(chalk.green('All dependencies are up to date!'));
+            console.log(chalk.green("All dependencies are up to date!"));
         }
     }
     else {
         for (let dep of available) {
-            let dev = !!config['dev-dependencies']?.[dep[0]];
-            await add(`${dep[0]}@${dep[2]}`, { dev });
+            let devDeps = Object.keys(config["dev-dependencies"] || {});
+            let allDeps = [...Object.keys(config.dependencies || {}), ...devDeps];
+            let dev = false;
+            for (let d of devDeps) {
+                let pinnedVersion = getDepPinnedVersion(d);
+                if (getDepName(d) === dep[0] &&
+                    (!pinnedVersion || dep[1].startsWith(pinnedVersion))) {
+                    dev = true;
+                    break;
+                }
+            }
+            let asName = allDeps.find((d) => {
+                let pinnedVersion = getDepPinnedVersion(d);
+                return (getDepName(d) === dep[0] &&
+                    (!pinnedVersion || dep[1].startsWith(pinnedVersion)));
+            }) || dep[0];
+            await add(`${dep[0]}@${dep[2]}`, { dev }, asName);
         }
     }
     await checkIntegrity(lock);

package/dist/commands/user.js

@@ -1,33 +1,33 @@
-import process from 'node:process';
-import chalk from 'chalk';
-import fs from 'node:fs';
-import path from 'node:path';
-import { Buffer } from 'node:buffer';
-import prompts from 'prompts';
-import { deleteSync } from 'del';
-import { mainActor } from '../api/actors.js';
-import { getIdentity, globalConfigDir } from '../mops.js';
-import { encrypt } from '../pem.js';
+import process from "node:process";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import prompts from "prompts";
+import { deleteSync } from "del";
+import { mainActor } from "../api/actors.js";
+import { getIdentity, globalConfigDir } from "../mops.js";
+import { encrypt } from "../pem.js";
 export async function getUserProp(prop) {
     let actor = await mainActor();
     let identity = await getIdentity();
     if (!identity) {
-        console.log(chalk.red('Error: ') + 'No identity found');
+        console.log(chalk.red("Error: ") + "No identity found");
         process.exit(1);
     }
     let res = await actor.getUser(identity.getPrincipal());
     // @ts-ignore
-    console.log(res[0]?.[prop] || '');
+    console.log(res[0]?.[prop] || "");
 }
 export async function setUserProp(prop, value) {
     let identity = await getIdentity();
     let actor = await mainActor(identity);
     let res = await actor.setUserProp(prop, value);
-    if ('ok' in res) {
-        console.log(chalk.green('Success!'));
+    if ("ok" in res) {
+        console.log(chalk.green("Success!"));
     }
     else {
-        console.log(chalk.red('Error: ') + res.err);
+        console.log(chalk.red("Error: ") + res.err);
     }
 }
 export async function getPrincipal() {
@@ -36,7 +36,10 @@ export async function getPrincipal() {
         console.log(identity.getPrincipal().toText());
     }
     else {
-        console.log(chalk.red('Error: ') + 'identity not found. Run ' + chalk.greenBright('mops user import') + ' command.');
+        console.log(chalk.red("Error: ") +
+            "identity not found. Run " +
+            chalk.greenBright("mops user import") +
+            " command.");
     }
 }
 export async function importPem(data, options = { encrypt: true }) {
@@ -44,28 +47,28 @@ export async function importPem(data, options = { encrypt: true }) {
         if (!fs.existsSync(globalConfigDir)) {
             fs.mkdirSync(globalConfigDir);
         }
-        let password = '';
+        let password = "";
         if (options.encrypt) {
             let res = await prompts({
-                type: 'invisible',
-                name: 'password',
-                message: 'Enter password to encrypt identity.pem',
+                type: "invisible",
+                name: "password",
+                message: "Enter password to encrypt identity.pem",
             });
             password = res.password;
             if (!password) {
                 let res = await prompts({
-                    type: 'confirm',
-                    name: 'ok',
-                    message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+                    type: "confirm",
+                    name: "ok",
+                    message: "Are you sure you don't want to protect your identity.pem with a password?",
                 });
                 if (!res.ok) {
-                    console.log('aborted');
+                    console.log("aborted");
                     return;
                 }
             }
         }
-        let identityPem = path.resolve(globalConfigDir, 'identity.pem');
-        let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
+        let identityPem = path.resolve(globalConfigDir, "identity.pem");
+        let identityPemEncrypted = path.resolve(globalConfigDir, "identity.pem.encrypted");
         deleteSync([identityPem, identityPemEncrypted], { force: true });
         // encrypted
         if (password) {
@@ -76,9 +79,9 @@ export async function importPem(data, options = { encrypt: true }) {
         else {
             fs.writeFileSync(identityPem, data);
         }
-        console.log(chalk.green('Success'));
+        console.log(chalk.green("Success"));
     }
     catch (err) {
-        console.log(chalk.red('Error: ') + err);
+        console.log(chalk.red("Error: ") + err);
     }
 }

package/dist/commands/watch/deployer.d.ts

@@ -1,9 +1,9 @@
-import { ErrorChecker } from './error-checker.js';
-import { Generator } from './generator.js';
+import { ErrorChecker } from "./error-checker.js";
+import { Generator } from "./generator.js";
 export declare class Deployer {
     verbose: boolean;
     canisters: Record<string, string>;
-    status: 'pending' | 'running' | 'syntax-error' | 'dfx-error' | 'error' | 'success';
+    status: "pending" | "running" | "syntax-error" | "dfx-error" | "error" | "success";
     errorChecker: ErrorChecker;
     generator: Generator;
     success: number;
@@ -11,7 +11,7 @@ export declare class Deployer {
     aborted: boolean;
     controllers: Map<string, AbortController>;
     currentRun: Promise<any> | undefined;
-    constructor({ verbose, canisters, errorChecker, generator }: {
+    constructor({ verbose, canisters, errorChecker, generator, }: {
         verbose: boolean;
         canisters: Record<string, string>;
         errorChecker: ErrorChecker;

package/dist/commands/watch/deployer.js

@@ -1,13 +1,13 @@
-import chalk from 'chalk';
-import os from 'node:os';
-import { promisify } from 'node:util';
-import { execFile, execSync } from 'node:child_process';
-import { parallel } from '../../parallel.js';
-import { getRootDir } from '../../mops.js';
+import chalk from "chalk";
+import os from "node:os";
+import { promisify } from "node:util";
+import { execFile, execSync } from "node:child_process";
+import { parallel } from "../../parallel.js";
+import { getRootDir } from "../../mops.js";
 export class Deployer {
     verbose = false;
     canisters = {};
-    status = 'pending';
+    status = "pending";
     errorChecker;
     generator;
     success = 0;
@@ -15,14 +15,14 @@ export class Deployer {
     aborted = false;
     controllers = new Map();
     currentRun;
-    constructor({ verbose, canisters, errorChecker, generator }) {
+    constructor({ verbose, canisters, errorChecker, generator, }) {
         this.verbose = verbose;
         this.canisters = canisters;
         this.errorChecker = errorChecker;
         this.generator = generator;
     }
     reset() {
-        this.status = 'pending';
+        this.status = "pending";
         this.success = 0;
         this.errors = [];
     }
@@ -38,37 +38,40 @@ export class Deployer {
     }
     async run(onProgress) {
         await this.abortCurrent();
-        if (this.errorChecker.status === 'error') {
-            this.status = 'syntax-error';
+        if (this.errorChecker.status === "error") {
+            this.status = "syntax-error";
             onProgress();
             return;
         }
         if (Object.keys(this.canisters).length === 0) {
-            this.status = 'success';
+            this.status = "success";
             onProgress();
             return;
         }
         let rootDir = getRootDir();
         try {
-            execSync('dfx ping', { cwd: rootDir });
+            execSync("dfx ping", { cwd: rootDir });
         }
         catch (error) {
-            this.status = 'dfx-error';
+            this.status = "dfx-error";
             onProgress();
             return;
         }
-        this.status = 'running';
+        this.status = "running";
         onProgress();
         // create canisters (sequentially to avoid DFX errors)
         let resolve;
-        this.currentRun = new Promise((res) => resolve = res);
+        this.currentRun = new Promise((res) => (resolve = res));
         for (let canister of Object.keys(this.canisters)) {
             let controller = new AbortController();
             let { signal } = controller;
             this.controllers.set(canister, controller);
-            await promisify(execFile)('dfx', ['canister', 'create', canister], { cwd: rootDir, signal }).catch((error) => {
-                if (error.code === 'ABORT_ERR') {
-                    return { stderr: '' };
+            await promisify(execFile)("dfx", ["canister", "create", canister], {
+                cwd: rootDir,
+                signal,
+            }).catch((error) => {
+                if (error.code === "ABORT_ERR") {
+                    return { stderr: "" };
                 }
                 throw error;
             });
@@ -83,18 +86,22 @@ export class Deployer {
             let { signal } = controller;
             this.controllers.set(canister, controller);
             // build
-            if (this.generator.status !== 'success' || !this.generator.canisters[canister]) {
-                await promisify(execFile)('dfx', ['build', canister], { cwd: rootDir, signal }).catch((error) => {
-                    if (error.code === 'ABORT_ERR') {
-                        return { stderr: '' };
+            if (this.generator.status !== "success" ||
+                !this.generator.canisters[canister]) {
+                await promisify(execFile)("dfx", ["build", canister], {
+                    cwd: rootDir,
+                    signal,
+                }).catch((error) => {
+                    if (error.code === "ABORT_ERR") {
+                        return { stderr: "" };
                     }
                     throw error;
                 });
             }
             // install
-            await promisify(execFile)('dfx', ['canister', 'install', '--mode=auto', '--yes', canister], { cwd: rootDir, signal }).catch((error) => {
-                if (error.code === 'ABORT_ERR') {
-                    return { stderr: '' };
+            await promisify(execFile)("dfx", ["canister", "install", "--mode=auto", "--yes", canister], { cwd: rootDir, signal }).catch((error) => {
+                if (error.code === "ABORT_ERR") {
+                    return { stderr: "" };
                 }
                 throw error;
             });
@@ -104,24 +111,26 @@ export class Deployer {
         });
         await this.currentRun;
         if (!this.aborted) {
-            this.status = 'success';
+            this.status = "success";
         }
         onProgress();
     }
     getOutput() {
         let get = (v) => v.toString();
-        let count = (this.status === 'running' ? get : chalk.bold[this.errors.length > 0 ? 'redBright' : 'green'])(this.errors.length || this.success);
-        if (this.status === 'pending') {
-            return `Deploy: ${chalk.gray('(pending)')}`;
+        let count = (this.status === "running"
+            ? get
+            : chalk.bold[this.errors.length > 0 ? "redBright" : "green"])(this.errors.length || this.success);
+        if (this.status === "pending") {
+            return `Deploy: ${chalk.gray("(pending)")}`;
         }
-        if (this.status === 'running') {
-            return `Deploy: ${count}/${Object.keys(this.canisters).length} ${chalk.gray('(running)')}`;
+        if (this.status === "running") {
+            return `Deploy: ${count}/${Object.keys(this.canisters).length} ${chalk.gray("(running)")}`;
         }
-        if (this.status === 'syntax-error') {
-            return `Deploy: ${chalk.gray('(errors)')}`;
+        if (this.status === "syntax-error") {
+            return `Deploy: ${chalk.gray("(errors)")}`;
         }
-        if (this.status === 'dfx-error') {
-            return `Deploy: ${chalk.gray('(dfx not running)')}`;
+        if (this.status === "dfx-error") {
+            return `Deploy: ${chalk.gray("(dfx not running)")}`;
         }
         return `Deploy: ${count}`;
     }

package/dist/commands/watch/error-checker.d.ts

@@ -1,11 +1,11 @@
 export declare class ErrorChecker {
     verbose: boolean;
     canisters: Record<string, string>;
-    status: 'pending' | 'running' | 'error' | 'success';
+    status: "pending" | "running" | "error" | "success";
     errors: string[];
     totalFiles: number;
     processedFiles: number;
-    constructor({ verbose, canisters }: {
+    constructor({ verbose, canisters, }: {
         verbose: boolean;
         canisters: Record<string, string>;
     });

package/dist/commands/watch/error-checker.js

@@ -1,32 +1,32 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import os from 'node:os';
-import chalk from 'chalk';
-import { getMocPath } from '../../helpers/get-moc-path.js';
-import { getRootDir } from '../../mops.js';
-import { sources } from '../sources.js';
-import { parallel } from '../../parallel.js';
-import { globMoFiles } from './globMoFiles.js';
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import os from "node:os";
+import chalk from "chalk";
+import { getMocPath } from "../../helpers/get-moc-path.js";
+import { getRootDir } from "../../mops.js";
+import { sources } from "../sources.js";
+import { parallel } from "../../parallel.js";
+import { globMoFiles } from "./globMoFiles.js";
 export class ErrorChecker {
     verbose = false;
     canisters = {};
-    status = 'pending';
+    status = "pending";
     errors = [];
     totalFiles = 0;
     processedFiles = 0;
-    constructor({ verbose, canisters }) {
+    constructor({ verbose, canisters, }) {
         this.verbose = verbose;
         this.canisters = canisters;
     }
     reset() {
-        this.status = 'pending';
+        this.status = "pending";
         this.errors = [];
         this.totalFiles = 0;
         this.processedFiles = 0;
     }
     async run(onProgress) {
         this.reset();
-        this.status = 'running';
+        this.status = "running";
         onProgress();
         let rootDir = getRootDir();
         let mocPath = getMocPath();
@@ -36,21 +36,21 @@ export class ErrorChecker {
         this.processedFiles = 0;
         await parallel(os.cpus().length, paths, async (file) => {
             try {
-                await promisify(execFile)(mocPath, ['--check', ...deps.flatMap(x => x.split(' ')), file], { cwd: rootDir });
+                await promisify(execFile)(mocPath, ["--check", ...deps.flatMap((x) => x.split(" ")), file], { cwd: rootDir });
             }
             catch (error) {
-                error.message.split('\n').forEach((line) => {
+                error.message.split("\n").forEach((line) => {
                     if (line.match(/: \w+ error \[/)) {
                         // better formatting
                         let str = line
                             .replace(/: (\w+ error) \[/, (_, m1) => `: ${chalk.red(m1)} [`)
-                            .replace(/unbound type (\w+)/, `unbound type ${chalk.bold('$1')}`)
-                            .replace(/unbound variable (\w+)/, `unbound variable ${chalk.bold('$1')}`)
+                            .replace(/unbound type (\w+)/, `unbound type ${chalk.bold("$1")}`)
+                            .replace(/unbound variable (\w+)/, `unbound variable ${chalk.bold("$1")}`)
                             .trim();
                         this.errors.push(str);
                     }
-                    else if (line.startsWith('  ') && this.errors.length) {
-                        this.errors[this.errors.length - 1] += '\n  ' + line;
+                    else if (line.startsWith("  ") && this.errors.length) {
+                        this.errors[this.errors.length - 1] += "\n  " + line;
                     }
                     else {
                         // console.log('UNKNOWN ERROR', line);
@@ -60,21 +60,21 @@ export class ErrorChecker {
             this.processedFiles++;
             onProgress();
         });
-        this.status = this.errors.length ? 'error' : 'success';
+        this.status = this.errors.length ? "error" : "success";
         onProgress();
     }
     getOutput() {
-        if (this.status === 'pending') {
-            return `Errors: ${chalk.gray('(pending)')}`;
+        if (this.status === "pending") {
+            return `Errors: ${chalk.gray("(pending)")}`;
         }
-        if (this.status === 'running') {
-            return `Errors: ${this.processedFiles}/${this.totalFiles} ${chalk.gray('(running)')}`;
+        if (this.status === "running") {
+            return `Errors: ${this.processedFiles}/${this.totalFiles} ${chalk.gray("(running)")}`;
         }
-        let output = '';
+        let output = "";
         let uniqueErrors = [...new Set(this.errors)];
-        output += `Errors: ${chalk.bold[uniqueErrors.length ? 'redBright' : 'green'](uniqueErrors.length)}`;
+        output += `Errors: ${chalk.bold[uniqueErrors.length ? "redBright" : "green"](uniqueErrors.length)}`;
         if (this.verbose && this.errors.length) {
-            output += `\n  ${uniqueErrors.join('\n  ')}`;
+            output += `\n  ${uniqueErrors.join("\n  ")}`;
         }
         return output;
     }

package/dist/commands/watch/formatter.d.ts

@@ -1,14 +1,14 @@
-import { FormatResult } from '../format.js';
-import { ErrorChecker } from './error-checker.js';
+import { FormatResult } from "../format.js";
+import { ErrorChecker } from "./error-checker.js";
 export declare class Formatter {
     verbose: boolean;
-    status: 'pending' | 'running' | 'syntax-error' | 'error' | 'success';
+    status: "pending" | "running" | "syntax-error" | "error" | "success";
     errorChecker: ErrorChecker;
     aborted: boolean;
     controller: AbortController;
     currentRun: Promise<any> | undefined;
     result: FormatResult | undefined;
-    constructor({ verbose, errorChecker }: {
+    constructor({ verbose, errorChecker, }: {
         verbose: boolean;
         errorChecker: ErrorChecker;
     });

package/dist/commands/watch/formatter.js

@@ -1,19 +1,19 @@
-import chalk from 'chalk';
-import { format } from '../format.js';
+import chalk from "chalk";
+import { format } from "../format.js";
 export class Formatter {
     verbose = false;
-    status = 'pending';
+    status = "pending";
     errorChecker;
     aborted = false;
     controller = new AbortController();
     currentRun;
     result;
-    constructor({ verbose, errorChecker }) {
+    constructor({ verbose, errorChecker, }) {
         this.verbose = verbose;
         this.errorChecker = errorChecker;
     }
     reset() {
-        this.status = 'pending';
+        this.status = "pending";
         this.result = undefined;
     }
     async abortCurrent() {
@@ -24,36 +24,36 @@ export class Formatter {
     }
     async run(onProgress) {
         await this.abortCurrent();
-        if (this.errorChecker.status === 'error') {
-            this.status = 'syntax-error';
+        if (this.errorChecker.status === "error") {
+            this.status = "syntax-error";
             onProgress();
             return;
         }
-        this.status = 'running';
+        this.status = "running";
         onProgress();
         this.controller = new AbortController();
-        this.currentRun = format('', { silent: true }, this.controller.signal, (result) => {
+        this.currentRun = format("", { silent: true }, this.controller.signal, (result) => {
             this.result = result;
             onProgress();
         });
         await this.currentRun;
         if (!this.aborted) {
-            this.status = 'success';
+            this.status = "success";
         }
         onProgress();
     }
     getOutput() {
-        if (this.status === 'pending') {
-            return `Format: ${chalk.gray('(pending)')}`;
+        if (this.status === "pending") {
+            return `Format: ${chalk.gray("(pending)")}`;
         }
-        if (this.status === 'syntax-error') {
-            return `Format: ${chalk.gray('(errors)')}`;
+        if (this.status === "syntax-error") {
+            return `Format: ${chalk.gray("(errors)")}`;
         }
         if (!this.result) {
-            return `Format: ${chalk.gray('(pending)')}`;
+            return `Format: ${chalk.gray("(pending)")}`;
         }
-        if (this.status === 'running') {
-            return `Format: ${this.result.checked}/${this.result.total} ${chalk.gray('(running)')}`;
+        if (this.status === "running") {
+            return `Format: ${this.result.checked}/${this.result.total} ${chalk.gray("(running)")}`;
         }
         return `Format: ${chalk.greenBright(`${this.result.formatted}`)}`;
     }

package/dist/commands/watch/generator.d.ts

@@ -1,15 +1,15 @@
-import { ErrorChecker } from './error-checker.js';
+import { ErrorChecker } from "./error-checker.js";
 export declare class Generator {
     verbose: boolean;
     canisters: Record<string, string>;
-    status: 'pending' | 'running' | 'syntax-error' | 'error' | 'success';
+    status: "pending" | "running" | "syntax-error" | "error" | "success";
     errorChecker: ErrorChecker;
     success: number;
     errors: string[];
     aborted: boolean;
     controllers: Map<string, AbortController>;
     currentRun: Promise<any> | undefined;
-    constructor({ verbose, canisters, errorChecker }: {
+    constructor({ verbose, canisters, errorChecker, }: {
         verbose: boolean;
         canisters: Record<string, string>;
         errorChecker: ErrorChecker;