motoko 3.0.0-beta0 → 3.0.0-beta2

package/lib/versions/interpreter.d.ts

@@ -17,24 +17,25 @@ declare const _default: {
         };
         candid(): string;
         wasm(mode: import("..").WasmMode): any;
-        parseMotoko(): {
-            ast: object;
-            exportType: object;
-        };
-        parseCandid(): {
-            ast: object;
+        parseMotoko(): import("../ast").Node;
+        parseMotokoTyped(): {
+            ast: import("../ast").Node;
+            type: import("../ast").Node;
         };
+        parseCandid(): object;
     };
     read(path: string): string;
     write(path: string, content?: string): void;
     rename(path: string, newPath: string): void;
     delete(path: string): void;
     list(directory: string): string[];
-    fetchPackage(info: string | import("../package").PackageInfo): Promise<import("../package").Package>;
-    loadPackages(packages: Record<string, string | import("../package").PackageInfo>): Promise<void>;
-    addPackage(name: string, directory: string): void;
+    fetchPackage(name: string, info: string | import("../package").PackageInfo): Promise<import("../package").Package>;
+    installPackages(packages: Record<string, string | import("../package").PackageInfo>): Promise<void>;
+    loadPackage(pkg: import("../package").Package): void;
+    usePackage(name: string, directory: string): void;
     clearPackages(): void;
