motoko 0.1.0

package/lib/index.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const debug = require('debug')('motoko');
+
+const { Motoko } = require('./generated/moc');
+const { loadPackages } = require('./package');
+
+const invoke = (key, unwrap, args) => {
+    let result;
+    try {
+        result = Motoko[key](...args);
+    } catch (e) {
+        throw new Error(
+            `Unable to execute ${key}(${[...args]
+                .map((x) => typeof x)
+                .join(', ')}):\n${JSON.stringify(e)}`,
+        );
+    }
+    if (!unwrap) {
+        return result;
+    }
+    if (!result.code) {
+        throw new Error(
+            result.diagnostics
+                ? result.diagnostics.map(({ message }) => message).join('; ')
+                : '(no diagnostics)',
+        );
+    }
+    return result.code;
+};
+
+// for (const key of Object.keys(Motoko)) {
+//     if (typeof Motoko[key] === 'function') {
+//         const fn = Motoko[key];
+//         Motoko[key] = (...args) => {
+//             debug(key, ...args);
+//             fn(...args);
+//         };
+//     }
+// }
+
+module.exports = {
+    Motoko,
+    loadPackages,
+    addFile(path, content) {
+        debug('+file', path);
+        try {
+            // TEMP
+            invoke('saveFile', false, [path, content]);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    },
+    removeFile(path) {
+        debug('-file', path);
+        invoke('removeFile', false, [path, content]);
+    },
+    getFiles(path) {
+        const files = invoke('readDir', false, [path]);
+
+        return files;
+    },
+    addPackage(name, path) {
+        debug('+package', name, path);
+        invoke('addPackage', false, [name, path]);
+    },
+    clearPackages() {
+        debug('-packages');
+        invoke('clearPackage', false, []);
+    },
+    parse(content) {
+        const ast = invoke('parse', true, [content]);
+        return ast;
+    },
+    parseCandid(content) {
+        const ast = invoke('parseCandid', true, [content]);
+        return ast;
+    },
+    candid(path) {
+        return invoke('candid', true, [path]);
+    },
+};
+exports.default = exports;

package/lib/index.test.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const Motoko = require('.');
+
+const actorMo = `
+actor Main {
+    public func test() : async Nat {
+        123
+    }
+}
+`;
+
+test('placeholder', () => {
+    expect(true).toEqual(true); // placeholder
+
+    console.log(Motoko.parse(actorMo));
+});

package/lib/package.js

@@ -0,0 +1,156 @@
+'use strict';
+// Derived from: https://github.com/dfinity/motoko-playground/blob/main/src/workers/file.ts
+
+const parse = require('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.addFile(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.addFile(stripped, content);
+                files[stripped] = content;
+            })();
+            promises.push(promise);
+        }
+    }
+    if (!promises.length) {
+        return;
+    }
+    return Promise.all(promises).then(() => {
+        return files;
+    });
+}
+
+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);
+    }
+
+    console.log(result);
+    const { name: repoName, filepath, branch, owner } = result;
+
+    return {
+        name: name || repoName,
+        // repo,
+        repo: `https://github.com/${owner}/${repoName}.git`,
+        version: branch,
+        dir: filepath,
+        // homepage: ,
+    };
+}
+
+module.exports = {
+    async loadPackages(packages) {
+        for (const [name, path] of Object.entries(packages)) {
+            const mo = require('.');
+            const info = parseGithubPackage(path, name);
+            return fetchPackage(mo, info);
+        }
+    },
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "motoko",
+    "version": "0.1.0",
+    "description": "Compile Motoko smart contracts in Node.js and the browser.",
+    "author": "Ryan Vandersmith (https://github.com/rvanasa)",
+    "license": "Apache-2.0",
+    "main": "lib/index.js",
+    "scripts": {
+        "test": "jest"
+    },
+    "dependencies": {
+        "cross-fetch": "^3.1.5",
+        "parse-github-url": "^1.0.2"
+    },
+    "devDependencies": {
+        "cross-env": "^7.0.3",
+        "jest": "^28.1.3",
+        "prettier": "^2.7.1"
+    },
+    "directories": {
+        "lib": "lib"
+    },
+    "files": [
+        "lib"
+    ],
+    "keywords": [
+        "motoko",
+        "language",
+        "programming-language",
+        "dfinity",
+        "smart-contract",
+        "canister",
+        "browser",
+        "ic",
+        "icp",
+        "internet-computer",
+        "blockchain",
+        "cryptocurrency",
+        "nft",
+        "token"
+    ]
+}