ic-mops 1.12.0 → 2.0.0

package/dist/commands/replica.js

@@ -1,77 +1,87 @@
-import process from 'node:process';
-import { execSync, spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import { PassThrough } from 'node:stream';
-import { spawn as spawnAsync } from 'promisify-child-process';
-import { Actor, HttpAgent } from '@icp-sdk/core/agent';
-import { PocketIc, PocketIcServer } from 'pic-ic';
-import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops } from 'pic-js-mops';
-import chalk from 'chalk';
-import { readConfig } from '../mops.js';
-import { toolchain } from './toolchain/index.js';
-import { getDfxVersion } from '../helpers/get-dfx-version.js';
+import process from "node:process";
+import { execSync, spawn, } from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import { PassThrough } from "node:stream";
+import { spawn as spawnAsync } from "promisify-child-process";
+import { Actor, HttpAgent } from "@icp-sdk/core/agent";
+import { PocketIc, PocketIcServer } from "pic-ic";
+import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops, } from "pic-js-mops";
+import chalk from "chalk";
+import { readConfig } from "../mops.js";
+import { toolchain } from "./toolchain/index.js";
+import { getDfxVersion } from "../helpers/get-dfx-version.js";
 export class Replica {
-    type = 'dfx';
+    type = "dfx";
     verbose = false;
     canisters = {};
     pocketIcServer;
     pocketIc;
     dfxProcess;
-    dir = ''; // absolute path (/.../.mops/.test/)
+    dir = ""; // absolute path (/.../.mops/.test/)
     ttl = 60;
     async start({ type, dir, verbose, silent } = {}) {
         this.type = type ?? this.type;
         this.verbose = verbose ?? this.verbose;
         this.dir = dir ?? this.dir;
         silent || console.log(`Starting ${this.type} replica...`);
-        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+        if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
             fs.mkdirSync(this.dir, { recursive: true });
-            fs.writeFileSync(path.join(this.dir, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
-            fs.writeFileSync(path.join(this.dir, 'canister.did'), 'service : { runTests: () -> (); }');
+            fs.writeFileSync(path.join(this.dir, "dfx.json"), JSON.stringify(this.dfxJson(""), null, 2));
+            fs.writeFileSync(path.join(this.dir, "canister.did"), "service : { runTests: () -> (); }");
             await this.stop();
-            this.dfxProcess = spawn('dfx', ['start', this.type === 'dfx-pocket-ic' ? '--pocketic' : '', '--clean', (this.verbose ? '' : '-qqqq'), '--artificial-delay', '0'].filter(x => x).flat(), { cwd: this.dir });
+            this.dfxProcess = spawn("dfx", [
+                "start",
+                this.type === "dfx-pocket-ic" ? "--pocketic" : "",
+                "--clean",
+                this.verbose ? "" : "-qqqq",
+                "--artificial-delay",
+                "0",
+            ]
+                .filter((x) => x)
+                .flat(), { cwd: this.dir });
             // process canister logs
             this._attachCanisterLogHandler(this.dfxProcess);
-            this.dfxProcess.stdout.on('data', (data) => {
+            this.dfxProcess.stdout.on("data", (data) => {
                 if (this.verbose) {
-                    console.log('DFX:', data.toString());
+                    console.log("DFX:", data.toString());
                 }
             });
-            this.dfxProcess.stderr.on('data', (data) => {
+            this.dfxProcess.stderr.on("data", (data) => {
                 if (this.verbose) {
-                    console.error('DFX:', data.toString());
+                    console.error("DFX:", data.toString());
                 }
-                if (data.toString().includes('Failed to bind socket to')) {
+                if (data.toString().includes("Failed to bind socket to")) {
                     console.error(chalk.red(data.toString()));
-                    console.log('Please try again after some time');
+                    console.log("Please try again after some time");
                     process.exit(11);
                 }
             });
             // await for dfx to start
             let ok = false;
             while (!ok) {
-                await fetch('http://127.0.0.1:4945/api/v2/status')
-                    .then(res => {
+                await fetch("http://127.0.0.1:4945/api/v2/status")
+                    .then((res) => {
                     if (res.status === 200) {
                         ok = true;
                     }
                 })
                     .catch(() => { })
                     .finally(() => {
-                    return new Promise(resolve => setTimeout(resolve, 1000));
+                    return new Promise((resolve) => setTimeout(resolve, 1000));
                 });
             }
         }
         else {
-            let pocketIcBin = await toolchain.bin('pocket-ic');
+            let pocketIcBin = await toolchain.bin("pocket-ic");
             let config = readConfig();
-            if (config.toolchain?.['pocket-ic'] !== '4.0.0' && !config.toolchain?.['pocket-ic']?.startsWith('9.')) {
-                console.error('Current Mops CLI only supports pocket-ic 9.x.x and 4.0.0');
+            if (config.toolchain?.["pocket-ic"] !== "4.0.0" &&
+                !config.toolchain?.["pocket-ic"]?.startsWith("9.")) {
+                console.error("Current Mops CLI only supports pocket-ic 9.x.x and 4.0.0");
                 process.exit(1);
             }
             // pocket-ic 9.x.x
-            if (config.toolchain?.['pocket-ic']?.startsWith('9.')) {
+            if (config.toolchain?.["pocket-ic"]?.startsWith("9.")) {
                 this.pocketIcServer = await PocketIcServerMops.start({
                     showRuntimeLogs: false,
                     showCanisterLogs: false,
@@ -95,31 +105,31 @@ export class Replica {
         }
     }
     _attachCanisterLogHandler(proc) {
-        let curData = '';
-        proc.stderr.on('data', (data) => {
+        let curData = "";
+        proc.stderr.on("data", (data) => {
             curData = curData + data.toString();
-            if (curData.includes('\n')) {
-                let chunk = curData.split('\n').slice(0, -1).join('\n');
+            if (curData.includes("\n")) {
+                let chunk = curData.split("\n").slice(0, -1).join("\n");
                 let matches = [...chunk.matchAll(/\[Canister ([a-z0-9-]+)\] (.*)/g)];
                 for (let match of matches) {
                     let [, canisterId, msg] = match;
-                    let stream = this.getCanisterStream(canisterId || '');
+                    let stream = this.getCanisterStream(canisterId || "");
                     if (stream) {
                         stream.write(msg);
                     }
                 }
                 if (matches.length) {
-                    curData = curData.split('\n').slice(-1).join('\n');
+                    curData = curData.split("\n").slice(-1).join("\n");
                 }
             }
         });
     }
     async stop(sigint = false) {
-        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+        if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
             if (this.dfxProcess) {
                 let killed = this.dfxProcess.kill();
                 if (!killed) {
-                    this.dfxProcess.kill('SIGKILL');
+                    this.dfxProcess.kill("SIGKILL");
                 }
                 // give replica some time to stop
                 let i = 0;
@@ -148,41 +158,59 @@ export class Replica {
         }
     }
     async deploy(name, wasm, idlFactory, cwd = process.cwd(), signal) {
-        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+        if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
             // prepare dfx.json for current canister
-            let dfxJson = path.join(this.dir, 'dfx.json');
+            let dfxJson = path.join(this.dir, "dfx.json");
             let oldDfxJsonData;
             if (fs.existsSync(dfxJson)) {
                 oldDfxJsonData = JSON.parse(fs.readFileSync(dfxJson).toString());
             }
-            let newDfxJsonData = this.dfxJson(name, name + '.wasm');
+            let newDfxJsonData = this.dfxJson(name, name + ".wasm");
             if (oldDfxJsonData.canisters) {
                 newDfxJsonData.canisters = Object.assign(oldDfxJsonData.canisters, newDfxJsonData.canisters);
             }
             fs.mkdirSync(this.dir, { recursive: true });
             fs.writeFileSync(dfxJson, JSON.stringify(newDfxJsonData, null, 2));
-            await spawnAsync('dfx', ['deploy', name, '--mode', 'reinstall', '--yes', '--identity', 'anonymous'], { cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] }).catch((error) => {
-                if (error.code === 'ABORT_ERR') {
-                    return { stderr: '' };
+            await spawnAsync("dfx", [
+                "deploy",
+                name,
+                "--mode",
+                "reinstall",
+                "--yes",
+                "--identity",
+                "anonymous",
+            ], {
+                cwd: this.dir,
+                signal,
+                stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
+            }).catch((error) => {
+                if (error.code === "ABORT_ERR") {
+                    return { stderr: "" };
                 }
                 throw error;
             });
             if (signal?.aborted) {
                 return;
             }
-            await spawnAsync('dfx', ['ledger', 'fabricate-cycles', '--canister', name, '--t', '100'], { cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] }).catch((error) => {
-                if (error.code === 'ABORT_ERR') {
-                    return { stderr: '' };
+            await spawnAsync("dfx", ["ledger", "fabricate-cycles", "--canister", name, "--t", "100"], {
+                cwd: this.dir,
+                signal,
+                stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
+            }).catch((error) => {
+                if (error.code === "ABORT_ERR") {
+                    return { stderr: "" };
                 }
                 throw error;
             });
             if (signal?.aborted) {
                 return;
             }
-            let canisterId = execSync(`dfx canister id ${name}`, { cwd: this.dir }).toString().trim();
+            let canisterId = execSync(`dfx canister id ${name}`, { cwd: this.dir })
+                .toString()
+                .trim();
             let actor = Actor.createActor(idlFactory, {
                 agent: await HttpAgent.create({
-                    host: 'http://127.0.0.1:4945',
+                    host: "http://127.0.0.1:4945",
                     shouldFetchRootKey: true,
                 }),
                 canisterId,
@@ -228,7 +256,7 @@ export class Replica {
         return this.canisters[name];
     }
     getCanisterId(name) {
-        return this.canisters[name]?.canisterId || '';
+        return this.canisters[name]?.canisterId || "";
     }
     getCanisterStream(canisterId) {
         for (let canister of Object.values(this.canisters)) {
@@ -238,11 +266,11 @@ export class Replica {
         }
         return null;
     }
-    dfxJson(canisterName, wasmPath = 'canister.wasm', didPath = 'canister.did') {
+    dfxJson(canisterName, wasmPath = "canister.wasm", didPath = "canister.did") {
         let canisters = {};
         if (canisterName) {
             canisters[canisterName] = {
-                type: 'custom',
+                type: "custom",
                 wasm: wasmPath,
                 candid: didPath,
             };
@@ -253,13 +281,13 @@ export class Replica {
             dfx: getDfxVersion(),
             defaults: {
                 build: {
-                    packtool: 'mops sources',
+                    packtool: "mops sources",
                 },
             },
             networks: {
                 local: {
-                    type: 'ephemeral',
-                    bind: '127.0.0.1:4945',
+                    type: "ephemeral",
+                    bind: "127.0.0.1:4945",
                 },
             },
         };

package/dist/commands/search.js

@@ -1,12 +1,12 @@
-import process from 'node:process';
-import asTable from 'as-table';
-import chalk from 'chalk';
-import { mainActor } from '../api/actors.js';
+import process from "node:process";
+import asTable from "as-table";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
 export async function search(text) {
     let actor = await mainActor();
     let [packages, _pageCount] = await actor.search(text, [], []);
     if (!packages.length) {
-        console.log('Packages not found');
+        console.log("Packages not found");
         return;
     }
     let ellipsis = (text, max) => {
@@ -14,23 +14,25 @@ export async function search(text) {
             return text;
         }
         else {
-            return text.slice(0, max) + '…';
+            return text.slice(0, max) + "…";
         }
     };
-    let maxNameLength = Math.max(...packages.map(a => a.config.name.length));
+    let maxNameLength = Math.max(...packages.map((a) => a.config.name.length));
     let table = packages.map((item) => {
         return {
             NAME: chalk.bold(item.config.name),
             DESCRIPTION: ellipsis(item.config.description, process.stdout.columns - 40 - maxNameLength),
             VERSION: item.config.version,
-            UPDATED: new Date(Number(item.publication.time / 1000000n)).toISOString().split('T')[0],
+            UPDATED: new Date(Number(item.publication.time / 1000000n))
+                .toISOString()
+                .split("T")[0],
         };
     });
-    console.log('');
+    console.log("");
     console.log(asTable.configure({
-        delimiter: chalk.gray(' | '),
-        dash: chalk.gray('─'),
-        title: t => chalk.gray.bold(t),
+        delimiter: chalk.gray(" | "),
+        dash: chalk.gray("─"),
+        title: (t) => chalk.gray.bold(t),
     })(table));
-    console.log('');
+    console.log("");
 }

package/dist/commands/self.js

@@ -1,63 +1,66 @@
-import process from 'node:process';
-import child_process, { execSync } from 'node:child_process';
-import chalk from 'chalk';
-import { version, globalConfigDir } from '../mops.js';
-import { cleanCache } from '../cache.js';
-import { toolchain } from './toolchain/index.js';
-let url = 'https://x344g-ziaaa-aaaap-abl7a-cai.icp0.io';
+import process from "node:process";
+import child_process, { execSync } from "node:child_process";
+import chalk from "chalk";
+import { version, globalConfigDir } from "../mops.js";
+import { cleanCache } from "../cache.js";
+import { toolchain } from "./toolchain/index.js";
+let url = "https://x344g-ziaaa-aaaap-abl7a-cai.icp0.io";
 function detectPackageManager() {
-    let res = '';
+    let res = "";
     try {
-        res = execSync('which mops').toString();
+        res = execSync("which mops").toString();
     }
     catch (e) { }
     if (!res) {
-        console.error(chalk.red('Couldn\'t detect package manager'));
+        console.error(chalk.red("Couldn't detect package manager"));
         process.exit(1);
     }
-    if (res.includes('pnpm/')) {
-        return 'pnpm';
+    if (res.includes("pnpm/")) {
+        return "pnpm";
     }
     // else if (res.includes('bun/')) {
     // 	return 'bun';
     // }
     else {
-        return 'npm';
+        return "npm";
     }
 }
 export async function getLatestVersion() {
-    let res = await fetch(url + '/tags/latest');
+    let res = await fetch(url + "/tags/latest");
     return res.text();
 }
 export async function update() {
     let latest = await getLatestVersion();
     let current = version();
     if (latest === current) {
-        console.log(chalk.green('You are up to date. Version: ' + current));
+        console.log(chalk.green("You are up to date. Version: " + current));
     }
     else {
-        console.log('Current version: ' + chalk.yellow(current));
-        console.log('Updating to version: ' + chalk.green(latest));
+        console.log("Current version: " + chalk.yellow(current));
+        console.log("Updating to version: " + chalk.green(latest));
         let pm = detectPackageManager();
-        let npmArgs = pm === 'npm' ? ['--no-fund', '--silent'] : [];
-        let proc = child_process.spawn(pm, ['add', '-g', ...npmArgs, `${url}/versions/${latest}.tgz`], { stdio: 'inherit', detached: false });
-        proc.on('exit', (res) => {
+        let npmArgs = pm === "npm" ? ["--no-fund", "--silent"] : [];
+        let proc = child_process.spawn(pm, ["add", "-g", ...npmArgs, `${url}/versions/${latest}.tgz`], { stdio: "inherit", detached: false });
+        proc.on("exit", (res) => {
             if (res !== 0) {
-                console.log(chalk.red('Failed to update.'));
+                console.log(chalk.red("Failed to update."));
                 process.exit(1);
             }
-            console.log(chalk.green('Success'));
+            console.log(chalk.green("Success"));
         });
     }
 }
 export async function uninstall() {
-    console.log('Cleaning cache...');
+    console.log("Cleaning cache...");
     cleanCache();
-    console.log('Resetting toolchain management...');
+    console.log("Resetting toolchain management...");
     toolchain.init({ reset: true, silent: true });
-    console.log('Uninstalling mops CLI...');
+    console.log("Uninstalling mops CLI...");
     let pm = detectPackageManager();
-    child_process.spawn(pm, ['remove', '-g', '--silent', 'ic-mops'], { stdio: 'inherit', detached: false });
-    console.log(chalk.yellow('Config directory has not been deleted: ' + globalConfigDir));
-    console.log('Uninstalled');
+    child_process.spawn(pm, ["remove", "-g", "--silent", "ic-mops"], {
+        stdio: "inherit",
+        detached: false,
+    });
+    console.log(chalk.yellow("Config directory has not been deleted: " + globalConfigDir));
+    console.log("Uninstalled");
 }

package/dist/commands/sources.d.ts

@@ -1,4 +1,8 @@
-export declare function sources({ conflicts, cwd }?: {
+export declare function sourcesArgs({ conflicts, cwd, }?: {
+    conflicts?: "ignore" | "error" | "warning" | undefined;
+    cwd?: string | undefined;
+}): Promise<string[][]>;
+export declare function sources({ conflicts, cwd, }?: {
     conflicts?: "ignore" | "error" | "warning" | undefined;
     cwd?: string | undefined;
 }): Promise<string[]>;

package/dist/commands/sources.js

@@ -1,24 +1,25 @@
-import process from 'node:process';
-import path from 'node:path';
-import fs from 'node:fs';
-import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig } from '../mops.js';
-import { resolvePackages } from '../resolve-packages.js';
-export async function sources({ conflicts = 'ignore', cwd = process.cwd() } = {}) {
+import process from "node:process";
+import path from "node:path";
+import fs from "node:fs";
+import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig, } from "../mops.js";
+import { resolvePackages } from "../resolve-packages.js";
+export async function sourcesArgs({ conflicts = "ignore", cwd = process.cwd(), } = {}) {
     if (!checkConfigFile()) {
         return [];
     }
     let resolvedPackages = await resolvePackages({ conflicts });
     // sources
-    return Object.entries(resolvedPackages).map(([name, version]) => {
+    return Object.entries(resolvedPackages)
+        .map(([name, version]) => {
         let depType = getDependencyType(version);
         let pkgDir;
-        if (depType === 'local') {
+        if (depType === "local") {
             pkgDir = path.relative(cwd, version);
         }
-        else if (depType === 'github') {
+        else if (depType === "github") {
             pkgDir = path.relative(cwd, formatGithubDir(name, version));
         }
-        else if (depType === 'mops') {
+        else if (depType === "mops") {
             pkgDir = path.relative(cwd, formatDir(name, version));
         }
         else {
@@ -26,17 +27,22 @@ export async function sources({ conflicts = 'ignore', cwd = process.cwd() } = {}
         }
         // append baseDir
         let pkgBaseDir;
-        if (fs.existsSync(path.join(pkgDir, 'mops.toml'))) {
-            let config = readConfig(path.join(pkgDir, 'mops.toml'));
-            pkgBaseDir = path.join(pkgDir, config.package?.baseDir || 'src');
+        if (fs.existsSync(path.join(pkgDir, "mops.toml"))) {
+            let config = readConfig(path.join(pkgDir, "mops.toml"));
+            pkgBaseDir = path.join(pkgDir, config.package?.baseDir || "src");
         }
         else {
-            pkgBaseDir = path.join(pkgDir, 'src');
+            pkgBaseDir = path.join(pkgDir, "src");
         }
         // use pkgDir if baseDir doesn't exist for local packages
-        if (depType === 'local' && !fs.existsSync(path.resolve(cwd, pkgBaseDir))) {
+        if (depType === "local" &&
+            !fs.existsSync(path.resolve(cwd, pkgBaseDir))) {
             pkgBaseDir = pkgDir;
         }
-        return `--package ${name} ${pkgBaseDir}`;
-    }).filter(x => x != null);
+        return ["--package", name, pkgBaseDir];
+    })
+        .filter((x) => x != null);
+}
+export async function sources({ conflicts = "ignore", cwd = process.cwd(), } = {}) {
+    return (await sourcesArgs({ conflicts, cwd })).map((args) => args.join(" "));
 }

package/dist/commands/sync.d.ts

@@ -1,5 +1,5 @@
 type SyncOptions = {
-    lock?: 'update' | 'ignore';
+    lock?: "update" | "ignore";
 };
 export declare function sync({ lock }?: SyncOptions): Promise<void>;
 export {};

package/dist/commands/sync.js

@@ -1,54 +1,61 @@
-import path from 'node:path';
-import { execSync } from 'node:child_process';
-import { globSync } from 'glob';
-import chalk from 'chalk';
-import { checkConfigFile, getRootDir, readConfig } from '../mops.js';
-import { add } from './add.js';
-import { remove } from './remove.js';
-import { checkIntegrity } from '../integrity.js';
-import { getMocPath } from '../helpers/get-moc-path.js';
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { globSync } from "glob";
+import chalk from "chalk";
+import { checkConfigFile, getRootDir, readConfig } from "../mops.js";
+import { add } from "./add.js";
+import { remove } from "./remove.js";
+import { checkIntegrity } from "../integrity.js";
+import { getMocPath } from "../helpers/get-moc-path.js";
 export async function sync({ lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
     let missing = await getMissingPackages();
     let unused = await getUnusedPackages();
-    missing.length && console.log(`${chalk.yellow('Missing packages:')} ${missing.join(', ')}`);
-    unused.length && console.log(`${chalk.yellow('Unused packages:')} ${unused.join(', ')}`);
+    missing.length &&
+        console.log(`${chalk.yellow("Missing packages:")} ${missing.join(", ")}`);
+    unused.length &&
+        console.log(`${chalk.yellow("Unused packages:")} ${unused.join(", ")}`);
     let config = readConfig();
     let deps = new Set(Object.keys(config.dependencies || {}));
-    let devDeps = new Set(Object.keys(config['dev-dependencies'] || {}));
+    let devDeps = new Set(Object.keys(config["dev-dependencies"] || {}));
     // add missing packages
     for (let pkg of missing) {
-        await add(pkg, { lock: 'ignore' });
+        await add(pkg, { lock: "ignore" });
     }
     // remove unused packages
     for (let pkg of unused) {
         let dev = devDeps.has(pkg) && !deps.has(pkg);
-        await remove(pkg, { dev, lock: 'ignore' });
+        await remove(pkg, { dev, lock: "ignore" });
     }
     await checkIntegrity(lock);
 }
 let ignore = [
-    '**/node_modules/**',
-    '**/.vessel/**',
-    '**/.git/**',
-    '**/.mops/**',
+    "**/node_modules/**",
+    "**/.vessel/**",
+    "**/.git/**",
+    "**/.mops/**",
 ];
 async function getUsedPackages() {
     let rootDir = getRootDir();
     let mocPath = getMocPath();
-    let files = globSync('**/*.mo', {
+    let files = globSync("**/*.mo", {
         cwd: rootDir,
         nocase: true,
         ignore: ignore,
     });
-    let packages = new Set;
+    let packages = new Set();
     for (let file of files) {
-        let deps = execSync(`${mocPath} --print-deps ${path.join(rootDir, file)}`).toString().trim().split('\n');
+        let deps = execSync(`${mocPath} --print-deps ${path.join(rootDir, file)}`)
+            .toString()
+            .trim()
+            .split("\n");
         for (let dep of deps) {
-            if (dep.startsWith('mo:') && !dep.startsWith('mo:prim') && !dep.startsWith('mo:⛔')) {
-                packages.add(dep.replace(/^mo:([^/]+).*$/, '$1'));
+            if (dep.startsWith("mo:") &&
+                !dep.startsWith("mo:prim") &&
+                !dep.startsWith("mo:⛔")) {
+                packages.add(dep.replace(/^mo:([^/]+).*$/, "$1"));
             }
         }
     }
@@ -56,7 +63,10 @@ async function getUsedPackages() {
 }
 async function getMissingPackages() {
     let config = readConfig();
-    let allDeps = [...Object.keys(config.dependencies || {}), ...Object.keys(config['dev-dependencies'] || {})];
+    let allDeps = [
+        ...Object.keys(config.dependencies || {}),
+        ...Object.keys(config["dev-dependencies"] || {}),
+    ];
     let missing = new Set(await getUsedPackages());
     for (let pkg of allDeps) {
         missing.delete(pkg);
@@ -65,7 +75,10 @@ async function getMissingPackages() {
 }
 async function getUnusedPackages() {
     let config = readConfig();
-    let allDeps = new Set([...Object.keys(config.dependencies || {}), ...Object.keys(config['dev-dependencies'] || {})]);
+    let allDeps = new Set([
+        ...Object.keys(config.dependencies || {}),
+        ...Object.keys(config["dev-dependencies"] || {}),
+    ]);
     let used = await getUsedPackages();
     for (let pkg of used) {
         allDeps.delete(pkg);