-    setAliases(aliases: string): void;
+    validatePackage(pkg: import("../package").Package): void;
+    setAliases(aliases: Record<string, string>): void;
     setMetadata(values: string): void;
     check(path: string): import("..").Diagnostic[];
     run(path: string, libPaths?: string[]): {
@@ -44,13 +45,14 @@ declare const _default: {
     };
     candid(path: string): string;
     wasm(path: string, mode: import("..").WasmMode): any;
-    parseMotoko(content: string): {
-        ast: object;
-        exportType: object;
-    };
-    parseCandid(content: string): {
-        ast: object;
+    parseMotoko(content: string): import("../ast").Node;
+    parseMotokoTyped(content: string): {
+        ast: import("../ast").Node;
+        type: import("../ast").Node;
     };
+    parseCandid(content: string): object;
+    resolveMain(directory?: string): string;
+    resolveLib(directory?: string): string;
 };
 export default _default;
 //# sourceMappingURL=interpreter.d.ts.map

package/lib/versions/interpreter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../src/versions/interpreter.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAAwD"}
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../src/versions/interpreter.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAAwD"}

package/lib/versions/moc.d.ts

@@ -17,24 +17,25 @@ declare const _default: {
         };
         candid(): string;
         wasm(mode: import("..").WasmMode): any;
-        parseMotoko(): {
-            ast: object;
-            exportType: object;
-        };
-        parseCandid(): {
-            ast: object;
+        parseMotoko(): import("../ast").Node;
+        parseMotokoTyped(): {
+            ast: import("../ast").Node;
+            type: import("../ast").Node;
         };
+        parseCandid(): object;
     };
     read(path: string): string;
     write(path: string, content?: string): void;
     rename(path: string, newPath: string): void;
     delete(path: string): void;
     list(directory: string): string[];
-    fetchPackage(info: string | import("../package").PackageInfo): Promise<import("../package").Package>;
-    loadPackages(packages: Record<string, string | import("../package").PackageInfo>): Promise<void>;
-    addPackage(name: string, directory: string): void;
+    fetchPackage(name: string, info: string | import("../package").PackageInfo): Promise<import("../package").Package>;
+    installPackages(packages: Record<string, string | import("../package").PackageInfo>): Promise<void>;
+    loadPackage(pkg: import("../package").Package): void;
+    usePackage(name: string, directory: string): void;
     clearPackages(): void;
-    setAliases(aliases: string): void;
+    validatePackage(pkg: import("../package").Package): void;
+    setAliases(aliases: Record<string, string>): void;
     setMetadata(values: string): void;
     check(path: string): import("..").Diagnostic[];
     run(path: string, libPaths?: string[]): {
@@ -44,13 +45,14 @@ declare const _default: {
     };
     candid(path: string): string;
     wasm(path: string, mode: import("..").WasmMode): any;
-    parseMotoko(content: string): {
-        ast: object;
-        exportType: object;
-    };
-    parseCandid(content: string): {
-        ast: object;
+    parseMotoko(content: string): import("../ast").Node;
+    parseMotokoTyped(content: string): {
+        ast: import("../ast").Node;
+        type: import("../ast").Node;
     };
+    parseCandid(content: string): object;
+    resolveMain(directory?: string): string;
+    resolveLib(directory?: string): string;
 };
 export default _default;
 //# sourceMappingURL=moc.d.ts.map

package/lib/versions/moc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moc.d.ts","sourceRoot":"","sources":["../../src/versions/moc.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAA4C"}
+{"version":3,"file":"moc.d.ts","sourceRoot":"","sources":["../../src/versions/moc.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAA4C"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "motoko",
-    "version": "3.0.0-beta0",
+    "version": "3.0.0-beta2",
     "description": "Compile and run Motoko smart contracts in Node.js or the browser.",
     "author": "Ryan Vandersmith (https://github.com/rvanasa)",
     "license": "Apache-2.0",
@@ -21,7 +21,8 @@
     "dependencies": {
         "cross-fetch": "3.1.5",
         "debug": "4.3.4",
-        "isomorphic-parse-github-url": "1.0.2"
+        "isomorphic-parse-github-url": "1.0.2",
+        "sanitize-filename": "^1.6.3"
     },
     "devDependencies": {
         "@types/jest": "^28.1.3",

package/src/ast.ts

@@ -0,0 +1,69 @@
+export type CompilerAST = CompilerAST[] | CompilerNode | string | null;
+export type CompilerSpan = { name: 'Pos'; args: [string, string, string] };
+
+export interface CompilerNode {
+    name: string;
+    args: CompilerAST[];
+}
+
+export type Span = [number, number];
+export type AST = AST[] | Node | string | null;
+
+export interface Node {
+    name: string;
+    file?: string;
+    start?: Span;
+    end?: Span;
+    type?: Node;
+    args?: AST[];
+}
+
+// export type TypeAST = AST[] | Node | string | number | null;
+// export type TypeNode = {
+//     name: string;
+//     args: TypeAST[];
+// };
+
+export function simplifyAST(ast: CompilerNode): Node;
+export function simplifyAST(ast: CompilerAST[]): AST[];
+export function simplifyAST<T extends CompilerAST>(ast: T): T;
+
+export function simplifyAST(ast: CompilerAST): AST {
+    if (Array.isArray(ast)) {
+        return ast.map((a) => simplifyAST(a));
+    }
+    if (typeof ast !== 'object') {
+        return ast;
+    }
+    if (ast.name === '@') {
+        const [start, end, subAst] = ast.args as [
+            CompilerSpan,
+            CompilerSpan,
+            CompilerAST,
+        ];
+        return {
+            ...(typeof subAst === 'string'
+                ? { name: subAst }
+                : simplifyAST(subAst)),
+            file: start.args[0],
+            start: [+start.args[1], +start.args[2]],
+            end: [+end.args[1], +end.args[2]],
+        };
+    }
+    if (ast.name === ':') {
+        const [type, subAst] = ast.args as [CompilerNode, CompilerAST];
+        // console.log(subAst); ////
+        return {
+            ...(typeof subAst === 'string'
+                ? { name: subAst }
+                : simplifyAST(subAst)),
+            type: simplifyAST(type),
+        };
+    }
+    return {
+        name: ast.name,
+        args: simplifyAST(ast.args),
+    };
+}
+
+// export function getTypeString(type: Type) {}

package/src/file.ts

@@ -60,6 +60,9 @@ export const file = (mo: Motoko, path: string) => {
         parseMotoko() {
             return mo.parseMotoko(result.read());
         },
+        parseMotokoTyped() {
+            return mo.parseMotokoTyped(result.read());
+        },
         parseCandid() {
             return mo.parseCandid(result.read());
         },

package/src/index.ts

@@ -1,5 +1,13 @@
+import { Node, simplifyAST } from './ast';
 import { file } from './file';
-import { fetchPackage, loadPackages, PackageInfo } from './package';
+import {
+    fetchPackage,
+    installPackages,
+    Package,
+    PackageInfo,
+    validatePackage,
+} from './package';
+import { resolveMain, resolveLib } from './utils/resolveEntryPoint';
 
 export type Motoko = ReturnType<typeof wrapMotoko>;
 
@@ -21,7 +29,7 @@ export type Diagnostic = {
 export type WasmMode = 'ic' | 'wasi';
 
 export default function wrapMotoko(compiler: Compiler, version: string) {
-    const debug = require('debug')(version ? `motoko:${version}` : 'motoko');
+    const debug = require('debug')(`motoko:${version}`);
 
     const invoke = (key: string, unwrap: boolean, args: any[]) => {
         if (!compiler) {
@@ -86,21 +94,36 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
         list(directory: string): string[] {
             return invoke('readDir', false, [directory]);
         },
-        async fetchPackage(info: string | PackageInfo) {
-            return fetchPackage(info);
-        },
-        async loadPackages(packages: Record<string, string | PackageInfo>) {
-            return loadPackages(mo, packages);
-        },
-        addPackage(name: string, directory: string) {
-            debug('+package', name, directory);
+        async fetchPackage(name:string, info: string | PackageInfo) {
+            if(!info){
+                throw new Error('Please specify both a name and source');
+            }
+            return fetchPackage(name,info);
+        },
+        async installPackages(packages: Record<string, string | PackageInfo>) {
+            return installPackages(mo, packages);
+        },
+        loadPackage(pkg: Package) {
+            debug('+package', pkg.name);
+            mo.validatePackage(pkg);
+            const directory = `.node-motoko/${pkg.name}/${pkg.version}`;
+            Object.entries(pkg.files).forEach(([path, file]) => {
+                mo.write(`${directory}/${path}`, file.content);
+            });
+            mo.usePackage(pkg.name, directory);
+        },
+        usePackage(name: string, directory: string) {
+            debug('@package', name, directory);
             invoke('addPackage', false, [name, directory]);
         },
         clearPackages() {
             debug('-packages');
             invoke('clearPackage', false, []);
         },
-        setAliases(aliases: string) {
+        validatePackage(pkg: Package) {
+            validatePackage(pkg);
+        },
+        setAliases(aliases: Record<string, string>) {
             debug('aliases', aliases);
             invoke('setActorAliases', false, [Object.entries(aliases)]);
         },
@@ -128,12 +151,26 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
             }
             return invoke('compileWasm', true, [mode, path]);
         },
-        parseMotoko(content: string): { ast: object; exportType: object } {
-            return invoke('parseMotoko', true, [content]);
+        parseMotoko(content: string): Node {
+            const ast = invoke('parseMotoko', true, [content]);
+            return simplifyAST(ast);
         },
-        parseCandid(content: string): { ast: object } {
+        parseMotokoTyped(content: string): { ast: Node; type: Node } {
+            const { ast, typ } = invoke('parseMotokoTyped', true, [content]);
+            return {
+                ast: simplifyAST(ast),
+                type: simplifyAST(typ),
+            };
+        },
+        parseCandid(content: string): object {
             return invoke('parseCandid', true, [content]);
         },
+        resolveMain(directory: string = ''): string | undefined {
+            return resolveMain(mo, directory);
+        },
+        resolveLib(directory: string = ''): string | undefined {
+            return resolveLib(mo, directory);
+        },
     };
     // @ts-ignore
     mo.default = mo;

package/src/package.ts

@@ -4,6 +4,7 @@
 import { default as parse } from 'isomorphic-parse-github-url';
 import fetch from 'cross-fetch';
 import { Motoko } from '.';
+import sanitize from 'sanitize-filename';
 
 export interface PackageInfo {
     name: string;
@@ -42,7 +43,7 @@ async function loadPackage(mo: Motoko, info: PackageInfo) {
     };
     const result = await fetchGithub_(mo, repo, info.name);
     if (result) {
-        mo.addPackage(info.name, info.name + '/');
+        mo.usePackage(info.name, info.name + '/');
     }
     return result ? true : false;
 }
@@ -279,6 +280,7 @@ async function fetchFromService(
 }
 
 export async function fetchPackage(
+    name: string,
     info: string | PackageInfo,
 ): Promise<Package | undefined> {
     if (typeof info === 'string') {
@@ -289,13 +291,13 @@ export async function fetchPackage(
         return;
     }
     return {
-        name: info.name,
+        name,
         version: info.version,
         files,
     };
 }
 
-export async function loadPackages(
+export async function installPackages(
     mo: Motoko,
     packages: Record<string, string | PackageInfo>,
 ) {
@@ -309,3 +311,54 @@ export async function loadPackages(
         }),
     );
 }
+
+export function validatePackage(pkg: Package) {
+    function showValue(value: any) {
+        const string = JSON.stringify(value);
+        return string.length > 50 ? string.substring(0, 50) + '...' : string;
+    }
+    function getPackageDisplayName() {
+        return `(${pkg.name} / ${pkg.version})`;
+    }
+
+    if (typeof pkg !== 'object' || Array.isArray(pkg)) {
+        throw new Error(`Unexpected package: ${showValue(pkg)}`);
+    }
+    if (typeof pkg.name !== 'string' || sanitize(pkg.name) !== pkg.name) {
+        throw new Error(`Invalid package name ${getPackageDisplayName()}`);
+    }
+    if (
+        typeof pkg.version !== 'string' ||
+        sanitize(pkg.version) !== pkg.version
+    ) {
+        throw new Error(`Invalid package version ${getPackageDisplayName()}`);
+    }
+    if (typeof pkg.files !== 'object' || Array.isArray(pkg.files)) {
+        throw new Error(`Invalid package files: ${showValue(pkg.files)}`);
+    }
+
+    Object.entries(pkg.files).forEach(([path, file]) => {
+        if (
+            typeof path !== 'string' ||
+            path.split('/').some((p) => sanitize(p) !== p)
+        ) {
+            throw new Error(
+                `Invalid file path ${getPackageDisplayName()} [${path}]`,
+            );
+        }
+        if (typeof file !== 'object' || Array.isArray(file)) {
+            throw new Error(
+                `Invalid file ${getPackageDisplayName()} [${path}]: ${showValue(
+                    file,
+                )}`,
+            );
+        }
+        if (typeof file.content !== 'string') {
+            throw new Error(
+                `Invalid file content ${getPackageDisplayName()} [${path}]: ${showValue(
+                    file.content,
+                )}`,
+            );
+        }
+    });
+}

package/src/utils/resolveEntryPoint.ts

@@ -0,0 +1,64 @@
+import { Motoko } from '..';
+
+// function getOne<T>(values: T[]): T | undefined {
+//     if (values.length) {
+//         return values[0];
+//     }
+// }
+
+function resolveEntryPoint(
+    mo: Motoko,
+    directory: string,
+    expected: string,
+): string {
+    directory = directory || '';
+    if (directory && !directory.endsWith('/')) {
+        directory += '/';
+    }
+
+    const moFiles = mo.list(directory).filter((f) => /\.mo$/i.test(f));
+    if (moFiles.length === 1) {
+        return moFiles[0];
+    } else if (moFiles.length === 0) {
+        throw new Error(
+            'Could not find any Motoko files in the top-level directory',
+        );
+    }
+
+    const expectedFiles = moFiles.filter(
+        (f) => f.toLowerCase() === expected.toLowerCase(),
+    );
+    if (expectedFiles.length === 1) {
+        return expectedFiles[0];
+    } else if (expectedFiles.length > 1) {
+        throw new Error(
+            `Found ${expectedFiles.length} entry point files with different capitalization`,
+        );
+    }
+
+    throw new Error(
+        `Found ${moFiles.length} possible entry points. Please rename one of these files to '${expected}'`,
+    );
+
+    // TODO: evaluate whether we want to choose an entry point by parsing files
+
+    // const parsedFiles = moFiles.map((f) => {
+    //     try {
+    //         return mo.parseMotoko(mo.read(directory + f));
+    //     } catch (err) {
+    //         throw new Error(`Parse error in ${f}`);
+    //     }
+    // });
+
+    // console.log(parsedFiles);
+
+    // return getOne(parsedFiles.filter());
+}
+
+export function resolveMain(mo: Motoko, directory: string): string {
+    return resolveEntryPoint(mo, directory, 'Main.mo');
+}
+
+export function resolveLib(mo: Motoko, directory: string): string {
+    return resolveEntryPoint(mo, directory, 'Lib.mo');
+}