motoko 1.0.1 → 2.0.4

package/lib/index.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const { file } = require('./file');
+const { /* findPackage, */ loadPackages } = require('./package');
+
+module.exports = (compiler, version) => {
+    const debug = require('debug')(version ? `motoko:${version}` : 'motoko');
+
+    const invoke = (key, unwrap, args) => {
+        if (!compiler) {
+            throw new Error(
+                'Please load a Motoko compiler before running this function',
+            );
+        }
+        if (typeof compiler[key] !== 'function') {
+            throw new Error(`Unknown compiler function: '${key}'`);
+        }
+        let result;
+        try {
+            result = compiler[key](...args);
+        } catch (err) {
+            if (err instanceof Error) {
+                throw err;
+            }
+            throw new Error(
+                `Unable to execute ${key}(${[...args]
+                    .map((x) => typeof x)
+                    .join(', ')}):\n${JSON.stringify(err)}`,
+            );
+        }
+        if (!unwrap) {
+            return result;
+        }
+        if (!result.code) {
+            throw new Error(
+                result.diagnostics
+                    ? result.diagnostics
+                          .map(({ message }) => message)
+                          .join('; ')
+                    : '(no diagnostics)',
+            );
+        }
+        return result.code;
+    };
+
+    const mo = {
+        version,
+        compiler,
+        file(path) {
+            return file(mo, path);
+        },
+        // findPackage,
+        async loadPackages(packages) {
+            return loadPackages(mo, packages);
+        },
+        read(path) {
+            return invoke('readFile', false, [path]);
+        },
+        write(path, content = '') {
+            if (typeof content !== 'string') {
+                throw new Error('Non-string file content');
+            }
+            debug('+file', path);
+            invoke('saveFile', false, [path, content]);
+        },
+        rename(path, newPath) {
+            invoke('renameFile', false, [path, newPath]);
+        },
+        delete(path) {
+            debug('-file', path);
+            invoke('removeFile', false, [path]);
+        },
+        list(directory) {
+            return invoke('readDir', false, [directory]);
+        },
+        addPackage(name, directory) {
+            debug('+package', name, directory);
+            invoke('addPackage', false, [name, directory]);
+        },
+        clearPackages() {
+            debug('-packages');
+            invoke('clearPackage', false, []);
+        },
+        setAliases(aliases) {
+            debug('aliases', aliases);
+            invoke('setActorAliases', false, [Object.entries(aliases)]);
+        },
+        setMetadata(values) {
+            invoke('setPublicMetadata', false, [values]);
+        },
+        check(path) {
+            const result = invoke('check', false, [path]);
+            return result.diagnostics;
+        },
+        run(path, libPaths) {
+            return invoke('run', false, [libPaths || [], path]);
+        },
+        candid(path) {
+            return invoke('candid', true, [path]);
+        },
+        wasm(path, mode) {
+            if (!mode) {
+                mode = 'ic';
+            } else if (mode !== 'ic' && mode !== 'wasi') {
+                throw new Error(`Invalid WASM format: ${mode}`);
+            }
+            return invoke('compileWasm', true, [mode, path]);
+        },
+        parseMotoko(content) {
+            const ast = invoke('parseMotoko', true, [content]);
+            return ast;
+        },
+        parseCandid(content) {
+            const ast = invoke('parseCandid', true, [content]);
+            return ast;
+        },
+    };
+    return mo;
+};
+exports.default = exports;

package/lib/package.js

