motoko 0.1.5 → 2.0.2

package/lib/index.js

@@ -1,86 +1,120 @@
 'use strict';
 
-const debug = require('debug')('motoko');
+const { file } = require('./file');
+const { /* findPackage, */ loadPackages } = require('./package');
 
-const { Motoko } = require('./generated/moc');
-const { /* resolvePackage, */ loadPackages } = require('./package');
+module.exports = (compiler, version) => {
+    const debug = require('debug')(version ? `motoko:${version}` : 'motoko');
 
-const invoke = (key, unwrap, args) => {
-    if (typeof Motoko[key] !== 'function') {
-        throw new Error(`Unknown compiler function: '${key}'`);
-    }
-    let result;
-    try {
-        result = Motoko[key](...args);
-    } catch (err) {
-        if (err instanceof Error) {
-            throw err;
+    const invoke = (key, unwrap, args) => {
+        if (!compiler) {
+            throw new Error(
+                'Please load a Motoko compiler before running this function',
+            );
         }
-        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;
-};
-
-module.exports = {
-    Motoko,
-    // resolvePackage,
-    loadPackages,
-    addFile(file, content = '') {
-        if (typeof content !== 'string') {
-            throw new Error('Non-string file content');
+        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)}`,
+            );
         }
-        debug('+file', file);
-        invoke('saveFile', false, [file, content]);
-    },
-    removeFile(file) {
-        debug('-file', file);
-        invoke('removeFile', false, [file, content]);
-    },
-    listFiles(directory) {
-        return invoke('readDir', false, [directory]);
-    },
-    addPackage(name, file) {
-        debug('+package', name, file);
-        invoke('addPackage', false, [name, file]);
-    },
-    clearPackages() {
-        debug('-packages');
-        invoke('clearPackage', false, []);
-    },
-    check(file) {
-        const result = invoke('check', false, [file]);
-        return result.diagnostics;
-    },
-    run(file, libFiles) {
-        return invoke('run', false, [libFiles || [], file]);
-    },
-    candid(file) {
-        return invoke('candid', true, [file]);
-    },
-    wasm(mode, file) {
-        return invoke('compileWasm', true, [mode, file]);
-    },
-    parse(content) {
-        const ast = invoke('parse', true, [content]);
-        return ast;
-    },
-    parseCandid(content) {
-        const ast = invoke('parseCandid', true, [content]);
-        return ast;
-    },
+        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

@@ -136,7 +136,6 @@ function parseGithubPackage(path, name) {
         console.warn(err);
     }
 
-    console.log(result);
     const { name: repoName, filepath, branch, owner } = result;
 
     return {
@@ -149,15 +148,14 @@ function parseGithubPackage(path, name) {
 }
 
 module.exports = {
-    // async resolvePackage(package) {
+    // async findPackage(package) {
     //     if (typeof package === 'string') {
     //         return resolve(package);
     //     }
     //     return package;
     // },
-    async loadPackages(packages) {
+    loadPackages: async (mo, packages) => {
         for (const [name, path] of Object.entries(packages)) {
-            const mo = require('.');
             const info = parseGithubPackage(path, name);
             return fetchPackage(mo, info);
         }

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "motoko",
-    "version": "0.1.5",
+    "version": "2.0.2",
     "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",
+    "main": "./index.js",
     "scripts": {
         "generate": "node utils/generate",
         "test": "jest"
@@ -14,18 +14,21 @@
         "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",
-        "uglify-js": "^3.16.3"
+        "prettier": "^2.7.1"
     },
     "directories": {
         "lib": "lib",
         "contrib": "contrib"
     },
     "files": [
+        "index.js",
+        "interpreter.js",
         "lib",
-        "contrib"
+        "contrib",
+        "versions/latest"
     ],
     "keywords": [
         "motoko",