ic-mops 1.11.1 → 2.0.0

package/commands/watch/error-checker.ts

@@ -1,93 +1,103 @@
-import {execFile} from 'node:child_process';
-import {promisify} from 'node:util';
-import os from 'node:os';
-import chalk from 'chalk';
+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 { 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 : Record<string, string> = {};
-	status : 'pending' | 'running' | 'error' | 'success' = 'pending';
-	errors : string[] = [];
-	totalFiles = 0;
-	processedFiles = 0;
+  verbose = false;
+  canisters: Record<string, string> = {};
+  status: "pending" | "running" | "error" | "success" = "pending";
+  errors: string[] = [];
+  totalFiles = 0;
+  processedFiles = 0;
 
-	constructor({verbose, canisters} : {verbose : boolean, canisters : Record<string, string>}) {
-		this.verbose = verbose;
-		this.canisters = canisters;
-	}
+  constructor({
+    verbose,
+    canisters,
+  }: {
+    verbose: boolean;
+    canisters: Record<string, string>;
+  }) {
+    this.verbose = verbose;
+    this.canisters = canisters;
+  }
 
-	reset() {
-		this.status = 'pending';
-		this.errors = [];
-		this.totalFiles = 0;
-		this.processedFiles = 0;
-	}
+  reset() {
+    this.status = "pending";
+    this.errors = [];
+    this.totalFiles = 0;
+    this.processedFiles = 0;
+  }
 
-	async run(onProgress : () => void) {
-		this.reset();
+  async run(onProgress: () => void) {
+    this.reset();
 
-		this.status = 'running';
-		onProgress();
+    this.status = "running";
+    onProgress();
 
-		let rootDir = getRootDir();
-		let mocPath = getMocPath();
-		let deps = await sources({cwd: rootDir});
+    let rootDir = getRootDir();
+    let mocPath = getMocPath();
+    let deps = await sources({ cwd: rootDir });
 
-		let paths = globMoFiles(rootDir);
+    let paths = globMoFiles(rootDir);
 
-		this.totalFiles = paths.length;
-		this.processedFiles = 0;
+    this.totalFiles = paths.length;
+    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});
-			}
-			catch (error : any) {
-				error.message.split('\n').forEach((line : string) => {
-					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')}`)
-							.trim();
-						this.errors.push(str);
-					}
-					else if (line.startsWith('  ') && this.errors.length) {
-						this.errors[this.errors.length - 1] += '\n  ' + line;
-					}
-					else {
-						// console.log('UNKNOWN ERROR', line);
-					}
-				});
-			}
-			this.processedFiles++;
-			onProgress();
-		});
+    await parallel(os.cpus().length, paths, async (file) => {
+      try {
+        await promisify(execFile)(
+          mocPath,
+          ["--check", ...deps.flatMap((x) => x.split(" ")), file],
+          { cwd: rootDir },
+        );
+      } catch (error: any) {
+        error.message.split("\n").forEach((line: string) => {
+          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")}`,
+              )
+              .trim();
+            this.errors.push(str);
+          } else if (line.startsWith("  ") && this.errors.length) {
+            this.errors[this.errors.length - 1] += "\n  " + line;
+          } else {
+            // console.log('UNKNOWN ERROR', line);
+          }
+        });
+      }
+      this.processedFiles++;
+      onProgress();
+    });
 
-		this.status = this.errors.length ? 'error' : 'success';
-		onProgress();
-	}
+    this.status = this.errors.length ? "error" : "success";
+    onProgress();
+  }
 
-	getOutput() : string {
-		if (this.status === 'pending') {
-			return `Errors: ${chalk.gray('(pending)')}`;
-		}
-		if (this.status === 'running') {
-			return `Errors: ${this.processedFiles}/${this.totalFiles} ${chalk.gray('(running)')}`;
-		}
-		let output = '';
-		let uniqueErrors = [...new Set(this.errors)];
-		output += `Errors: ${chalk.bold[uniqueErrors.length ? 'redBright' : 'green'](uniqueErrors.length)}`;
-		if (this.verbose && this.errors.length) {
-			output += `\n  ${uniqueErrors.join('\n  ')}`;
-		}
-		return output;
-	}
-}
+  getOutput(): string {
+    if (this.status === "pending") {
+      return `Errors: ${chalk.gray("(pending)")}`;
+    }
+    if (this.status === "running") {
+      return `Errors: ${this.processedFiles}/${this.totalFiles} ${chalk.gray("(running)")}`;
+    }
+    let output = "";
+    let uniqueErrors = [...new Set(this.errors)];
+    output += `Errors: ${chalk.bold[uniqueErrors.length ? "redBright" : "green"](uniqueErrors.length)}`;
+    if (this.verbose && this.errors.length) {
+      output += `\n  ${uniqueErrors.join("\n  ")}`;
+    }
+    return output;
+  }
+}