@@ -0,0 +1,163 @@
+'use strict';
+// Derived from: https://github.com/dfinity/motoko-playground/blob/main/src/workers/file.ts
+
+const parse = require('isomorphic-parse-github-url');
+const fetch = require('cross-fetch');
+
+async function fetchPackage(mo, info) {
+    if (
+        !info.repo.startsWith('https://github.com/') ||
+        !info.repo.endsWith('.git')
+    ) {
+        return false;
+    }
+    const repo = {
+        repo: info.repo.slice(0, -4).replace(/^(https:\/\/github.com\/)/, ''),
+        branch: info.version,
+        dir: info.dir || 'src',
+    };
+    const result = await fetchGithub(mo, repo, info.name);
+    if (result) {
+        mo.addPackage(info.name, info.name + '/');
+    }
+    return result ? true : false;
+}
+
+async function fetchGithub(mo, repo, directory = '') {
+    const possiblyCDN = !(
+        (repo.branch.length % 2 === 0 && /^[A-F0-9]+$/i.test(repo.branch)) ||
+        repo.branch === 'master' ||
+        repo.branch === 'main'
+    );
+    if (possiblyCDN) {
+        const result = await fetchFromCDN(repo, directory);
+        if (result) {
+            return result;
+        }
+    }
+    return await fetchFromGithub(mo, repo, directory);
+}
+
+// function saveWorkplaceToMotoko(mo, files) {
+//     for (const [name, code] of Object.entries(files)) {
+//         if (!name.endsWith('mo')) continue;
+//         mo.addFile(name, code);
+//     }
+// }
+
+async function fetchFromCDN(mo, repo, directory = '') {
+    const meta_url = `https://data.jsdelivr.com/v1/package/gh/${repo.repo}@${repo.branch}/flat`;
+    const base_url = `https://cdn.jsdelivr.net/gh/${repo.repo}@${repo.branch}`;
+    const response = await fetch(meta_url);
+    const json = await response.json();
+    if (!json.hasOwnProperty('files')) {
+        throw new Error(json.message || `Could not fetch from CDN: ${repo}`);
+    }
+    const promises = [];
+    const files = {};
+    for (const f of json.files) {
+        if (f.name.startsWith(`/${repo.dir}/`) && /\.mo$/.test(f.name)) {
+            const promise = (async () => {
+                const content = await (await fetch(base_url + f.name)).text();
+                const stripped =
+                    directory +
+                    f.name.slice(repo.dir ? repo.dir.length + 1 : 0);
+                mo.write(stripped, content);
+                files[stripped] = content;
+            })();
+            promises.push(promise);
+        }
+    }
+    if (!promises.length) {
+        return;
+    }
+    return Promise.all(promises).then(() => {
+        return files;
+    });
+}
+
+async function fetchFromGithub(mo, repo, directory = '') {
+    const meta_url = `https://api.github.com/repos/${repo.repo}/git/trees/${repo.branch}?recursive=1`;
+    const base_url = `https://raw.githubusercontent.com/${repo.repo}/${repo.branch}/`;
+    const response = await fetch(meta_url);
+    const json = await response.json();
+    if (!json.hasOwnProperty('tree')) {
+        throw new Error(
+            json.message || `Could not fetch from GitHub repository: ${repo}`,
+        );
+    }
+    const promises = [];
+    const files = {};
+    for (const f of json.tree) {
+        if (
+            f.path.startsWith(repo.dir ? `${repo.dir}/` : '') &&
+            f.type === 'blob' &&
+            /\.mo$/.test(f.path)
+        ) {
+            const promise = (async () => {
+                const content = await (await fetch(base_url + f.path)).text();
+                const stripped =
+                    directory +
+                    (directory ? '/' : '') +
+                    f.path.slice(repo.dir ? repo.dir.length + 1 : 0);
+                mo.write(stripped, content);
+                files[stripped] = content;
+            })();
+            promises.push(promise);
+        }
+    }
+    if (!promises.length) {
+        return;
+    }
+    return Promise.all(promises).then(() => {
+        return files;
+    });
+}
+
+// async function resolve(path) {
+
+// }
+
+function parseGithubPackage(path, name) {
+    if (!path) {
+        return;
+    }
+    if (typeof path === 'object') {
+        return path;
+    }
+
+    let result;
+    try {
+        result = parse(path);
+        if (!result) {
+            return;
+        }
+    } catch (err) {
+        console.warn(err);
+    }
+
+    const { name: repoName, filepath, branch, owner } = result;
+
+    return {
+        name: name || repoName,
+        repo: `https://github.com/${owner}/${repoName}.git`,
+        version: branch,
+        dir: filepath,
+        // homepage: ,
+    };
+}
+
+module.exports = {
+    // async findPackage(package) {
+    //     if (typeof package === 'string') {
+    //         return resolve(package);
+    //     }
+    //     return package;
+    // },
+    loadPackages: async (mo, packages) => {
+        for (const [name, path] of Object.entries(packages)) {
+            const info = parseGithubPackage(path, name);
+            return fetchPackage(mo, info);
+        }
+    },
+};

package/package.json

@@ -1,12 +1,53 @@
 {
-  "name": "motoko",
-  "version": "1.0.1",
-  "description": "",
-  "main": "motoko.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC"
+    "name": "motoko",
+    "version": "2.0.4",
+    "description": "Compile Motoko smart contracts in Node.js and the browser.",
+    "author": "Ryan Vandersmith (https://github.com/rvanasa)",
+    "license": "Apache-2.0",
+    "main": "./index.js",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/dfinity/node-motoko.git"
+    },
+    "scripts": {
+        "generate": "node utils/generate",
+        "test": "jest"
+    },
+    "dependencies": {
+        "cross-fetch": "3.1.5",
+        "isomorphic-parse-github-url": "1.0.2"
+    },
+    "devDependencies": {
+        "@wasmer/wasi": "^1.0.2",
+        "cross-env": "^7.0.3",
+        "jest": "^28.1.3",
+        "prettier": "^2.7.1"
+    },
+    "directories": {
+        "lib": "lib",
+        "example": "examples"
+    },
+    "files": [
+        "index.js",
+        "interpreter.js",
+        "lib",
+        "contrib",
+        "versions/latest"
+    ],
+    "keywords": [
+        "motoko",
+        "language",
+        "programming-language",
+        "dfinity",
+        "smart-contract",
+        "canister",
+        "browser",
+        "ic",
+        "icp",
+        "internet-computer",
+        "blockchain",
+        "cryptocurrency",
+        "nft",
+        "token"
+    ]
 }