motoko 3.0.0-beta3 → 3.0.0-beta5

package/src/file.ts

@@ -21,6 +21,9 @@ export const file = (mo: Motoko, path: string) => {
         get path(): string {
             return path;
         },
+        set path(newPath) {
+            path = newPath;
+        },
         // file(subPath) {
         //     subPath = getValidPath(subPath);
         //     return exports.file(`${path}/${subPath}`);
@@ -57,14 +60,14 @@ export const file = (mo: Motoko, path: string) => {
         wasm(mode: WasmMode) {
             return mo.wasm(path, mode);
         },
+        parseCandid() {
+            return mo.parseCandid(result.read());
+        },
         parseMotoko() {
             return mo.parseMotoko(result.read());
         },
         parseMotokoTyped() {
-            return mo.parseMotokoTyped(result.read());
-        },
-        parseCandid() {
-            return mo.parseCandid(result.read());
+            return mo.parseMotokoTyped([path]);
         },
     };
     return result;

package/src/index.ts

@@ -1,4 +1,4 @@
-import { Node, simplifyAST } from './ast';
+import { Node, simplifyAST, CompilerAST, CompilerNode } from './ast';
 import { file } from './file';
 import {
     fetchPackage,
@@ -11,9 +11,9 @@ import { resolveMain, resolveLib } from './utils/resolveEntryPoint';
 
 export type Motoko = ReturnType<typeof wrapMotoko>;
 
-type Compiler = any; // TODO
+type Compiler = any; // TODO: generate from `js_of_ocaml`?
 
-// TODO
+// TODO: compatibility with the VS Code or Monaco `Diagnostic` type
 export type Diagnostic = {
     code?: string | number | { target: any; value: string | number };
     message: string;
@@ -28,15 +28,11 @@ export type Diagnostic = {
 
 export type WasmMode = 'ic' | 'wasi';
 
-export default function wrapMotoko(compiler: Compiler, version: string) {
+export default function wrapMotoko(compiler: Compiler) {
+    const version = compiler.version || '(unknown)';
     const debug = require('debug')(`motoko:${version}`);
 
     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}'`);
         }
@@ -68,6 +64,26 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
         return result.code;
     };
 
+    // Function signatures for `mo.parseMotokoTyped()`
+    type ParseMotokoTypedResult = { ast: Node; type: Node };
+    function parseMotokoTyped(paths: string): ParseMotokoTypedResult;
+    function parseMotokoTyped(paths: string[]): ParseMotokoTypedResult[];
+    function parseMotokoTyped(
+        paths: string | string[],
+    ): ParseMotokoTypedResult | ParseMotokoTypedResult[] {
+        if (typeof paths === 'string') {
+            return mo.parseMotokoTyped([paths])[0];
+        }
+        return invoke('parseMotokoTyped', true, [paths]).map(
+            ({ ast, typ }: { ast: CompilerNode; typ: CompilerNode }) => {
+                return {
+                    ast: simplifyAST(ast),
+                    type: simplifyAST(typ),
+                };
+            },
+        );
+    }
+
     const mo = {
         version,
         compiler,
@@ -94,11 +110,11 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
         list(directory: string): string[] {
             return invoke('readDir', false, [directory]);
         },
-        async fetchPackage(name:string, info: string | PackageInfo) {
-            if(!info){
+        async fetchPackage(name: string, info: string | PackageInfo) {
+            if (!info) {
                 throw new Error('Please specify both a name and source');
             }
-            return fetchPackage(name,info);
+            return fetchPackage(name, info);
         },
         async installPackages(packages: Record<string, string | PackageInfo>) {
             return installPackages(mo, packages);
@@ -123,8 +139,9 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
         validatePackage(pkg: Package) {
             validatePackage(pkg);
         },
-        setAliases(aliases: Record<string, string>) {
-            debug('aliases', aliases);
+        setAliases(directory: string, aliases: Record<string, string>) {
+            debug('aliases', directory, aliases);
+            invoke('setCandidPath', false, [directory]);
             invoke('setActorAliases', false, [Object.entries(aliases)]);
         },
         setMetadata(values: string) {
@@ -151,20 +168,14 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
             }
             return invoke('compileWasm', true, [mode, path]);
         },
+        parseCandid(content: string): object {
+            return invoke('parseCandid', true, [content]);
+        },
         parseMotoko(content: string): Node {
             const ast = invoke('parseMotoko', true, [content]);
             return simplifyAST(ast);
         },
-        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]);
-        },
+        parseMotokoTyped,
         resolveMain(directory: string = ''): string | undefined {
             return resolveMain(mo, directory);
         },

package/src/versions/interpreter.ts

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

package/src/versions/moc.ts

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