motoko 2.0.6 → 2.0.9

package/src/index.ts

@@ -0,0 +1,139 @@
+import { file } from './file';
+import { loadPackages, PackageInfo } from './package';
+
+export type Motoko = ReturnType<typeof getMotoko>;
+
+type Compiler = any; // TODO
+
+// TODO
+export type Diagnostic = {
+    code?: string | number | { target: any; value: string | number };
+    message: string;
+    range: {
+        start: { line: number; character: number };
+        end: { line: number; character: number };
+    };
+    severity: string;
+    source?: string;
+    tags?: string[];
+};
+
+export type WasmMode = 'ic' | 'wasi';
+
+export default function getMotoko(compiler: Compiler, version: string) {
+    const debug = require('debug')(version ? `motoko:${version}` : 'motoko');
+
+    const invoke = (key: string, unwrap: boolean, args: any[]) => {
+        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 }: Diagnostic) => message)
+                          .join('; ')
+                    : '(no diagnostics)',
+            );
+        }
+        return result.code;
+    };
+
+    const mo = {
+        version,
+        compiler,
+        file(path: string) {
+            return file(mo, path);
+        },
+        // findPackage,
+        async loadPackages(packages: Record<string, string | PackageInfo>) {
+            return loadPackages(mo, packages);
+        },
+        read(path: string): string {
+            return invoke('readFile', false, [path]);
+        },
+        write(path: string, content: string = '') {
+            if (typeof content !== 'string') {
+                throw new Error('Non-string file content');
+            }
+            debug('+file', path);
+            invoke('saveFile', false, [path, content]);
+        },
+        rename(path: string, newPath: string) {
+            invoke('renameFile', false, [path, newPath]);
+        },
+        delete(path: string) {
+            debug('-file', path);
+            invoke('removeFile', false, [path]);
+        },
+        list(directory: string): string[] {
+            return invoke('readDir', false, [directory]);
+        },
+        addPackage(name: string, directory: string) {
+            debug('+package', name, directory);
+            invoke('addPackage', false, [name, directory]);
+        },
+        clearPackages() {
+            debug('-packages');
+            invoke('clearPackage', false, []);
+        },
+        setAliases(aliases: string) {
+            debug('aliases', aliases);
+            invoke('setActorAliases', false, [Object.entries(aliases)]);
+        },
+        setMetadata(values: string) {
+            invoke('setPublicMetadata', false, [values]);
+        },
+        check(path: string): Diagnostic[] {
+            const result = invoke('check', false, [path]);
+            return result.diagnostics;
+        },
+        run(
+            path: string,
+            libPaths?: string[] | undefined,
+        ): { stdout: string; stderr: string; result: number | string } {
+            return invoke('run', false, [libPaths || [], path]);
+        },
+        candid(path: string): string {
+            return invoke('candid', true, [path]);
+        },
+        wasm(path: string, mode: WasmMode) {
+            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: string): object {
+            return invoke('parseMotoko', true, [content]);
+        },
+        parseCandid(content: string): object {
+            return invoke('parseCandid', true, [content]);
+        },
+    };
+    // @ts-ignore
+    mo.default = mo;
+    return mo;
+}

package/src/package.ts

