ic-mops 1.12.0 → 2.0.0

package/commands/watch/parseDfxJson.ts

@@ -1,65 +1,71 @@
-import {existsSync, readFileSync} from 'node:fs';
-import path from 'node:path';
-import {getRootDir} from '../../mops.js';
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { getRootDir } from "../../mops.js";
 
 type DfxConfig = {
-	$schema : string;
-	version : number;
-	profile : 'Debug' | 'Release';
-	canisters : {
-		[key : string] : {
-			type : 'motoko' | 'assets';
-			main ?: string;
-			specified_id ?: string;
-			declarations ?: {
-				output : string;
-				node_compatibility : boolean;
-			};
-			build ?: string[];
-			frontend ?: {
-				entrypoint : string;
-			};
-			source ?: string[];
-			remote ?: {
-				id : {
-					ic : string;
-					staging : string;
-				};
-			};
-		};
-	};
-	defaults : {
-		build : {
-			packtool : string;
-		};
-	};
-	dfx : string;
-	networks : {
-		[key : string] : {
-			type : string;
-			providers : string[];
-		};
-	};
+  $schema: string;
+  version: number;
+  profile: "Debug" | "Release";
+  canisters: {
+    [key: string]: {
+      type: "motoko" | "assets";
+      main?: string;
+      specified_id?: string;
+      declarations?: {
+        output: string;
+        node_compatibility: boolean;
+      };
+      build?: string[];
+      frontend?: {
+        entrypoint: string;
+      };
+      source?: string[];
+      remote?: {
+        id: {
+          ic: string;
+          staging: string;
+        };
+      };
+    };
+  };
+  defaults: {
+    build: {
+      packtool: string;
+    };
+  };
+  dfx: string;
+  networks: {
+    [key: string]: {
+      type: string;
+      providers: string[];
+    };
+  };
 };
 