package/commands/watch/formatter.ts

@@ -1,74 +1,86 @@
-import chalk from 'chalk';
-import {format, FormatResult} from '../format.js';
-import {ErrorChecker} from './error-checker.js';
+import chalk from "chalk";
+import { format, FormatResult } from "../format.js";
+import { ErrorChecker } from "./error-checker.js";
 
 export class Formatter {
-	verbose = false;
-	status : 'pending' | 'running' | 'syntax-error' | 'error' | 'success' = 'pending';
-	errorChecker : ErrorChecker;
-	aborted = false;
-	controller = new AbortController();
-	currentRun : Promise<any> | undefined;
-	result : FormatResult | undefined;
+  verbose = false;
+  status: "pending" | "running" | "syntax-error" | "error" | "success" =
+    "pending";
+  errorChecker: ErrorChecker;
+  aborted = false;
+  controller = new AbortController();
+  currentRun: Promise<any> | undefined;
+  result: FormatResult | 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';
-		this.result = undefined;
-	}
+  reset() {
+    this.status = "pending";
+    this.result = undefined;
+  }
 
-	async abortCurrent() {
-		this.aborted = true;
-		await this.currentRun;
-		this.reset();
-		this.aborted = false;
-	}
+  async abortCurrent() {
+    this.aborted = true;
+    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.controller = new AbortController();
+    this.controller = new AbortController();
 
-		this.currentRun = format('', {silent: true}, this.controller.signal, (result) => {
-			this.result = result;
-			onProgress();
-		});
-		await this.currentRun;
+    this.currentRun = format(
+      "",
+      { silent: true },
+      this.controller.signal,
+      (result) => {
+        this.result = result;
+        onProgress();
+      },
+    );
+    await this.currentRun;
 
-		if (!this.aborted) {
-			this.status = 'success';
-		}
-		onProgress();
-	}
+    if (!this.aborted) {
+      this.status = "success";
+    }
+    onProgress();
+  }
 
-	getOutput() : string {
-		if (this.status === 'pending') {
-			return `Format: ${chalk.gray('(pending)')}`;
-		}
-		if (this.status === 'syntax-error') {
-			return `Format: ${chalk.gray('(errors)')}`;
-		}
+  getOutput(): string {
+    if (this.status === "pending") {
+      return `Format: ${chalk.gray("(pending)")}`;
+    }
+    if (this.status === "syntax-error") {
+      return `Format: ${chalk.gray("(errors)")}`;
+    }
 
-		if (!this.result) {
-			return `Format: ${chalk.gray('(pending)')}`;
-		}
+    if (!this.result) {
+      return `Format: ${chalk.gray("(pending)")}`;
+    }
 
-		if (this.status === 'running') {
-			return `Format: ${this.result.checked}/${this.result.total} ${chalk.gray('(running)')}`;
-		}
-		return `Format: ${chalk.greenBright(`${this.result.formatted}`)}`;
-	}
-}
+    if (this.status === "running") {
+      return `Format: ${this.result.checked}/${this.result.total} ${chalk.gray("(running)")}`;
+    }
+    return `Format: ${chalk.greenBright(`${this.result.formatted}`)}`;
+  }
+}

package/commands/watch/generator.ts

@@ -1,99 +1,119 @@
-import os from 'node:os';
-import {promisify} from 'node:util';
-import {execFile} from 'node:child_process';
-import chalk from 'chalk';
+import os from "node:os";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+import chalk from "chalk";
 
