ic-mops 2.1.0 → 2.2.1

package/dist/helpers/autofix-motoko.js

@@ -16,75 +16,120 @@ export function parseDiagnostics(stdout) {
     })
         .filter((d) => d !== null);
 }
-function extractFixes(diagnostics) {
-    const fixes = [];
+function extractDiagnosticFixes(diagnostics) {
+    const result = new Map();
     for (const diag of diagnostics) {
+        const editsByFile = new Map();
         for (const span of diag.spans) {
             if (span.suggestion_applicability === "MachineApplicable" &&
                 span.suggested_replacement !== null) {
-                fixes.push({
-                    file: span.file,
-                    code: diag.code,
-                    edit: {
-                        range: {
-                            start: {
-                                line: span.line_start - 1,
-                                character: span.column_start - 1,
-                            },
-                            end: {
-                                line: span.line_end - 1,
-                                character: span.column_end - 1,
-                            },
+                const file = resolve(span.file);
+                const edits = editsByFile.get(file) ?? [];
+                edits.push({
+                    range: {
+                        start: {
+                            line: span.line_start - 1,
+                            character: span.column_start - 1,
+                        },
+                        end: {
+                            line: span.line_end - 1,
+                            character: span.column_end - 1,
                         },
-                        newText: span.suggested_replacement,
                     },
+                    newText: span.suggested_replacement,
                 });
+                editsByFile.set(file, edits);
             }
         }
+        for (const [file, edits] of editsByFile) {
+            const existing = result.get(file) ?? [];
+            existing.push({ code: diag.code, edits });
+            result.set(file, existing);
+        }
     }
-    return fixes;
+    return result;
+}
+function normalizeRange(range) {
+    const { start, end } = range;
+    if (start.line > end.line ||
+        (start.line === end.line && start.character > end.character)) {
+        return { start: end, end: start };
+    }
+    return range;
+}
+/**
+ * Applies diagnostic fixes to a document, processing each diagnostic as
+ * an atomic unit. If any edit from a diagnostic overlaps with an already-accepted
+ * edit, the entire diagnostic is skipped (picked up in subsequent iterations).
+ * Based on vscode-languageserver-textdocument's TextDocument.applyEdits.
+ */
+function applyDiagnosticFixes(doc, fixes) {
+    const acceptedEdits = [];
+    const appliedCodes = [];
+    for (const fix of fixes) {
+        const offsets = fix.edits.map((e) => {
+            const range = normalizeRange(e.range);
+            return {
+                start: doc.offsetAt(range.start),
+                end: doc.offsetAt(range.end),
+                newText: e.newText,
+            };
+        });
+        const overlaps = offsets.some((o) => acceptedEdits.some((a) => o.start < a.end && o.end > a.start));
+        if (overlaps) {
+            continue;
+        }
+        acceptedEdits.push(...offsets);
+        appliedCodes.push(fix.code);
+    }
+    acceptedEdits.sort((a, b) => a.start - b.start);
+    const text = doc.getText();
+    const spans = [];
+    let lastOffset = 0;
+    for (const edit of acceptedEdits) {
+        if (edit.start < lastOffset) {
+            continue;
+        }
+        if (edit.start > lastOffset) {
+            spans.push(text.substring(lastOffset, edit.start));
+        }
+        if (edit.newText.length) {
+            spans.push(edit.newText);
+        }
+        lastOffset = edit.end;
+    }
+    spans.push(text.substring(lastOffset));
+    return { text: spans.join(""), appliedCodes };
 }
 const MAX_FIX_ITERATIONS = 10;
 export async function autofixMotoko(mocPath, files, mocArgs) {
     const fixedFilesCodes = new Map();
     for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
-        const allFixes = [];
+        const fixesByFile = new Map();
         for (const file of files) {
-            const result = await execa(mocPath, [file, "--error-format=json", ...mocArgs], { stdio: "pipe", reject: false });
+            const result = await execa(mocPath, [file, ...mocArgs, "--error-format=json"], { stdio: "pipe", reject: false });
             const diagnostics = parseDiagnostics(result.stdout);
-            allFixes.push(...extractFixes(diagnostics));
+            for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
+                const existing = fixesByFile.get(targetFile) ?? [];
+                existing.push(...fixes);
+                fixesByFile.set(targetFile, existing);
+            }
         }
-        if (allFixes.length === 0) {
+        if (fixesByFile.size === 0) {
             break;
         }
-        const fixesByFile = new Map();
-        for (const fix of allFixes) {
-            const normalizedPath = resolve(fix.file);
-            const existing = fixesByFile.get(normalizedPath) ?? [];
-            existing.push(fix);
-            fixesByFile.set(normalizedPath, existing);
-        }
         let progress = false;
         for (const [file, fixes] of fixesByFile) {
             const original = await readFile(file, "utf-8");
             const doc = TextDocument.create(`file://${file}`, "motoko", 0, original);
-            let result;
-            try {
-                result = TextDocument.applyEdits(doc, fixes.map((f) => f.edit));
-            }
-            catch (err) {
-                console.warn(`Warning: could not apply fixes to ${file}: ${err}`);
-                continue;
-            }
+            const { text: result, appliedCodes } = applyDiagnosticFixes(doc, fixes);
             if (result === original) {
                 continue;
             }
             await writeFile(file, result, "utf-8");
             progress = true;
             const existing = fixedFilesCodes.get(file) ?? [];
-            for (const fix of fixes) {
-                existing.push(fix.code);
-            }
+            existing.push(...appliedCodes);
             fixedFilesCodes.set(file, existing);
         }
         if (!progress) {

package/dist/mops.d.ts

@@ -23,6 +23,7 @@ export declare function getGithubCommit(repo: string, ref: string): Promise<any>
 export declare function getDependencyType(version: string): "local" | "mops" | "github";
 export declare function parseDepValue(name: string, value: string): Dependency;
 export declare function readConfig(configFile?: string): Config;
+export declare function getGlobalMocArgs(config: Config): string[];
 export declare function writeConfig(config: Config, configFile?: string): void;
 export declare function formatDir(name: string, version: string): string;
 export declare function formatGithubDir(name: string, repo: string): string;

package/dist/mops.js

@@ -4,16 +4,13 @@ import fs from "node:fs";
 import TOML from "@iarna/toml";
 import chalk from "chalk";
 import prompts from "prompts";
-import fetch from "node-fetch";
 import { decodeFile } from "./pem.js";
+import { cliError } from "./error.js";
 import { mainActor, storageActor } from "./api/actors.js";
 import { getNetwork } from "./api/network.js";
 import { getHighestVersion } from "./api/getHighestVersion.js";
 import { getPackageId } from "./helpers/get-package-id.js";
 import { FILE_PATH_REGEX } from "./constants.js";
-if (!globalThis.fetch) {
-    globalThis.fetch = fetch;
-}
 // (!) make changes in pair with backend
 export let apiVersion = "1.3";
 export let globalConfigDir = "";
@@ -177,6 +174,15 @@ export function readConfig(configFile = getClosestConfigFile()) {
     });
     return config;
 }
+export function getGlobalMocArgs(config) {
+    if (!config.moc?.args) {
+        return [];
+    }
+    if (typeof config.moc.args === "string") {
+        cliError(`[moc] config 'args' should be an array of strings in mops.toml config file`);
+    }
+    return config.moc.args;
+}
 export function writeConfig(config, configFile = getClosestConfigFile()) {
     let resConfig = JSON.parse(JSON.stringify(config));
     let deps = resConfig.dependencies || {};

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -48,29 +48,28 @@
     "filesize": "10.1.6",
     "fs-extra": "11.2.0",
     "get-folder-size": "5.0.0",
-    "glob": "11.0.1",
+    "glob": "13.0.6",
     "globby": "14.0.2",
     "got": "14.4.6",
-    "jsdom": "26.1.0",
+    "jsdom": "28.1.0",
     "log-update": "6.1.0",
     "markdown-table": "3.0.4",
     "mdast-util-from-markdown": "2.0.2",
     "mdast-util-to-markdown": "2.1.2",
     "minimatch": "10.0.1",
     "ncp": "2.0.0",
-    "node-fetch": "3.3.2",
     "octokit": "3.1.2",
     "pem-file": "1.0.1",
     "pic-ic": "0.5.4",
     "pic-js-mops": "0.14.8",
     "prettier": "3.5.3",
-    "prettier-plugin-motoko": "0.11.0",
+    "prettier-plugin-motoko": "0.12.5",
     "promisify-child-process": "4.1.2",
     "prompts": "2.4.2",
     "semver": "7.7.1",
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
-    "tar": "7.5.6",
+    "tar": "7.5.9",
     "terminal-size": "4.0.0",
     "vscode-languageserver-textdocument": "1.0.12"
   },
@@ -80,7 +79,7 @@
     "@types/decompress": "4.2.7",
     "@types/fs-extra": "11.0.4",
     "@types/glob": "8.1.0",
-    "@types/jsdom": "21.1.7",
+    "@types/jsdom": "28.0.0",
     "@types/ncp": "2.0.8",
     "@types/node": "24.0.3",
     "@types/prompts": "2.4.9",

package/dist/tests/check-fix.test.js

@@ -52,6 +52,9 @@ describe("check --fix", () => {
             M0237: 17,
         });
     });
+    test("overlapping edits", async () => {
+        await testCheckFix("overlapping.mo", { M0223: 1, M0236: 2 });
+    });
     test("transitive imports", async () => {
         const runMainPath = copyFixture("transitive-main.mo");
         const runLibPath = copyFixture("transitive-lib.mo");
@@ -62,6 +65,19 @@ describe("check --fix", () => {
         const afterResult = await cli(["check", runMainPath, "--", ...diagnosticFlags], { cwd: fixDir });
         expect(countCodes(afterResult.stdout)).toEqual({});
     });
+    test("--error-format=human does not break --fix", async () => {
+        const runFilePath = copyFixture("M0223.mo");
+        const fixResult = await cli([
+            "check",
+            runFilePath,
+            "--fix",
+            "--",
+            warningFlags,
+            "--error-format=human",
+        ], { cwd: fixDir });
+        expect(fixResult.stdout).toContain("1 fix applied");
+        expect(readFileSync(runFilePath, "utf-8")).not.toContain("<Nat>");
+    });
     test("verbose", async () => {
         const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
             cwd: fixDir,

package/dist/tests/check.test.js

@@ -30,4 +30,8 @@ describe("check", () => {
         expect(result.stderr).toMatch(/warning \[M0194\]/);
         expect(result.stderr).toMatch(/unused identifier/);
     });
+    test("[moc] args are passed to moc", async () => {
+        const cwd = path.join(import.meta.dirname, "check/moc-args");
+        await cliSnapshot(["check", "Warning.mo"], { cwd }, 1);
+    });
 });

package/dist/tests/moc-args.test.d.ts

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

package/dist/tests/moc-args.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cli } from "./helpers";
+describe("moc-args", () => {
+    test("prints moc args from [moc] config", async () => {
+        const cwd = path.join(import.meta.dirname, "check/moc-args");
+        const result = await cli(["moc-args"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBe("-Werror");
+    });
+    test("prints nothing when no [moc] config", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cli(["moc-args"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBe("");
+    });
+});

package/dist/tests/toolchain.test.js

@@ -8,4 +8,15 @@ describe("toolchain", () => {
         expect(result.exitCode).toBe(0);
         expect(result.stdout.trim()).toBe("./mock");
     });
+    test("file URI with subdirectory path", async () => {
+        const cwd = path.join(import.meta.dirname, "toolchain-local-subpath");
+        const result = await cli(["toolchain", "bin", "moc"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.trim()).toBe("./bin/moc");
+    });
+    test("file URI does not trigger download during install", async () => {
+        const cwd = path.join(import.meta.dirname, "toolchain-local-subpath");
+        const result = await cli(["install"], { cwd });
+        expect(result.stderr).not.toContain("Invalid Version");
+    });
 });

package/dist/types.d.ts

@@ -19,6 +19,9 @@ export type Config = {
     "dev-dependencies"?: Dependencies;
     toolchain?: Toolchain;
     requirements?: Requirements;
+    moc?: {
+        args?: string[];
+    };
     canisters?: Record<string, string | CanisterConfig>;
     build?: {
         outputDir?: string;

package/dist/wasm/pkg/bundler/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "wasm",
+  "type": "module",
+  "collaborators": [
+    "Ryan Vandersmith <ryan.vandersmith@dfinity.org>"
+  ],
+  "version": "0.1.0",
+  "files": [
+    "wasm_bg.wasm",
+    "wasm.js",
+    "wasm_bg.js",
+    "wasm.d.ts"
+  ],
+  "main": "wasm.js",
+  "types": "wasm.d.ts",
+  "sideEffects": [
+    "./wasm.js",
+    "./snippets/*"
+  ]
+}

package/dist/wasm/pkg/bundler/wasm.d.ts

@@ -0,0 +1,3 @@
+/* tslint:disable */
+/* eslint-disable */
+export function is_candid_compatible(new_interface: string, original_interface: string): boolean;

package/dist/wasm/pkg/bundler/wasm.js

@@ -0,0 +1,5 @@
+import * as wasm from "./wasm_bg.wasm";
+export * from "./wasm_bg.js";
+import { __wbg_set_wasm } from "./wasm_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/dist/wasm/pkg/bundler/wasm_bg.js

@@ -0,0 +1,93 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+/**
+ * @param {string} new_interface
+ * @param {string} original_interface
+ * @returns {boolean}
+ */
+export function is_candid_compatible(new_interface, original_interface) {
+    const ptr0 = passStringToWasm0(new_interface, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(original_interface, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.is_candid_compatible(ptr0, len0, ptr1, len1);
+    return ret !== 0;
+}
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+

package/dist/wasm/pkg/bundler/wasm_bg.wasm.d.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_start: () => void;

package/error.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 
-export function cliError(...args: unknown[]) {
+export function cliError(...args: unknown[]): never {
   console.error(chalk.red(...args));
   process.exit(1);
 }