@@ -0,0 +1,185 @@
+// Derived from: https://github.com/dfinity/motoko-playground/blob/main/src/workers/file.ts
+
+// @ts-ignore
+import { default as parse } from 'isomorphic-parse-github-url';
+import fetch from 'cross-fetch';
+import { Motoko } from '.';
+
+export interface PackageInfo {
+    name: string;
+    repo: string;
+    version: string;
+    dir: string;
+    branch?: string | undefined;
+}
+
+async function fetchPackage(mo: Motoko, info: PackageInfo) {
+    if (
+        !info.repo.startsWith('https://github.com/') ||
+        !info.repo.endsWith('.git')
+    ) {
+        return false;
+    }
+    const repo = {
+        name: info.name,
+        version: info.version,
+        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: Motoko, info: PackageInfo, directory = '') {
+    const possiblyCDN = !(
+        (info.branch.length % 2 === 0 && /^[A-F0-9]+$/i.test(info.branch)) ||
+        info.branch === 'master' ||
+        info.branch === 'main'
+    );
+    if (possiblyCDN) {
+        const result = await fetchFromCDN(mo, info, directory);
+        if (result) {
+            return result;
+        }
+    }
+    return await fetchFromGithub(mo, info, 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: Motoko, info: PackageInfo, directory = '') {
+    const meta_url = `https://data.jsdelivr.com/v1/package/gh/${info.repo}@${info.branch}/flat`;
+    const base_url = `https://cdn.jsdelivr.net/gh/${info.repo}@${info.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: ${info}`);
+    }
+    const promises: Promise<void>[] = [];
+    const files: Record<string, string> = {};
+    for (const f of json.files) {
+        if (f.name.startsWith(`/${info.dir}/`) && /\.mo$/.test(f.name)) {
+            const promise = (async () => {
+                const content = await (await fetch(base_url + f.name)).text();
+                const stripped =
+                    directory +
+                    f.name.slice(info.dir ? info.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: Motoko,
+    info: PackageInfo,
+    directory: string = '',
+) {
+    const meta_url = `https://api.github.com/repos/${info.repo}/git/trees/${info.branch}?recursive=1`;
+    const base_url = `https://raw.githubusercontent.com/${info.repo}/${info.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: ${info}`,
+        );
+    }
+    const promises: Promise<void>[] = [];
+    const files: Record<string, string> = {};
+    for (const f of json.tree) {
+        if (
+            f.path.startsWith(info.dir ? `${info.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(info.dir ? info.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: string | PackageInfo,
+    name: string,
+): PackageInfo {
+    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: ,
+    };
+}
+
+export async function loadPackages(
+    mo: Motoko,
+    packages: Record<string, string | PackageInfo>,
+) {
+    await Promise.all(
+        Object.entries(packages).map(([name, path]) => {
+            const info = parseGithubPackage(path, name);
+            return fetchPackage(mo, info);
+        }),
+    );
+}
+
+// export async function findPackage(package) {
+//     if (typeof package === 'string') {
+//         return resolve(package);
+//     }
+//     return package;
+// },

package/src/versions/interpreter.ts

@@ -0,0 +1,4 @@
+import getMotoko from '..';
+const { Motoko } = require('../../versions/latest/moc_interpreter.min');
+
+export default getMotoko(Motoko, 'latest/interpreter');

package/src/versions/moc.ts

@@ -0,0 +1,4 @@
+import getMotoko from '..';
+const { Motoko } = require('../../versions/latest/moc.min');
+
+export default getMotoko(Motoko, 'latest');

package/lib/__tests__/index.test.js

@@ -1,40 +0,0 @@
-'use strict';
-
-const mo = require('../..');
-
-const actor = `
-actor Main {
-    public func test() : async Nat {
-        123
-    }
-}
-`;
-
-describe('virtual file system I/O', () => {
-    test('write -> read', () => {
-        const path = 'test__write_read__.txt';
-        const text = 'A\nB';
-        mo.write(path, text);
-        expect(mo.read(path)).toStrictEqual(text);
-    });
-});
-
-describe('check', () => {
-    test('works for a basic example', () => {
-        const path = 'test__check__.mo';
-        mo.write(path, actor);
-        expect(mo.check(path)).toStrictEqual([]);
-    });
-});
-
-describe('run', () => {
-    test('works for a basic example', () => {
-        const path = 'test__run__.mo';
-        mo.write(path, 'let x = 1 + 1; x');
-        expect(mo.run(path)).toStrictEqual({
-            result: 0,
-            stdout: '2 : Nat\n',
-            stderr: '',
-        });
-    });
-});

package/lib/__tests__/interpreter.test.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const mo = require('../../interpreter');
-
-describe('run', () => {
-    test('works for a basic example', () => {
-        const path = 'test__run__.mo';
-        mo.write(path, 'let x = 1 + 1; x');
-        expect(mo.run(path)).toStrictEqual({
-            result: 0,
-            stdout: '2 : Nat\n',
-            stderr: '',
-        });
-    });
-});