ic-mops 1.11.1 → 2.0.0

package/commands/add.ts

@@ -1,134 +1,147 @@
-import process from 'node:process';
-import path from 'node:path';
-import chalk from 'chalk';
-import {createLogUpdate} from 'log-update';
-import {checkConfigFile, getGithubCommit, parseGithubURL, readConfig, writeConfig} from '../mops.js';
-import {getHighestVersion} from '../api/getHighestVersion.js';
-import {installMopsDep} from './install/install-mops-dep.js';
-import {installFromGithub} from '../vessel.js';
-import {checkIntegrity} from '../integrity.js';
-import {checkRequirements} from '../check-requirements.js';
-import {syncLocalCache} from './install/sync-local-cache.js';
-import {notifyInstalls} from '../notify-installs.js';
-import {resolvePackages} from '../resolve-packages.js';
+import process from "node:process";
+import path from "node:path";
+import chalk from "chalk";
+import { createLogUpdate } from "log-update";
+import {
+  checkConfigFile,
+  getGithubCommit,
+  parseGithubURL,
+  readConfig,
+  writeConfig,
+} from "../mops.js";
+import { getHighestVersion } from "../api/getHighestVersion.js";
+import { installMopsDep } from "./install/install-mops-dep.js";
+import { installFromGithub } from "../vessel.js";
+import { checkIntegrity } from "../integrity.js";
+import { checkRequirements } from "../check-requirements.js";
+import { syncLocalCache } from "./install/sync-local-cache.js";
+import { notifyInstalls } from "../notify-installs.js";
+import { resolvePackages } from "../resolve-packages.js";
 
 type AddOptions = {
-	verbose ?: boolean;
-	dev ?: boolean;
-	lock ?: 'update' | 'ignore';
+  verbose?: boolean;
+  dev?: boolean;
+  lock?: "update" | "ignore";
 };
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function add(name : string, {verbose = false, dev = false, lock} : AddOptions = {}, asName ?: string) {
-	if (!checkConfigFile()) {
-		return;
-	}
-
-	let config = readConfig();
-	if (dev) {
-		if (!config['dev-dependencies']) {
-			config['dev-dependencies'] = {};
-		}
-	}
-	else {
-		if (!config.dependencies) {
-			config.dependencies = {};
-		}
-	}
-
-	let pkgDetails : any;
-
-	// local package
-	if (name.startsWith('./') || name.startsWith('../') || name.startsWith('/')) {
-		pkgDetails = {
-			name: path.parse(name).name === '.' ? '_' : path.parse(name).name,
-			path: name,
-			repo: '',
-			version: '',
-		};
-	}
-	// github package
-	else if (name.startsWith('https://github.com') || name.split('/').length > 1) {
-		let {org, gitName, branch, commitHash} = parseGithubURL(name);
-
-		// fetch latest commit hash of branch if not specified
-		if (!commitHash) {
-			let commit = await getGithubCommit(`${org}/${gitName}`, branch);
-			if (!commit.sha) {
-				throw Error(`Could not find commit hash for ${name}`);
-			}
-			commitHash = commit.sha;
-		}
-
-		pkgDetails = {
-			name: asName || parseGithubURL(name).gitName,
-			repo: `https://github.com/${org}/${gitName}#${branch}@${commitHash}`,
-			version: '',
-		};
-	}
-	// mops package
-	else {
-		let ver : string;
-		if (name.includes('@')) {
-			// @ts-ignore
-			[name, ver] = name.split('@');
-		}
-		else {
-			let versionRes = await getHighestVersion(name);
-			if ('err' in versionRes) {
-				console.log(chalk.red('Error: ') + versionRes.err);
-				return;
-			}
-			ver = versionRes.ok;
-		}
-
-		pkgDetails = {
-			name: name,
-			repo: '',
-			version: ver,
-		};
-	}
-
-	if (pkgDetails.repo) {
-		await installFromGithub(pkgDetails.name, pkgDetails.repo, {verbose: verbose});
-	}
-	else if (!pkgDetails.path) {
-		let res = await installMopsDep(pkgDetails.name, pkgDetails.version, {verbose: verbose});
-		if (res === false) {
-			return;
-		}
-	}
-
-	const depsProp = dev ? 'dev-dependencies' : 'dependencies';
-	let deps = config[depsProp];
-	if (deps) {
-		deps[pkgDetails.name] = pkgDetails;
-	}
-	else {
-		throw Error(`Invalid config file: [${depsProp}] not found`);
-	}
-
-	writeConfig(config);
-
-	let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
-
-	if (lock !== 'ignore') {
-		logUpdate('Checking integrity...');
-	}
-
-	let installedPackages = await syncLocalCache();
-
-	await Promise.all([
-		notifyInstalls(installedPackages),
-		checkIntegrity(lock),
-	]);
-
-	logUpdate.clear();
-
-	await checkRequirements({verbose});
-
-	console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
-
-	// check conflicts
-	await resolvePackages({conflicts: 'warning'});
-}
+export async function add(
+  name: string,
+  { verbose = false, dev = false, lock }: AddOptions = {},
+  asName?: string,
+) {
+  if (!checkConfigFile()) {
+    return;
+  }
+
+  let config = readConfig();
+  if (dev) {
+    if (!config["dev-dependencies"]) {
+      config["dev-dependencies"] = {};
+    }
+  } else {
+    if (!config.dependencies) {
+      config.dependencies = {};
+    }
+  }
+
+  let pkgDetails: any;
+
+  // local package
+  if (name.startsWith("./") || name.startsWith("../") || name.startsWith("/")) {
+    pkgDetails = {
+      name: path.parse(name).name === "." ? "_" : path.parse(name).name,
+      path: name,
+      repo: "",
+      version: "",
+    };
+  }
+  // github package
+  else if (
+    name.startsWith("https://github.com") ||
+    name.split("/").length > 1
+  ) {
+    let { org, gitName, branch, commitHash } = parseGithubURL(name);
+
+    // fetch latest commit hash of branch if not specified
+    if (!commitHash) {
+      let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+      if (!commit.sha) {
+        throw Error(`Could not find commit hash for ${name}`);
+      }
+      commitHash = commit.sha;
+    }
+
+    pkgDetails = {
+      name: asName || parseGithubURL(name).gitName,
+      repo: `https://github.com/${org}/${gitName}#${branch}@${commitHash}`,
+      version: "",
+    };
+  }
+  // mops package
+  else {
+    let ver: string;
+    if (name.includes("@")) {
+      // @ts-ignore
+      [name, ver] = name.split("@");
+    } else {
+      let versionRes = await getHighestVersion(name);
+      if ("err" in versionRes) {
+        console.log(chalk.red("Error: ") + versionRes.err);
+        return;
+      }
+      ver = versionRes.ok;
+    }
+
+    pkgDetails = {
+      name: asName || name,
+      repo: "",
+      version: ver,
+    };
+  }
+
+  if (pkgDetails.repo) {
+    await installFromGithub(pkgDetails.name, pkgDetails.repo, {
+      verbose: verbose,
+    });
+  } else if (!pkgDetails.path) {
+    let res = await installMopsDep(pkgDetails.name, pkgDetails.version, {
+      verbose: verbose,
+    });
+    if (res === false) {
+      return;
+    }
+  }
+
+  const depsProp = dev ? "dev-dependencies" : "dependencies";
+  let deps = config[depsProp];
+  if (deps) {
+    deps[pkgDetails.name] = pkgDetails;
+  } else {
+    throw Error(`Invalid config file: [${depsProp}] not found`);
+  }
+
+  writeConfig(config);
+
+  let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+
+  if (lock !== "ignore") {
+    logUpdate("Checking integrity...");
+  }
+
+  let installedPackages = await syncLocalCache();
+
+  await Promise.all([notifyInstalls(installedPackages), checkIntegrity(lock)]);
+
+  logUpdate.clear();
+
+  await checkRequirements({ verbose });
+
+  console.log(
+    chalk.green("Package installed ") +
+      `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`,
+  );
+
+  // check conflicts
+  await resolvePackages({ conflicts: "warning" });
+}

