ic-mops 0.34.4 → 0.36.0

package/dist/commands/bench-replica.js

@@ -0,0 +1,87 @@
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import { execaCommand } from 'execa';
+import { PocketIc } from '@hadronous/pic';
+import { getRootDir } from '../mops.js';
+import { createActor, idlFactory } from '../declarations/bench/index.js';
+export class BenchReplica {
+    constructor(type, verbose = false) {
+        this.verbose = false;
+        this.canisters = {};
+        this.type = type;
+        this.verbose = verbose;
+    }
+    async start() {
+        console.log(`Starting ${this.type} replica...`);
+        if (this.type == 'dfx') {
+            await this.stop();
+            let dir = path.join(getRootDir(), '.mops/.bench');
+            fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
+            execSync('dfx start --background --clean --artificial-delay 0' + (this.verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', this.verbose ? 'inherit' : 'ignore', 'inherit'] });
+        }
+        else {
+            this.pocketIc = await PocketIc.create();
+        }
+    }
+    async stop() {
+        if (this.type == 'dfx') {
+            let dir = path.join(getRootDir(), '.mops/.bench');
+            execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe'] });
+        }
+        else if (this.pocketIc) {
+            this.pocketIc.tearDown();
+        }
+    }
+    async deploy(name, wasm, cwd = process.cwd()) {
+        if (this.type === 'dfx') {
+            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+            let canisterId = execSync(`dfx canister id ${name}`, { cwd }).toString().trim();
+            let actor = await createActor(canisterId, {
+                agentOptions: {
+                    host: 'http://127.0.0.1:4944',
+                },
+            });
+            this.canisters[name] = { cwd, canisterId, actor };
+        }
+        else if (this.pocketIc) {
+            let { canisterId, actor } = await this.pocketIc.setupCanister(idlFactory, wasm);
+            this.canisters[name] = {
+                cwd,
+                canisterId: canisterId.toText(),
+                actor,
+            };
+        }
+    }
+    getActor(name) {
+        return this.canisters[name]?.actor;
+    }
+    getCanisterId(name) {
+        return this.canisters[name]?.canisterId || '';
+    }
+    dfxJson(canisterName) {
+        let canisters = {};
+        if (canisterName) {
+            canisters[canisterName] = {
+                type: 'custom',
+                wasm: 'canister.wasm',
+                candid: 'canister.did',
+            };
+        }
+        return {
+            version: 1,
+            canisters,
+            defaults: {
+                build: {
+                    packtool: 'mops sources',
+                },
+            },
+            networks: {
+                local: {
+                    type: 'ephemeral',
+                    bind: '127.0.0.1:4944',
+                },
+            },
+        };
+    }
+}

package/dist/commands/bench.d.ts

@@ -1,11 +1,12 @@
 type BenchOptions = {
-    dfx?: string;
-    moc?: string;
-    gc?: 'copying' | 'compacting' | 'generational' | 'incremental';
-    forceGc?: boolean;
-    save?: boolean;
-    compare?: boolean;
-    verbose?: boolean;
+    replica: 'dfx' | 'pocket-ic';
+    replicaVersion: string;
+    moc: string;
+    gc: 'copying' | 'compacting' | 'generational' | 'incremental';
+    forceGc: boolean;
+    save: boolean;
+    compare: boolean;
+    verbose: boolean;
 };
-export declare function bench(filter?: string, options?: BenchOptions): Promise<boolean>;
+export declare function bench(filter?: string, optionsArg?: Partial<BenchOptions>): Promise<boolean>;
 export {};

package/dist/commands/bench.js

@@ -1,4 +1,3 @@
-import { execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -6,15 +5,16 @@ import chalk from 'chalk';
 import { globSync } from 'glob';
 import { markdownTable } from 'markdown-table';
 import logUpdate from 'log-update';
+import { execaCommand } from 'execa';
+import stringWidth from 'string-width';
 import { getRootDir } from '../mops.js';
 import { parallel } from '../parallel.js';
-import { createActor } from '../declarations/bench/index.js';
 import { absToRel } from './test/utils.js';
 import { getMocVersion } from '../helpers/get-moc-version.js';
 import { getDfxVersion } from '../helpers/get-dfx-version.js';
 import { getMocPath } from '../helpers/get-moc-path.js';
 import { sources } from './sources.js';
-import { execaCommand } from 'execa';
+import { BenchReplica } from './bench-replica.js';
 let ignore = [
     '**/node_modules/**',
     '**/.mops/**',
@@ -25,18 +25,21 @@ let globConfig = {
     nocase: true,
     ignore: ignore,
 };
-export async function bench(filter = '', options = {}) {
+export async function bench(filter = '', optionsArg = {}) {
     let defaultOptions = {
+        replica: 'dfx',
         moc: getMocVersion(),
-        dfx: getDfxVersion(),
-        gc: 'incremental',
+        replicaVersion: '0.0.0',
+        gc: 'copying',
         forceGc: true,
         save: false,
         compare: false,
         verbose: false,
     };
-    options = { ...defaultOptions, ...options };
+    let options = { ...defaultOptions, ...optionsArg };
+    options.replicaVersion = options.replica == 'dfx' ? getDfxVersion() : '1.0.0';
     options.verbose && console.log(options);
+    let replica = new BenchReplica(options.replica, options.verbose);
     let rootDir = getRootDir();
     let globStr = '**/bench?(mark)/**/*.bench.mo';
     if (filter) {
@@ -63,16 +66,15 @@ export async function bench(filter = '', options = {}) {
     console.log('');
     console.log('='.repeat(50));
     console.log('');
-    console.log('Starting dfx replica...');
-    startDfx(options.verbose);
+    await replica.start();
     console.log('Deploying canisters...');
     await parallel(os.cpus().length, files, async (file) => {
         try {
-            await deployBenchFile(file, options);
+            await deployBenchFile(file, options, replica);
         }
         catch (err) {
-            console.error('Unexpected error. Stopping dfx replica...');
-            stopDfx(options.verbose);
+            console.error('Unexpected error. Stopping replica...');
+            await replica.stop();
             throw err;
         }
     });
@@ -81,16 +83,16 @@ export async function bench(filter = '', options = {}) {
         console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
         console.log('');
         try {
-            await runBenchFile(file, options);
+            await runBenchFile(file, options, replica);
         }
         catch (err) {
-            console.error('Unexpected error. Stopping dfx replica...');
-            stopDfx(options.verbose);
+            console.error('Unexpected error. Stopping replica...');
+            await replica.stop();
             throw err;
         }
     });
-    console.log('Stopping dfx replica...');
-    stopDfx(options.verbose);
+    console.log('Stopping replica...');
+    await replica.stop();
     fs.rmSync(benchDir, { recursive: true, force: true });
     return true;
 }
@@ -104,49 +106,13 @@ function getMocArgs(options) {
     }
     return args;
 }
-function dfxJson(canisterName, options = {}) {
-    options || console.log(options);
-    let canisters = {};
-    if (canisterName) {
-        canisters[canisterName] = {
-            type: 'custom',
-            wasm: 'canister.wasm',
-            candid: 'canister.did',
-        };
-    }
-    return {
-        version: 1,
-        canisters,
-        defaults: {
-            build: {
-                packtool: 'mops sources',
-            },
-        },
-        networks: {
-            local: {
-                type: 'ephemeral',
-                bind: '127.0.0.1:4944',
-            },
-        },
-    };
-}
-function startDfx(verbose = false) {
-    stopDfx(verbose);
-    let dir = path.join(getRootDir(), '.mops/.bench');
-    fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(dfxJson(''), null, 2));
-    execSync('dfx start --background --clean --artificial-delay 0' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit'] });
-}
-function stopDfx(verbose = false) {
-    let dir = path.join(getRootDir(), '.mops/.bench');
-    execSync('dfx stop' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe'] });
-}
-async function deployBenchFile(file, options = {}) {
+async function deployBenchFile(file, options, replica) {
     let rootDir = getRootDir();
     let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
     let canisterName = path.parse(file).name;
     // prepare temp files
     fs.mkdirSync(tempDir, { recursive: true });
-    fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(dfxJson(canisterName, options), null, 2));
+    fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(replica.dfxJson(canisterName), null, 2));
     let benchCanisterData = fs.readFileSync(new URL('./bench/bench-canister.mo', import.meta.url), 'utf8');
     benchCanisterData = benchCanisterData.replace('./user-bench', path.relative(tempDir, file).replace(/.mo$/g, ''));
     fs.writeFileSync(path.join(tempDir, 'canister.mo'), benchCanisterData);
@@ -157,30 +123,21 @@ async function deployBenchFile(file, options = {}) {
     await execaCommand(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(' ')}`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
     options.verbose && console.timeEnd(`build ${canisterName}`);
     // deploy canister
+    let wasm = path.join(tempDir, 'canister.wasm');
     options.verbose && console.time(`deploy ${canisterName}`);
-    await execaCommand(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+    // await execaCommand(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, {cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
+    await replica.deploy(canisterName, wasm, tempDir);
     options.verbose && console.timeEnd(`deploy ${canisterName}`);
     // init bench
     options.verbose && console.time(`init ${canisterName}`);
-    let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
-    let actor = await createActor(canisterId, {
-        agentOptions: {
-            host: 'http://127.0.0.1:4944',
-        },
-    });
+    let actor = await replica.getActor(canisterName);
     await actor.init();
     options.verbose && console.timeEnd(`init ${canisterName}`);
 }
-async function runBenchFile(file, options = {}) {
+async function runBenchFile(file, options, replica) {
     let rootDir = getRootDir();
-    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
     let canisterName = path.parse(file).name;
-    let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
-    let actor = await createActor(canisterId, {
-        agentOptions: {
-            host: 'http://127.0.0.1:4944',
-        },
-    });
+    let actor = await replica.getActor(canisterName);
     let schema = await actor.getSchema();
     // load previous results
     let prevResults;
@@ -213,8 +170,8 @@ async function runBenchFile(file, options = {}) {
                             let percent = (Number(res[prop]) - Number(prevRes[prop])) / Number(prevRes[prop]) * 100;
                             let sign = percent > 0 ? '+' : '';
                             let percentText = percent == 0 ? '0%' : sign + percent.toFixed(2) + '%';
-                            // diff = ' (' + (percent > 0 ? chalk.red(percentText) : chalk.green(percentText)) + ')'; // alignment is broken
-                            diff = ' (' + percentText + ')';
+                            let color = percent == 0 ? 'gray' : (percent > 0 ? 'red' : 'green');
+                            diff = ` (${chalk[color](percentText)})`;
                         }
                         else {
                             diff = chalk.yellow(' (no previous results)');
@@ -229,7 +186,10 @@ async function runBenchFile(file, options = {}) {
             }
             resArr.push(curRow);
         }
-        return markdownTable(resArr, { align: ['l', ...'r'.repeat(schema.cols.length)] });
+        return markdownTable(resArr, {
+            align: ['l', ...'r'.repeat(schema.cols.length)],
+            stringLength: stringWidth,
+        });
     };
     let printResults = () => {
         logUpdate(`
@@ -239,7 +199,9 @@ async function runBenchFile(file, options = {}) {
 			\n\n${chalk.blue('Heap')}\n\n${getTable('rts_heap_size')}
 		`);
     };
-    printResults();
+    if (!process.env.CI) {
+        printResults();
+    }
     // run all cells
     for (let [rowIndex, row] of schema.rows.entries()) {
         for (let [colIndex, col] of schema.cols.entries()) {
@@ -247,9 +209,14 @@ async function runBenchFile(file, options = {}) {
             // let res = await actor.runCellUpdate(BigInt(rowIndex), BigInt(colIndex));
             let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
             results.set(`${row}:${col}`, res);
-            printResults();
+            if (!process.env.CI) {
+                printResults();
+            }
         }
     }
+    if (process.env.CI) {
+        printResults();
+    }
     logUpdate.done();
     // save results
     if (options.save) {
@@ -257,7 +224,8 @@ async function runBenchFile(file, options = {}) {
         let json = {
             version: 1,
             moc: options.moc,
-            dfx: options.dfx,
+            replica: options.replica,
+            replicaVersion: options.replicaVersion,
             gc: options.gc,
             forceGc: options.forceGc,
             results: Array.from(results.entries()),

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

@@ -1,7 +1,7 @@
 type InstallAllOptions = {
     verbose?: boolean;
     silent?: boolean;
-    lockfile?: 'save' | 'check' | 'ignore';
+    lock?: 'check' | 'update' | 'ignore';
 };
-export declare function installAll({ verbose, silent, lockfile }?: InstallAllOptions): Promise<void>;
+export declare function installAll({ verbose, silent, lock }?: InstallAllOptions): Promise<void>;
 export {};

package/dist/commands/install-all.js

@@ -5,7 +5,7 @@ import { install } from './install.js';
 import { installFromGithub } from '../vessel.js';
 import { notifyInstalls } from '../notify-installs.js';
 import { checkIntegrity } from '../integrity.js';
-export async function installAll({ verbose = false, silent = false, lockfile } = {}) {
+export async function installAll({ verbose = false, silent = false, lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -26,12 +26,12 @@ export async function installAll({ verbose = false, silent = false, lockfile } =
             installedPackages = { ...installedPackages, ...res };
         }
     }
-    if (!silent && lockfile !== 'ignore') {
+    if (!silent && lock !== 'ignore') {
         logUpdate('Checking integrity...');
     }
     await Promise.all([
         notifyInstalls(Object.keys(installedPackages)),
-        checkIntegrity(lockfile),
+        checkIntegrity(lock),
     ]);
     if (!silent) {
         logUpdate.clear();

package/dist/commands/remove.d.ts

@@ -2,7 +2,7 @@ type RemoveOptions = {
     verbose?: boolean;
     dev?: boolean;
     dryRun?: boolean;
-    lockfile?: 'save' | 'ignore';
+    lock?: 'update' | 'ignore';
 };
-export declare function remove(name: string, { dev, verbose, dryRun, lockfile }?: RemoveOptions): Promise<void>;
+export declare function remove(name: string, { dev, verbose, dryRun, lock }?: RemoveOptions): Promise<void>;
 export {};

package/dist/commands/remove.js

@@ -2,8 +2,9 @@ import fs from 'node:fs';
 import { deleteSync } from 'del';
 import chalk from 'chalk';
 import { formatDir, formatGithubDir, checkConfigFile, readConfig, writeConfig } from '../mops.js';
+import { checkIntegrity } from '../integrity.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function remove(name, { dev = false, verbose = false, dryRun = false, lockfile } = {}) {
+export async function remove(name, { dev = false, verbose = false, dryRun = false, lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -80,6 +81,6 @@ export async function remove(name, { dev = false, verbose = false, dryRun = fals
         delete config['dev-dependencies'][name];
     }
     dryRun || writeConfig(config);
-    // await checkIntegrity(lockfile);
+    await checkIntegrity(lock);
     console.log(chalk.green('Package removed ') + `${name} = "${version}"`);
 }

package/dist/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -6,7 +6,7 @@ import { checkConfigFile, getRootDir, readConfig } from '../mops.js';
 import { add } from './add.js';
 import { remove } from './remove.js';
 import { checkIntegrity } from '../integrity.js';
-export async function sync({ lockfile } = {}) {
+export async function sync({ lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -19,14 +19,14 @@ export async function sync({ lockfile } = {}) {
     let devDeps = new Set(Object.keys(config['dev-dependencies'] || {}));
     // add missing packages
     for (let pkg of missing) {
-        await add(pkg, { lockfile: '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, lockfile: 'ignore' });
+        await remove(pkg, { dev, lock: 'ignore' });
     }
-    await checkIntegrity(lockfile);
+    await checkIntegrity(lock);
 }
 let ignore = [
     '**/node_modules/**',

package/dist/commands/toolchain/moc.d.ts

@@ -0,0 +1,4 @@
+export declare let isCached: (version: string) => boolean;
+export declare let download: (version: string, { silent }?: {
+    silent?: boolean | undefined;
+}) => Promise<void>;

package/dist/commands/toolchain/moc.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { globalCacheDir } from '../../mops.js';
+import { downloadGithubRelease } from './toolchain-utils.js';
+let cacheDir = path.join(globalCacheDir, 'moc');
+export let isCached = (version) => {
+    let dir = path.join(cacheDir, version);
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'moc'));
+};
+export let download = async (version, { silent = false } = {}) => {
+    if (process.platform == 'win32') {
+        console.log('Windows is not supported. Please use WSL');
+        process.exit(1);
+    }
+    if (!version) {
+        console.log('version is not defined');
+        process.exit(1);
+    }
+    if (isCached(version)) {
+        return;
+    }
+    let url;
+    if (parseInt(version.replaceAll('.', '')) >= parseInt('0.9.5'.replaceAll('.', ''))) {
+        let platfrom = process.platform == 'darwin' ? 'Darwin' : 'Linux';
+        let arch = process.arch.startsWith('arm') ? 'arm64' : 'x86_64';
+        // currently only x64 binaries are available
+        arch = 'x86_64';
+        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+    }
+    else {
+        let platfrom = process.platform == 'darwin' ? 'macos' : 'linux64';
+        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+    }
+    silent || console.log(`Downloading ${url}`);
+    await downloadGithubRelease(url, path.join(cacheDir, version));
+};

package/dist/commands/toolchain/mocv.d.ts

@@ -0,0 +1 @@
+export {};