ic-mops 1.12.0 → 2.0.0

package/dist/helpers/get-dfx-version.js

@@ -1,9 +1,9 @@
-import { execSync } from 'node:child_process';
+import { execSync } from "node:child_process";
 export function getDfxVersion() {
     try {
-        let res = execSync('dfx --version').toString();
-        return res.trim().split('dfx ')[1] || '';
+        let res = execSync("dfx --version").toString();
+        return res.trim().split("dfx ")[1] || "";
     }
     catch { }
-    return '';
+    return "";
 }

package/dist/helpers/get-moc-path.js

@@ -1,25 +1,26 @@
-import process from 'node:process';
-import { execFileSync } from 'node:child_process';
+import process from "node:process";
+import { execFileSync } from "node:child_process";
 export function getMocPath(throwIfNotFound = false) {
     let mocPath = process.env.DFX_MOC_PATH;
     if (!mocPath) {
         try {
-            mocPath = execFileSync('dfx', ['cache', 'show']).toString().trim() + '/moc';
+            mocPath =
+                execFileSync("dfx", ["cache", "show"]).toString().trim() + "/moc";
         }
         catch (e) {
-            mocPath = '';
+            mocPath = "";
         }
     }
     if (!mocPath) {
-        mocPath = 'moc';
+        mocPath = "moc";
     }
     if (throwIfNotFound) {
         try {
-            execFileSync(mocPath, ['--version']);
+            execFileSync(mocPath, ["--version"]);
         }
         catch (e) {
             console.error(e);
-            throw new Error('moc not found');
+            throw new Error("moc not found");
         }
     }
     return mocPath;

package/dist/helpers/get-moc-version.js

@@ -1,19 +1,22 @@
-import { execFileSync } from 'node:child_process';
-import { getMocPath } from './get-moc-path.js';
+import { execFileSync } from "node:child_process";
+import { getMocPath } from "./get-moc-path.js";
 export function getMocVersion(throwOnError = false) {
     let mocPath = getMocPath(false);
     if (!mocPath) {
-        return '';
+        return "";
     }
     try {
-        let match = execFileSync(mocPath, ['--version']).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
-        return match?.[1] || '';
+        let match = execFileSync(mocPath, ["--version"])
+            .toString()
+            .trim()
+            .match(/Motoko compiler ([^\s]+) .*/);
+        return match?.[1] || "";
     }
     catch (e) {
         if (throwOnError) {
             console.error(e);
-            throw new Error('moc not found');
+            throw new Error("moc not found");
         }
-        return '';
+        return "";
     }
 }

package/dist/helpers/get-package-id.js

@@ -1,4 +1,4 @@
-import { getDepName } from './get-dep-name.js';
+import { getDepName } from "./get-dep-name.js";
 export function getPackageId(name, version) {
-    return getDepName(name) + '@' + version;
+    return getDepName(name) + "@" + version;
 }

package/dist/helpers/is-candid-compatible.d.ts

@@ -0,0 +1 @@
+export declare function isCandidCompatible(newPath: string, originalPath: string): Promise<boolean>;

package/dist/helpers/is-candid-compatible.js

@@ -0,0 +1,20 @@
+import { readFile, access } from "node:fs/promises";
+import path from "node:path";
+import { getWasmBindings } from "../wasm.js";
+export async function isCandidCompatible(newPath, originalPath) {
+    try {
+        await access(newPath);
+    }
+    catch {
+        throw new Error(`Candid file not found: ${newPath}`);
+    }
+    try {
+        await access(originalPath);
+    }
+    catch {
+        throw new Error(`Candid file not found: ${originalPath}`);
+    }
+    const newText = await readFile(path.resolve(newPath), "utf8");
+    const originalText = await readFile(path.resolve(originalPath), "utf8");
+    return getWasmBindings().is_candid_compatible(newText, originalText);
+}

package/dist/integrity.d.ts

@@ -15,7 +15,7 @@ type LockFileV3 = {
     deps: Record<string, string>;
 };
 type LockFile = LockFileV1 | LockFileV2 | LockFileV3;
-export declare function checkIntegrity(lock?: 'check' | 'update' | 'ignore'): Promise<void>;
+export declare function checkIntegrity(lock?: "check" | "update" | "ignore"): Promise<void>;
 export declare function getLocalFileHash(fileId: string): string;
 export declare function checkRemote(): Promise<void>;
 export declare function readLockFile(): LockFile | null;

package/dist/integrity.js

@@ -1,25 +1,27 @@
-import process from 'node:process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex } from '@noble/hashes/utils';
-import { getDependencyType, getRootDir, readConfig } from './mops.js';
-import { mainActor } from './api/actors.js';
-import { resolvePackages } from './resolve-packages.js';
-import { getPackageId } from './helpers/get-package-id.js';
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex } from "@noble/hashes/utils";
+import { getDependencyType, getRootDir, readConfig } from "./mops.js";
+import { mainActor } from "./api/actors.js";
+import { resolvePackages } from "./resolve-packages.js";
+import { getPackageId } from "./helpers/get-package-id.js";
 export async function checkIntegrity(lock) {
     let force = !!lock;
-    if (!lock && !process.env['CI'] && fs.existsSync(path.join(getRootDir(), 'mops.lock'))) {
-        lock = 'update';
+    if (!lock &&
+        !process.env["CI"] &&
+        fs.existsSync(path.join(getRootDir(), "mops.lock"))) {
+        lock = "update";
     }
     if (!lock) {
-        lock = process.env['CI'] ? 'check' : 'ignore';
+        lock = process.env["CI"] ? "check" : "ignore";
     }
-    if (lock === 'update') {
+    if (lock === "update") {
         await updateLockFile();
         await checkLockFile(force);
     }
-    else if (lock === 'check') {
+    else if (lock === "check") {
         await checkLockFile(force);
     }
 }
@@ -32,14 +34,14 @@ async function getFileHashesFromRegistry() {
 async function getResolvedMopsPackageIds() {
     let resolvedPackages = await resolvePackages();
     let packageIds = Object.entries(resolvedPackages)
-        .filter(([_, version]) => getDependencyType(version) === 'mops')
+        .filter(([_, version]) => getDependencyType(version) === "mops")
         .map(([name, version]) => getPackageId(name, version));
     return packageIds;
 }
 // get hash of local file from '.mops' dir by fileId
 export function getLocalFileHash(fileId) {
     let rootDir = getRootDir();
-    let file = path.join(rootDir, '.mops', fileId);
+    let file = path.join(rootDir, ".mops", fileId);
     if (!fs.existsSync(file)) {
         console.error(`Missing file ${fileId} in .mops dir`);
         process.exit(1);
@@ -48,16 +50,22 @@ export function getLocalFileHash(fileId) {
     return bytesToHex(sha256(fileData));
 }
 function getMopsTomlHash() {
-    return bytesToHex(sha256(fs.readFileSync(getRootDir() + '/mops.toml')));
+    return bytesToHex(sha256(fs.readFileSync(getRootDir() + "/mops.toml")));
 }
 function getMopsTomlDepsHash() {
     let config = readConfig();
     let deps = config.dependencies || {};
-    let devDeps = config['dev-dependencies'] || {};
+    let devDeps = config["dev-dependencies"] || {};
     let allDeps = { ...deps, ...devDeps };
     // sort allDeps by key
-    let sortedDeps = Object.keys(allDeps).sort().reduce((acc, key) => {
-        acc[key] = allDeps[key]?.version || allDeps[key]?.repo || allDeps[key]?.path || '';
+    let sortedDeps = Object.keys(allDeps)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] =
+            allDeps[key]?.version ||
+                allDeps[key]?.repo ||
+                allDeps[key]?.path ||
+                "";
         return acc;
     }, {});
     return bytesToHex(sha256(JSON.stringify(sortedDeps)));
@@ -71,7 +79,7 @@ export async function checkRemote() {
             let remoteHash = new Uint8Array(hash);
             let localHash = getLocalFileHash(fileId);
             if (localHash !== bytesToHex(remoteHash)) {
-                console.error('Integrity check failed.');
+                console.error("Integrity check failed.");
                 console.error(`Mismatched hash for ${fileId}: ${localHash} vs ${bytesToHex(remoteHash)}`);
                 process.exit(1);
             }
@@ -80,7 +88,7 @@ export async function checkRemote() {
 }
 export function readLockFile() {
     let rootDir = getRootDir();
-    let lockFile = path.join(rootDir, 'mops.lock');
+    let lockFile = path.join(rootDir, "mops.lock");
     if (fs.existsSync(lockFile)) {
         return JSON.parse(fs.readFileSync(lockFile).toString());
     }
@@ -91,7 +99,8 @@ export function checkLockFileLight() {
     let existingLockFileJson = readLockFile();
     if (existingLockFileJson) {
         let mopsTomlDepsHash = getMopsTomlDepsHash();
-        if (existingLockFileJson.version === 3 && mopsTomlDepsHash === existingLockFileJson.mopsTomlDepsHash) {
+        if (existingLockFileJson.version === 3 &&
+            mopsTomlDepsHash === existingLockFileJson.mopsTomlDepsHash) {
             return true;
         }
     }
@@ -117,18 +126,18 @@ export async function updateLockFile() {
         }, {}),
     };
     let rootDir = getRootDir();
-    let lockFile = path.join(rootDir, 'mops.lock');
+    let lockFile = path.join(rootDir, "mops.lock");
     fs.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
 }
 // compare hashes of local files with hashes from the lock file
 export async function checkLockFile(force = false) {
     let supportedVersions = [1, 2, 3];
     let rootDir = getRootDir();
-    let lockFile = path.join(rootDir, 'mops.lock');
+    let lockFile = path.join(rootDir, "mops.lock");
     // check if lock file exists
     if (!fs.existsSync(lockFile)) {
         if (force) {
-            console.error('Missing lock file. Run `mops install` to generate it.');
+            console.error("Missing lock file. Run `mops install` to generate it.");
             process.exit(1);
         }
         return;
@@ -137,16 +146,16 @@ export async function checkLockFile(force = false) {
     let packageIds = await getResolvedMopsPackageIds();
     // check lock file version
     if (!supportedVersions.includes(lockFileJsonGeneric.version)) {
-        console.error('Integrity check failed');
-        console.error(`Invalid lock file version: ${lockFileJsonGeneric.version}. Supported versions: ${supportedVersions.join(', ')}`);
+        console.error("Integrity check failed");
+        console.error(`Invalid lock file version: ${lockFileJsonGeneric.version}. Supported versions: ${supportedVersions.join(", ")}`);
         process.exit(1);
     }
     let lockFileJson = lockFileJsonGeneric;
     // V1: check mops.toml hash
     if (lockFileJson.version === 1) {
         if (lockFileJson.mopsTomlHash !== getMopsTomlHash()) {
-            console.error('Integrity check failed');
-            console.error('Mismatched mops.toml hash');
+            console.error("Integrity check failed");
+            console.error("Mismatched mops.toml hash");
             console.error(`Locked hash: ${lockFileJson.mopsTomlHash}`);
             console.error(`Actual hash: ${getMopsTomlHash()}`);
             process.exit(1);
@@ -155,8 +164,8 @@ export async function checkLockFile(force = false) {
     // V2, V3: check mops.toml deps hash
     if (lockFileJson.version === 2 || lockFileJson.version === 3) {
         if (lockFileJson.mopsTomlDepsHash !== getMopsTomlDepsHash()) {
-            console.error('Integrity check failed');
-            console.error('Mismatched mops.toml dependencies hash');
+            console.error("Integrity check failed");
+            console.error("Mismatched mops.toml dependencies hash");
             console.error(`Locked hash: ${lockFileJson.mopsTomlDepsHash}`);
             console.error(`Actual hash: ${getMopsTomlDepsHash()}`);
             process.exit(1);
@@ -168,7 +177,7 @@ export async function checkLockFile(force = false) {
         let resolvedDeps = await resolvePackages();
         for (let name of Object.keys(resolvedDeps)) {
             if (lockedDeps[name] !== resolvedDeps[name]) {
-                console.error('Integrity check failed');
+                console.error("Integrity check failed");
                 console.error(`Mismatched package ${name}`);
                 console.error(`Locked: ${lockedDeps[name]}`);
                 console.error(`Actual: ${resolvedDeps[name]}`);
@@ -178,14 +187,14 @@ export async function checkLockFile(force = false) {
     }
     // check number of packages
     if (Object.keys(lockFileJson.hashes).length !== packageIds.length) {
-        console.error('Integrity check failed');
+        console.error("Integrity check failed");
         console.error(`Mismatched number of resolved packages: ${JSON.stringify(Object.keys(lockFileJson.hashes).length)} vs ${JSON.stringify(packageIds.length)}`);
         process.exit(1);
     }
     // check if resolved packages are in the lock file
     for (let packageId of packageIds) {
         if (!(packageId in lockFileJson.hashes)) {
-            console.error('Integrity check failed');
+            console.error("Integrity check failed");
             console.error(`Missing package ${packageId} in lock file`);
             process.exit(1);
         }
@@ -193,21 +202,21 @@ export async function checkLockFile(force = false) {
     for (let [packageId, hashes] of Object.entries(lockFileJson.hashes)) {
         // check if package is in resolved packages
         if (!packageIds.includes(packageId)) {
-            console.error('Integrity check failed');
+            console.error("Integrity check failed");
             console.error(`Package ${packageId} in lock file but not in resolved packages`);
             process.exit(1);
         }
         for (let [fileId, lockedHash] of Object.entries(hashes)) {
             // check if file belongs to package
             if (!fileId.startsWith(packageId)) {
-                console.error('Integrity check failed');
+                console.error("Integrity check failed");
                 console.error(`File ${fileId} in lock file does not belong to package ${packageId}`);
                 process.exit(1);
             }
             // local file hash vs hash from lock file
             let localHash = getLocalFileHash(fileId);
             if (lockedHash !== localHash) {
-                console.error('Integrity check failed');
+                console.error("Integrity check failed");
                 console.error(`Mismatched hash for ${fileId}`);
                 console.error(`Locked hash: ${lockedHash}`);
                 console.error(`Actual hash: ${localHash}`);

package/dist/jest.config.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    preset: string;
+    testPathIgnorePatterns: string[];
+    transform: {
+        "^.+\\.tsx?$": [string, {
+            useESM: boolean;
+        }];
+    };
+    testTimeout: number;
+};
+export default _default;

package/dist/jest.config.js

@@ -0,0 +1,14 @@
+/** @type {import("jest").Config} **/
+export default {
+    preset: "ts-jest/presets/default-esm",
+    testPathIgnorePatterns: [
+        "<rootDir>/node_modules/",
+        "<rootDir>/dist/",
+        "<rootDir>/bundle/",
+        "<rootDir>/commands/"
+    ],
+    transform: {
+        "^.+\\.tsx?$": ["ts-jest", { useESM: true }],
+    },
+    testTimeout: 60000,
+};

package/dist/mops.d.ts

@@ -1,8 +1,8 @@
-import { Identity } from '@icp-sdk/core/agent';
-import { Config, Dependency } from './types.js';
-import { mainActor, storageActor } from './api/actors.js';
-import { getNetwork } from './api/network.js';
-import { getHighestVersion } from './api/getHighestVersion.js';
+import { Identity } from "@icp-sdk/core/agent";
+import { Config, Dependency } from "./types.js";
+import { mainActor, storageActor } from "./api/actors.js";
+import { getNetwork } from "./api/network.js";
+import { getHighestVersion } from "./api/getHighestVersion.js";
 export declare let apiVersion: string;
 export declare let globalConfigDir: string;
 export declare let globalCacheDir: string;
@@ -29,4 +29,4 @@ export declare function formatGithubDir(name: string, repo: string): string;
 export declare function readDfxJson(): any;
 export declare function checkApiCompatibility(): Promise<boolean>;
 export declare function version(): any;
-export { getNetwork, mainActor, storageActor, getHighestVersion, };
+export { getNetwork, mainActor, storageActor, getHighestVersion };