-export function readDfxJson() : DfxConfig | Record<string, never> {
-	let dfxJsonPath = path.resolve(getRootDir(), 'dfx.json');
-	if (!existsSync(dfxJsonPath)) {
-		return {};
-	}
-	return JSON.parse(readFileSync(dfxJsonPath, 'utf8')) as DfxConfig;
+export function readDfxJson(): DfxConfig | Record<string, never> {
+  let dfxJsonPath = path.resolve(getRootDir(), "dfx.json");
+  if (!existsSync(dfxJsonPath)) {
+    return {};
+  }
+  return JSON.parse(readFileSync(dfxJsonPath, "utf8")) as DfxConfig;
 }
 
-export function getMotokoCanisters() : Record<string, string> {
-	let dfxJson = readDfxJson();
-	return Object.fromEntries(Object.entries(dfxJson.canisters || {})
-		.filter(([_, canister]) => canister.type === 'motoko')
-		.map(([name, canister]) => [name, canister.main ?? '']));
+export function getMotokoCanisters(): Record<string, string> {
+  let dfxJson = readDfxJson();
+  return Object.fromEntries(
+    Object.entries(dfxJson.canisters || {})
+      .filter(([_, canister]) => canister.type === "motoko")
+      .map(([name, canister]) => [name, canister.main ?? ""]),
+  );
 }
 
-export function getMotokoCanistersWithDeclarations() : Record<string, string> {
-	let dfxJson = readDfxJson();
-	return Object.fromEntries(Object.entries(dfxJson.canisters || {})
-		.filter(([_, canister]) => canister.type === 'motoko' && canister.declarations)
-		.map(([name, canister]) => [name, canister.main ?? '']));
-}
+export function getMotokoCanistersWithDeclarations(): Record<string, string> {
+  let dfxJson = readDfxJson();
+  return Object.fromEntries(
+    Object.entries(dfxJson.canisters || {})
+      .filter(
+        ([_, canister]) => canister.type === "motoko" && canister.declarations,
+      )
+      .map(([name, canister]) => [name, canister.main ?? ""]),
+  );
+}

package/commands/watch/tester.ts

@@ -1,81 +1,99 @@
-import chalk from 'chalk';
-import {readConfig} from '../../mops.js';
-import {ErrorChecker} from './error-checker.js';
-import {testWithReporter} from '../test/test.js';
-import {SilentReporter} from '../test/reporters/silent-reporter.js';
+import chalk from "chalk";
+import { readConfig } from "../../mops.js";
+import { ErrorChecker } from "./error-checker.js";
+import { testWithReporter } from "../test/test.js";
+import { SilentReporter } from "../test/reporters/silent-reporter.js";
 
 export class Tester {
-	verbose = false;
-	status : 'pending' | 'running' | 'syntax-error' | 'error' | 'success' = 'pending';
-	errorChecker : ErrorChecker;
-	reporter = new SilentReporter(false);
-	aborted = false;
-	controller = new AbortController();
-	currentRun : Promise<any> | undefined;
+  verbose = false;
+  status: "pending" | "running" | "syntax-error" | "error" | "success" =
+    "pending";
+  errorChecker: ErrorChecker;
+  reporter = new SilentReporter(false);
+  aborted = false;
+  controller = new AbortController();
+  currentRun: Promise<any> | undefined;
 
-	constructor({verbose, errorChecker} : {verbose : boolean, errorChecker : ErrorChecker}) {
-		this.verbose = verbose;
-		this.errorChecker = errorChecker;
-	}
+  constructor({
+    verbose,
+    errorChecker,
+  }: {
+    verbose: boolean;
+    errorChecker: ErrorChecker;
+  }) {
+    this.verbose = verbose;
+    this.errorChecker = errorChecker;
+  }
 
-	reset() {
-		this.status = 'pending';
-	}
+  reset() {
+    this.status = "pending";
+  }
 
-	async abortCurrent() {
-		this.aborted = true;
-		this.controller.abort();
-		await this.currentRun;
-		this.reset();
-		this.aborted = false;
-	}
+  async abortCurrent() {
+    this.aborted = true;
+    this.controller.abort();
+    await this.currentRun;
+    this.reset();
+    this.aborted = false;
+  }
 
-	async run(onProgress : () => void) {
-		await this.abortCurrent();
+  async run(onProgress: () => void) {
+    await this.abortCurrent();
 
-		if (this.errorChecker.status === 'error') {
-			this.status = 'syntax-error';
-			onProgress();
-			return;
-		}
+    if (this.errorChecker.status === "error") {
+      this.status = "syntax-error";
+      onProgress();
+      return;
+    }
 
-		this.status = 'running';
-		onProgress();
+    this.status = "running";
+    onProgress();
 
-		this.reporter = new SilentReporter(false, onProgress);
-		this.controller = new AbortController();
+    this.reporter = new SilentReporter(false, onProgress);
+    this.controller = new AbortController();
 
-		let config = readConfig();
+    let config = readConfig();
 
-		this.currentRun = testWithReporter(this.reporter, '', 'interpreter', config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx', true, this.controller.signal);
-		await this.currentRun;
+    this.currentRun = testWithReporter(
+      this.reporter,
+      "",
+      "interpreter",
+      config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx",
+      true,
+      this.controller.signal,
+    );
+    await this.currentRun;
 
-		if (!this.aborted) {
-			this.status = this.reporter.failed > 0 ? 'error' : 'success';
-		}
+    if (!this.aborted) {
+      this.status = this.reporter.failed > 0 ? "error" : "success";
+    }
 
-		onProgress();
-	}
+    onProgress();
+  }
 
-	getOutput() : string {
-		let get = (v : number) => v.toString();
-		let count = (this.status === 'running' ? get : chalk.bold[this.reporter.failed > 0 ? 'redBright' : 'green'])(this.reporter.failedFiles || this.reporter.passedFiles);
+  getOutput(): string {
+    let get = (v: number) => v.toString();
+    let count = (
+      this.status === "running"
+        ? get
+        : chalk.bold[this.reporter.failed > 0 ? "redBright" : "green"]
+    )(this.reporter.failedFiles || this.reporter.passedFiles);
 
-		if (this.status === 'pending') {
-			return `Tests: ${chalk.gray('(pending)')}`;
-		}
-		if (this.status === 'running') {
-			return `Tests: ${count}/${this.reporter.total} ${chalk.gray('(running)')}`;
-		}
-		if (this.status === 'syntax-error') {
-			return `Tests: ${chalk.gray('(errors)')}`;
-		}
+    if (this.status === "pending") {
+      return `Tests: ${chalk.gray("(pending)")}`;
+    }
+    if (this.status === "running") {
+      return `Tests: ${count}/${this.reporter.total} ${chalk.gray("(running)")}`;
+    }
+    if (this.status === "syntax-error") {
+      return `Tests: ${chalk.gray("(errors)")}`;
+    }
 
-		let output = '';
-		output += `Tests: ${count}`;
-		if (this.reporter.errorOutput) {
-			output += '\n' + this.reporter.errorOutput;
-		}
-		return output;
-	}
-}
+    let output = "";
+    output += `Tests: ${count}`;
+    if (this.reporter.errorOutput) {
+      output += "\n" + this.reporter.errorOutput;
+    }
+    return output;
+  }
+}

package/commands/watch/warning-checker.ts

@@ -1,138 +1,151 @@
-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 {ErrorChecker} from './error-checker.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 { ErrorChecker } from "./error-checker.js";
+import { parallel } from "../../parallel.js";
+import { globMoFiles } from "./globMoFiles.js";
 
 export class WarningChecker {
-	verbose = false;
-	canisters : Record<string, string> = {};
-	status : 'pending' | 'running' | 'syntax-error' | 'error' | 'success' = 'pending';
-	warnings : string[] = [];
-	errorChecker : ErrorChecker;
-	aborted = false;
-	controllers = new Map<string, AbortController>();
-	currentRun : Promise<any> | undefined;
-	totalFiles = 0;
-	processedFiles = 0;
-
-	constructor({verbose, canisters, errorChecker} : {verbose : boolean, canisters : Record<string, string>, errorChecker : ErrorChecker}) {
-		this.verbose = verbose;
-		this.canisters = canisters;
-		this.errorChecker = errorChecker;
-	}
-
-	reset() {
-		this.status = 'pending';
-		this.warnings = [];
-		this.totalFiles = 0;
-		this.processedFiles = 0;
-	}
-
-	async abortCurrent() {
-		this.aborted = true;
-		for (let controller of this.controllers.values()) {
-			controller.abort();
-		}
-		this.controllers.clear();
-		await this.currentRun;
-		this.reset();
-		this.aborted = false;
-	}
-
-	async run(onProgress : () => void) {
-		await this.abortCurrent();
-
-		if (this.errorChecker.status === 'error') {
-			this.status = 'syntax-error';
-			onProgress();
-			return;
-		}
-
-		this.status = 'running';
-		onProgress();
-
-		let rootDir = getRootDir();
-		let mocPath = getMocPath();
-		let deps = await sources({cwd: rootDir});
-		let paths = globMoFiles(rootDir);
-
-		this.totalFiles = paths.length;
-		this.processedFiles = 0;
-
-		this.currentRun = parallel(os.cpus().length, paths, async (file) => {
-			let controller = new AbortController();
-			let {signal} = controller;
-			this.controllers.set(file, controller);
-
-			let {stderr} = await promisify(execFile)(mocPath, ['--check', ...deps.flatMap(x => x.split(' ')), file], {cwd: rootDir, signal}).catch((error) => {
-				if (error.code === 'ABORT_ERR') {
-					return {stderr: ''};
-				}
-				throw error;
-			});
-
-			if (stderr) {
-				stderr.split('\n').forEach((line) => {
-					// ignore deps warnings
-					if (line.startsWith('.mops/')) {
-						return;
-					}
-					else if (line.includes(': warning [')) {
-						// better formatting
-						let str = line
-							.replace(': warning [', `: ${chalk.yellow('warning')} [`)
-							.replace(/unused field (\w+)/, `unused field ${chalk.bold('$1')}`)
-							.replace(/unused identifier (\w+)/, `unused identifier ${chalk.bold('$1')}`)
-							.trim();
-						this.warnings.push(str);
-					}
-					else if (line.startsWith('  ') && this.warnings.length) {
-						this.warnings[this.warnings.length - 1] += '\n  ' + line;
-					}
-					else {
-						// console.log('UNKNOWN WARNING', line);
-					}
-				});
-			}
-
-			this.controllers.delete(file);
-			this.processedFiles++;
-			onProgress();
-		});
-
-		await this.currentRun;
-
-		if (!this.aborted) {
-			this.status = this.warnings.length ? 'error' : 'success';
-		}
-
-		onProgress();
-	}
-
-	getOutput() : string {
-		if (this.status === 'pending') {
-			return `Warnings: ${chalk.gray('(pending)')}`;
-		}
-		if (this.status === 'running') {
-			return `Warnings: ${this.processedFiles}/${this.totalFiles} ${chalk.gray('(running)')}`;
-		}
-		if (this.status === 'syntax-error') {
-			return `Warnings: ${chalk.gray('(errors)')}`;
-		}
-
-		let output = '';
-		let uniqueWarnings = [...new Set(this.warnings)];
-		output += `Warnings: ${chalk.bold[uniqueWarnings.length ? 'yellowBright' : 'green'](uniqueWarnings.length)}`;
-		if (this.verbose && uniqueWarnings.length) {
-			output += `\n  ${uniqueWarnings.join('\n  ')}`;
-		}
-		return output;
-	}
-}
+  verbose = false;
+  canisters: Record<string, string> = {};
+  status: "pending" | "running" | "syntax-error" | "error" | "success" =
+    "pending";
+  warnings: string[] = [];
+  errorChecker: ErrorChecker;
+  aborted = false;
+  controllers = new Map<string, AbortController>();
+  currentRun: Promise<any> | undefined;
+  totalFiles = 0;
+  processedFiles = 0;
+
+  constructor({
+    verbose,
+    canisters,
+    errorChecker,
+  }: {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    errorChecker: ErrorChecker;
+  }) {
+    this.verbose = verbose;
+    this.canisters = canisters;
+    this.errorChecker = errorChecker;
+  }
+
+  reset() {
+    this.status = "pending";
+    this.warnings = [];
+    this.totalFiles = 0;
+    this.processedFiles = 0;
+  }
+
+  async abortCurrent() {
+    this.aborted = true;
+    for (let controller of this.controllers.values()) {
+      controller.abort();
+    }
+    this.controllers.clear();
+    await this.currentRun;
+    this.reset();
+    this.aborted = false;
+  }
+
+  async run(onProgress: () => void) {
+    await this.abortCurrent();
+
+    if (this.errorChecker.status === "error") {
+      this.status = "syntax-error";
+      onProgress();
+      return;
+    }
+
+    this.status = "running";
+    onProgress();
+
+    let rootDir = getRootDir();
+    let mocPath = getMocPath();
+    let deps = await sources({ cwd: rootDir });
+    let paths = globMoFiles(rootDir);
+
+    this.totalFiles = paths.length;
+    this.processedFiles = 0;
+
+    this.currentRun = parallel(os.cpus().length, paths, async (file) => {
+      let controller = new AbortController();
+      let { signal } = controller;
+      this.controllers.set(file, controller);
+
+      let { stderr } = await promisify(execFile)(
+        mocPath,
+        ["--check", ...deps.flatMap((x) => x.split(" ")), file],
+        { cwd: rootDir, signal },
+      ).catch((error) => {
+        if (error.code === "ABORT_ERR") {
+          return { stderr: "" };
+        }
+        throw error;
+      });
+
+      if (stderr) {
+        stderr.split("\n").forEach((line) => {
+          // ignore deps warnings
+          if (line.startsWith(".mops/")) {
+            return;
+          } else if (line.includes(": warning [")) {
+            // better formatting
+            let str = line
+              .replace(": warning [", `: ${chalk.yellow("warning")} [`)
+              .replace(/unused field (\w+)/, `unused field ${chalk.bold("$1")}`)
+              .replace(
+                /unused identifier (\w+)/,
+                `unused identifier ${chalk.bold("$1")}`,
+              )
+              .trim();
+            this.warnings.push(str);
+          } else if (line.startsWith("  ") && this.warnings.length) {
+            this.warnings[this.warnings.length - 1] += "\n  " + line;
+          } else {
+            // console.log('UNKNOWN WARNING', line);
+          }
+        });
+      }
+
+      this.controllers.delete(file);
+      this.processedFiles++;
+      onProgress();
+    });
+
+    await this.currentRun;
+
+    if (!this.aborted) {
+      this.status = this.warnings.length ? "error" : "success";
+    }
+
+    onProgress();
+  }
+
+  getOutput(): string {
+    if (this.status === "pending") {
+      return `Warnings: ${chalk.gray("(pending)")}`;
+    }
+    if (this.status === "running") {
+      return `Warnings: ${this.processedFiles}/${this.totalFiles} ${chalk.gray("(running)")}`;
+    }
+    if (this.status === "syntax-error") {
+      return `Warnings: ${chalk.gray("(errors)")}`;
+    }
+
+    let output = "";
+    let uniqueWarnings = [...new Set(this.warnings)];
+    output += `Warnings: ${chalk.bold[uniqueWarnings.length ? "yellowBright" : "green"](uniqueWarnings.length)}`;
+    if (this.verbose && uniqueWarnings.length) {
+      output += `\n  ${uniqueWarnings.join("\n  ")}`;
+    }
+    return output;
+  }
+}