package/commands/available-updates.ts

@@ -1,35 +1,62 @@
-import process from 'node:process';
-import chalk from 'chalk';
-import {mainActor} from '../api/actors.js';
-import {Config} from '../types.js';
-import {getDepName} from '../helpers/get-dep-name.js';
+import process from "node:process";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
+import { Config } from "../types.js";
+import { getDepName, getDepPinnedVersion } from "../helpers/get-dep-name.js";
+import { SemverPart } from "../declarations/main/main.did.js";
 
 // [pkg, oldVersion, newVersion]
-export async function getAvailableUpdates(config : Config, pkg ?: string) : Promise<Array<[string, string, string]>> {
-	let deps = Object.values(config.dependencies || {});
-	let devDeps = Object.values(config['dev-dependencies'] || {});
-	let allDeps = [...deps, ...devDeps].filter((dep) => dep.version);
-	let depsToUpdate = pkg ? allDeps.filter((dep) => dep.name === pkg) : allDeps;
+export async function getAvailableUpdates(
+  config: Config,
+  pkg?: string,
+): Promise<Array<[string, string, string]>> {
+  let deps = Object.values(config.dependencies || {});
+  let devDeps = Object.values(config["dev-dependencies"] || {});
+  let allDeps = [...deps, ...devDeps].filter((dep) => dep.version);
+  let depsToUpdate = pkg ? allDeps.filter((dep) => dep.name === pkg) : allDeps;
 
-	// skip pinned dependencies
-	depsToUpdate = depsToUpdate.filter((dep) => getDepName(dep.name) === dep.name);
+  // skip hard pinned dependencies (e.g. "base@X.Y.Z")
+  depsToUpdate = depsToUpdate.filter(
+    (dep) =>
+      getDepName(dep.name) === dep.name ||
+      getDepPinnedVersion(dep.name).split(".").length !== 3,
+  );
 
-	let getCurrentVersion = (pkg : string) => {
-		for (let dep of allDeps) {
-			if (dep.name === pkg && dep.version) {
-				return dep.version;
-			}
-		}
-		return '';
-	};
+  let getCurrentVersion = (pkg: string, updateVersion: string) => {
+    for (let dep of allDeps) {
+      if (getDepName(dep.name) === pkg && dep.version) {
+        let pinnedVersion = getDepPinnedVersion(dep.name);
+        if (pinnedVersion && !updateVersion.startsWith(pinnedVersion)) {
+          continue;
+        }
+        return dep.version;
+      }
+    }
+    return "";
+  };
 
-	let actor = await mainActor();
-	let res = await actor.getHighestSemverBatch(depsToUpdate.map((dep) => [dep.name, dep.version || '', {major: null}]));
+  let actor = await mainActor();
+  let res = await actor.getHighestSemverBatch(
+    depsToUpdate.map((dep) => {
+      let semverPart: SemverPart = { major: null };
+      let name = getDepName(dep.name);
+      let pinnedVersion = getDepPinnedVersion(dep.name);
+      if (pinnedVersion) {
+        semverPart =
+          pinnedVersion.split(".").length === 1
+            ? { minor: null }
+            : { patch: null };
+      }
+      return [name, dep.version || "", semverPart];
+    }),
+  );
 
-	if ('err' in res) {
-		console.log(chalk.red('Error:'), res.err);
-		process.exit(1);
-	}
+  if ("err" in res) {
+    console.log(chalk.red("Error:"), res.err);
+    process.exit(1);
+  }
 
-	return res.ok.filter((dep) => dep[1] !== getCurrentVersion(dep[0])).map((dep) => [dep[0], getCurrentVersion(dep[0]), dep[1]]);
-}
+  return res.ok
+    .filter((dep) => dep[1] !== getCurrentVersion(dep[0], dep[1]))
+    .map((dep) => [dep[0], getCurrentVersion(dep[0], dep[1]), dep[1]]);
+}