-import {ErrorChecker} from './error-checker.js';
-import {parallel} from '../../parallel.js';
-import {getRootDir} from '../../mops.js';
+import { ErrorChecker } from "./error-checker.js";
+import { parallel } from "../../parallel.js";
+import { getRootDir } from "../../mops.js";
 
 export class Generator {
-	verbose = false;
-	canisters : Record<string, string> = {};
-	status : 'pending' | 'running' | 'syntax-error' | 'error' | 'success' = 'pending';
-	errorChecker : ErrorChecker;
-	success = 0;
-	errors : string[] = [];
-	aborted = false;
-	controllers = new Map<string, AbortController>();
-	currentRun : Promise<any> | undefined;
-
-	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.success = 0;
-		this.errors = [];
-	}
-
-	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();
-
-		this.currentRun = parallel(os.cpus().length, [...Object.keys(this.canisters)], async (canister) => {
-			let controller = new AbortController();
-			let {signal} = controller;
-			this.controllers.set(canister, controller);
-
-			await promisify(execFile)('dfx', ['generate', canister], {cwd: rootDir, signal}).catch((error) => {
-				if (error.code === 'ABORT_ERR') {
-					return {stderr: ''};
-				}
-				throw error;
-			});
-
-			this.success += 1;
-			this.controllers.delete(canister);
-			onProgress();
-		});
-
-		await this.currentRun;
-
-		if (!this.aborted) {
-			this.status = 'success';
-		}
-		onProgress();
-	}
-
-	getOutput() : string {
-		let get = (v : number) => 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 `Generate: ${chalk.gray('(pending)')}`;
-		}
-		if (this.status === 'running') {
-			return `Generate: ${count}/${Object.keys(this.canisters).length} ${chalk.gray('(running)')}`;
-		}
-		if (this.status === 'syntax-error') {
-			return `Generate: ${chalk.gray('(errors)')}`;
-		}
-
-		return `Generate: ${count}`;
-	}
-}
+  verbose = false;
+  canisters: Record<string, string> = {};
+  status: "pending" | "running" | "syntax-error" | "error" | "success" =
+    "pending";
+  errorChecker: ErrorChecker;
+  success = 0;
+  errors: string[] = [];
+  aborted = false;
+  controllers = new Map<string, AbortController>();
+  currentRun: Promise<any> | undefined;
+
+  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.success = 0;
+    this.errors = [];
+  }
+
+  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();
+
+    this.currentRun = parallel(
+      os.cpus().length,
+      [...Object.keys(this.canisters)],
+      async (canister) => {
+        let controller = new AbortController();
+        let { signal } = controller;
+        this.controllers.set(canister, controller);
+
+        await promisify(execFile)("dfx", ["generate", canister], {
+          cwd: rootDir,
+          signal,
+        }).catch((error) => {
+          if (error.code === "ABORT_ERR") {
+            return { stderr: "" };
+          }
+          throw error;
+        });
+
+        this.success += 1;
+        this.controllers.delete(canister);
+        onProgress();
+      },
+    );
+
+    await this.currentRun;
+
+    if (!this.aborted) {
+      this.status = "success";
+    }
+    onProgress();
+  }
+
+  getOutput(): string {
+    let get = (v: number) => 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 `Generate: ${chalk.gray("(pending)")}`;
+    }
+    if (this.status === "running") {
+      return `Generate: ${count}/${Object.keys(this.canisters).length} ${chalk.gray("(running)")}`;
+    }
+    if (this.status === "syntax-error") {
+      return `Generate: ${chalk.gray("(errors)")}`;
+    }
+
+    return `Generate: ${count}`;
+  }
+}

package/commands/watch/globMoFiles.ts

@@ -1,17 +1,17 @@
-import {globSync} from 'glob';
+import { globSync } from "glob";
 
 let globConfig = {
-	nocase: true,
-	ignore: [
-		'**/node_modules/**',
-		'**/.mops/**',
-		'**/.vessel/**',
-		'**/.git/**',
-		'**/.dfx/**',
-		'**/{build,bundle,dist}/**',
-	],
+  nocase: true,
+  ignore: [
+    "**/node_modules/**",
+    "**/.mops/**",
+    "**/.vessel/**",
+    "**/.git/**",
+    "**/.dfx/**",
+    "**/{build,bundle,dist}/**",
+  ],
 };
 
-export function globMoFiles(rootDir : string) {
-	return globSync('**/*.mo', {cwd: rootDir, ...globConfig});
-}
+export function globMoFiles(rootDir: string) {
+  return globSync("**/*.mo", { cwd: rootDir, ...globConfig });
+}