package/commands/bench/bench-canister.mo

@@ -1,113 +1,119 @@
-import Nat64 "mo:base/Nat64";
-import Nat "mo:base/Nat";
-import Debug "mo:base/Debug";
-import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
-import ExperimentalStableMemory "mo:base/ExperimentalStableMemory";
-import Int64 "mo:base/Int64";
-import Region "mo:base/Region";
+import Nat64 "mo:core/Nat64";
+import Nat "mo:core/Nat";
+import Runtime "mo:core/Runtime";
+import InternetComputer "mo:core/InternetComputer";
+import Int64 "mo:core/Int64";
+import Region "mo:core/Region";
 import Prim "mo:prim";
 import Bench "mo:bench";
 
 import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
 
-persistent actor class() {
-	type BenchResult = {
-		instructions : Int;
-		rts_mutator_instructions : Int;
-		stable_memory_size : Int;
-		rts_stable_memory_size : Int;
-		rts_logical_stable_memory_size : Int;
-		rts_collector_instructions : Int;
-		rts_heap_size : Int;
-		rts_memory_size : Int;
-		rts_total_allocation : Int;
-		rts_reclaimed : Int;
-	};
-
-	transient var benchOpt : ?Bench.Bench = null;
-
-	public func init() : async Bench.BenchSchema {
-		let bench = UserBench.init();
-		benchOpt := ?bench;
-		// ignore ExperimentalStableMemory.grow(1);
-		ignore Region.grow(Region.new(), 1);
-		bench.getSchema();
-	};
-
-	public query func getSchema() : async Bench.BenchSchema {
-		let ?bench = benchOpt else Debug.trap("bench not initialized");
-		bench.getSchema();
-	};
-
-	func _getStats() : BenchResult {
-		{
-			instructions = 0;
-			rts_heap_size = Prim.rts_heap_size();
-			stable_memory_size = Int64.toInt(Int64.fromNat64(ExperimentalStableMemory.size())) * 65536;
-			rts_stable_memory_size = Prim.rts_stable_memory_size();
-			rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
-			rts_memory_size = Prim.rts_memory_size();
-			rts_total_allocation = Prim.rts_total_allocation();
-			rts_reclaimed = Prim.rts_reclaimed();
-			rts_mutator_instructions = Prim.rts_mutator_instructions();
-			rts_collector_instructions = Prim.rts_collector_instructions();
-		}
-	};
-
-	func _diffStats(before : BenchResult, after : BenchResult) : BenchResult {
-		{
-			instructions = after.instructions - before.instructions;
-			rts_heap_size = after.rts_heap_size - before.rts_heap_size;
-			stable_memory_size = after.stable_memory_size - before.stable_memory_size;
-			rts_stable_memory_size = after.rts_stable_memory_size - before.rts_stable_memory_size;
-			rts_logical_stable_memory_size = after.rts_logical_stable_memory_size - before.rts_logical_stable_memory_size;
-			rts_memory_size = after.rts_memory_size - before.rts_memory_size;
-			rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
-			rts_reclaimed = after.rts_reclaimed - before.rts_reclaimed;
-			rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
-			rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
-		}
-	};
-
-	func _runCell(rowIndex : Nat, colIndex : Nat) : BenchResult {
-		let ?bench = benchOpt else Debug.trap("bench not initialized");
-		let statsBefore = _getStats();
-
-		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
-			bench.runCell(rowIndex, colIndex);
-		}));
-
-		let statsAfter = _getStats();
-		_diffStats(statsBefore, { statsAfter with instructions });
-	};
-
-	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		let ?bench = benchOpt else Debug.trap("bench not initialized");
-		let statsBefore = _getStats();
-
-		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
-			bench.runCell(rowIndex, colIndex);
-		}));
-
-		await (func() : async () {})();
-
-		let statsAfter = _getStats();
-		_diffStats(statsBefore, { statsAfter with instructions });
-	};
-
-	public query func getStats() : async BenchResult {
-		_getStats();
-	};
-
-	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		_runCell(rowIndex, colIndex);
-	};
-
-	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		_runCell(rowIndex, colIndex);
-	};
-
-	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		await _runCellAwait(rowIndex, colIndex);
-	};
-};
+persistent actor class () {
+  type BenchResult = {
+    instructions : Int;
+    rts_mutator_instructions : Int;
+    stable_memory_size : Int;
+    rts_stable_memory_size : Int;
+    rts_logical_stable_memory_size : Int;
+    rts_collector_instructions : Int;
+    rts_heap_size : Int;
+    rts_memory_size : Int;
+    rts_total_allocation : Int;
+    rts_reclaimed : Int;
+  };
+
+  transient var benchOpt : ?Bench.Bench = null;
+
+  public func init() : async Bench.BenchSchema {
+    let bench = UserBench.init();
+    benchOpt := ?bench;
+    ignore Region.grow(Region.new(), 1);
+    bench.getSchema();
+  };
+
+  public query func getSchema() : async Bench.BenchSchema {
+    let ?bench = benchOpt else Runtime.trap("bench not initialized");
+    bench.getSchema();
+  };
+
+  func _getStats() : BenchResult {
+    {
+      instructions = 0;
+      rts_heap_size = Prim.rts_heap_size();
+      stable_memory_size = Int64.toInt(Int64.fromNat64(Prim.stableMemorySize())) * 65536;
+      rts_stable_memory_size = Prim.rts_stable_memory_size();
+      rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
+      rts_memory_size = Prim.rts_memory_size();
+      rts_total_allocation = Prim.rts_total_allocation();
+      rts_reclaimed = Prim.rts_reclaimed();
+      rts_mutator_instructions = Prim.rts_mutator_instructions();
+      rts_collector_instructions = Prim.rts_collector_instructions();
+    };
+  };
+
+  func _diffStats(before : BenchResult, after : BenchResult) : BenchResult {
+    {
+      instructions = after.instructions - before.instructions;
+      rts_heap_size = after.rts_heap_size - before.rts_heap_size;
+      stable_memory_size = after.stable_memory_size - before.stable_memory_size;
+      rts_stable_memory_size = after.rts_stable_memory_size - before.rts_stable_memory_size;
+      rts_logical_stable_memory_size = after.rts_logical_stable_memory_size - before.rts_logical_stable_memory_size;
+      rts_memory_size = after.rts_memory_size - before.rts_memory_size;
+      rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
+      rts_reclaimed = after.rts_reclaimed - before.rts_reclaimed;
+      rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
+      rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
+    };
+  };
+
+  func _runCell(rowIndex : Nat, colIndex : Nat) : BenchResult {
+    let ?bench = benchOpt else Runtime.trap("bench not initialized");
+    let statsBefore = _getStats();
+
+    let instructions = Nat64.toNat(
+      InternetComputer.countInstructions(
+        func() {
+          bench.runCell(rowIndex, colIndex);
+        }
+      )
+    );
+
+    let statsAfter = _getStats();
+    _diffStats(statsBefore, { statsAfter with instructions });
+  };
+
+  func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    let ?bench = benchOpt else Runtime.trap("bench not initialized");
+    let statsBefore = _getStats();
+
+    let instructions = Nat64.toNat(
+      InternetComputer.countInstructions(
+        func() {
+          bench.runCell(rowIndex, colIndex);
+        }
+      )
+    );
+
+    await (func() : async () {})();
+
+    let statsAfter = _getStats();
+    _diffStats(statsBefore, { statsAfter with instructions });
+  };
+
+  public query func getStats() : async BenchResult {
+    _getStats();
+  };
+
+  public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    _runCell(rowIndex, colIndex);
+  };
+
+  public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    _runCell(rowIndex, colIndex);
+  };
+
+  public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    await _runCellAwait(rowIndex, colIndex);
+  };
+};

package/commands/bench/user-bench.mo

@@ -2,9 +2,9 @@ import Bench "mo:bench";
 
 // placeholder file that will be replaced with the *.bench.mo file
 module {
-	public func init() : Bench.Bench {
-		let bench = Bench.Bench();
-		// benchmark code goes here...
-		bench;
-	};
-};
+  public func init() : Bench.Bench {
+    let bench = Bench.Bench();
+    // benchmark code goes here...
+    bench;
+  };
+};