mlogjs 0.5.2 → 0.6.0

package/dist/Compiler.d.ts

@@ -4,36 +4,32 @@ type THandlerMap = {
     [k in es.Node["type"]]?: THandler<IValue | null>;
 };
 export interface CompilerOptions {
-    stackName?: string;
-    /** Wether the compiler should preserve or compact variable and function names*/
+    /** Wether the compiler should preserve or compact variable and function names */
     compactNames?: boolean;
     sourcemap?: boolean;
 }
 export declare class Compiler {
     protected stackName?: string;
-    protected usingStack: boolean;
     protected handlers: THandlerMap;
     readonly compactNames: boolean;
     readonly sourcemap: boolean;
-    constructor({ stackName, compactNames, sourcemap, }?: CompilerOptions);
+    constructor({ compactNames, sourcemap, }?: CompilerOptions);
     compile(script: string): [string, null, es.SourceLocation[] | undefined] | [null, CompilerError];
     protected resolve(valueInst: TValueInstructions<IValue | null>): void;
     protected serialize(resLines: TValueInstructions<IValue | null>): string;
     protected parse(script: string): import("@babel/parser").ParseResult<es.File>;
     protected mapSources(valueInst: TValueInstructions<IValue | null>): es.SourceLocation[];
-    handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput): TValueInstructions<IValue | null>;
+    handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput, arg?: unknown): TValueInstructions<IValue | null>;
     /** Handles the node and asserts that it resolves to a value. */
-    handleValue(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput): TValueInstructions;
-    handleEval(scope: IScope, node: es.Node, out?: TEOutput): TValueInstructions;
+    handleValue(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput, arg?: unknown): TValueInstructions;
+    handleEval(scope: IScope, node: es.Node, out?: TEOutput, arg?: unknown): TValueInstructions;
     /**
      * Handles many nodes in order.
      *
-     * The usage of this method over a regular loop over an array of nodes
-     * is only required if the code inside the loop generates
-     * instructions that are not tracked by the compiler
-     * handler methods ({@link handle}, {@link handleEval}
+     * The usage of this method over a regular loop over an array of nodes is only
+     * required if the code inside the loop generates instructions that are not
+     * tracked by the compiler handler methods ({@link handle}, {@link handleEval}
      * and {@link handleMany})
-     *
      */
     handleMany<T extends es.Node>(scope: IScope, nodes: T[], handler?: (node: T) => TValueInstructions<IValue | null>): TValueInstructions<null>;
 }

package/dist/CompilerError.d.ts

@@ -16,17 +16,27 @@ type CompilerErrorSource = es.Node | es.SourceLocation | {
     line: number;
     column: number;
 };
+export interface CompilerErrorLoc {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+}
 export declare class CompilerError extends Error {
-    protected _loc?: es.SourceLocation;
+    protected _loc?: CompilerErrorLoc;
     /**
      * The error that preceded this `CompilerError`.
      *
      * If it's not `undefined` it means that `this` is just wrapping the error to
      * append extra data like the node stack
-     * */
+     */
     inner?: unknown;
     constructor(message: string, source?: CompilerErrorSource);
-    get loc(): es.SourceLocation | undefined;
+    get loc(): CompilerErrorLoc | undefined;
     set loc(value: CompilerErrorSource | undefined);
     static from(error: unknown, source?: CompilerErrorSource): CompilerError;
 }

package/dist/Scope.d.ts

@@ -1,31 +1,31 @@
-import { SenseableValue } from "./values";
+import { StoreValue } from "./values";
 import { AddressResolver } from "./instructions";
 import { IFunctionValue, IInstruction, INamedValue, IScope, IValue } from "./types";
 export declare class Scope implements IScope {
+    data: Record<string, IValue | null>;
     parent: IScope | null;
-    stacked: boolean;
     ntemp: number;
     name: string;
     inst: IInstruction[];
     operationCache: Record<string, IValue>;
     cacheDependencies: Record<string, string[]>;
-    data: Record<string, IValue | null>;
     break: AddressResolver;
     continue: AddressResolver;
     function: IFunctionValue;
     label?: string;
     checkIndexes: boolean;
-    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[], operationCache?: Record<string, IValue>, cacheDependencies?: Record<string, string[]>);
+    builtInModules: Record<string, IValue>;
+    constructor({ data, parent, ntemp, name, inst, operationCache, cacheDependencies, builtInModules, }?: Partial<Pick<IScope, "data" | "parent" | "ntemp" | "name" | "inst" | "operationCache" | "cacheDependencies" | "builtInModules">>);
     copy(): IScope;
     createScope(): IScope;
-    createFunction(name: string, stacked?: boolean): IScope;
+    createFunction(name: string): IScope;
     has(identifier: string): boolean;
     get(identifier: string): INamedValue;
     set<T extends IValue>(name: string, value: T): T;
     hardSet<T extends IValue>(name: string, value: T): T;
-    make(identifier: string, name: string): SenseableValue;
+    make(identifier: string, name: string): StoreValue;
     makeTempName(): string;
-    addCachedOperation(op: string, result: IValue, left: IValue, right?: IValue | undefined): void;
-    getCachedOperation(op: string, left: IValue, right?: IValue | undefined): IValue | undefined;
+    addCachedOperation(op: string, result: IValue, left: IValue, right?: IValue): void;
+    getCachedOperation(op: string, left: IValue, right?: IValue): IValue | undefined;
     clearDependentCache(value: IValue): void;
 }

package/dist/bin/files.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns the contents of the tsconfig.json file that should be placed on the
+ * project's root directory
+ */
+export declare function getRootTSConfig(): string;
+/**
+ * Returns the contents of the tsconfig.json file that should be placed inside
+ * the .mlogjs folder
+ */
+export declare function getInnerTSConfig(): string;
+/**
+ * Returns the path to the lib folder of the compiler.
+ *
+ * To achieve this, this function assumes that the output bin.cjs file is one
+ * folder bellow the package folder. If this condition is not met, then the
+ * function will not return the correct path to the lib folder.
+ */
+export declare function getLibFolderPath(): string;

package/dist/bin.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import { existsSync, watchFile, rmSync, cpSync, writeFileSync, readFileSync } from 'node:fs';
+import { hideBin } from 'yargs/helpers';
+import { highlight } from 'cli-highlight';
+import yargs from 'yargs';
+import chalk from 'chalk';
+import { join, resolve, parse } from 'node:path';
+import { C as Compiler } from './Compiler-7GMG4MDr.js';
+import '@babel/parser';
+import '@babel/types';
+
+// The files generated by the setup command follow the following structure:
+// ./mlogjs
+// ├── lib/
+// └── tsconfig.json
+//
+// The lib folder contains the type definitions for the compiler's environment.
+// The tsconfig allows us to have a base configuration that can be updated
+// without modifying the user's tsconfig.json.
+/**
+ * Returns the contents of the tsconfig.json file that should be placed on the
+ * project's root directory
+ */
+function getRootTSConfig() {
+    const config = {
+        extends: "./.mlogjs/tsconfig.json",
+        include: ["./.mlogjs/lib", "*.js", "*.ts", "src"],
+        exclude: ["node_modules"],
+    };
+    return JSON.stringify(config, null, "\t");
+}
+/**
+ * Returns the contents of the tsconfig.json file that should be placed inside
+ * the .mlogjs folder
+ */
+function getInnerTSConfig() {
+    const config = {
+        compilerOptions: {
+            allowJs: true,
+            checkJs: true,
+            moduleDetection: "force",
+            noEmit: true,
+            noLib: true,
+            target: "ESNext",
+        },
+    };
+    return JSON.stringify(config, null, "\t");
+}
+/**
+ * Returns the path to the lib folder of the compiler.
+ *
+ * To achieve this, this function assumes that the output bin.cjs file is one
+ * folder bellow the package folder. If this condition is not met, then the
+ * function will not return the correct path to the lib folder.
+ */
+function getLibFolderPath() {
+    const currentPath = import.meta.dirname.replace(/\\/g, "/");
+    const parent = currentPath.split("/").slice(0, -1).join("/");
+    return join(parent, "lib");
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+yargs(hideBin(process.argv))
+    .command("setup [dir]", "Copies the compiler type definitions in the current folder", yargs => {
+    return yargs
+        .positional("dir", {
+        default: ".",
+        type: "string",
+        describe: "The directory where the type definitions folder will be copied",
+    })
+        .option("tsconfig", {
+        type: "boolean",
+        default: false,
+        describe: "Wether a tsconfig.json file should be created in the current directory",
+    });
+}, argv => {
+    const dir = resolve(process.cwd(), argv.dir);
+    console.log(process.cwd());
+    console.log(argv.dir);
+    setup(dir, argv.tsconfig);
+})
+    .command("$0 [path] [out]", "compiles your Javascript file to MLog", yargs => {
+    return yargs
+        .positional("path", {
+        describe: "path of the file to compile",
+        type: "string",
+    })
+        .positional("out", {
+        describe: "path of the output file",
+        type: "string",
+    })
+        .option("compact-names", {
+        type: "boolean",
+        default: false,
+        describe: "Wether the compiler should preserve or compact variable and function names",
+    })
+        .option("watch", {
+        type: "boolean",
+        default: false,
+        describe: "Wether the compiler should watch for file changes",
+    });
+}, argv => {
+    const path = argv.path;
+    if (!path)
+        return console.log("missing required path argument");
+    if (!existsSync(path))
+        return console.log(`file at ${path} does not exist`);
+    const out = argv.out ?? defaultOutPath(path);
+    if (path == out)
+        return console.log("The out path cannot be the same as the input path");
+    const options = {
+        compactNames: argv["compact-names"],
+    };
+    compile(path, out, options);
+    if (!argv.watch)
+        return;
+    // using interval of 600 milliseconds
+    // because 1 second might feel too slow to the user
+    watchFile(path, { interval: 600 }, () => compile(path, out, options));
+})
+    .help()
+    .scriptName("mlogjs")
+    .demandCommand()
+    .parse();
+function setup(dir, tsconfig) {
+    const dotDir = join(dir, ".mlogjs");
+    if (existsSync(dotDir)) {
+        rmSync(dotDir, { recursive: true });
+    }
+    const libPath = getLibFolderPath();
+    cpSync(libPath, join(dotDir, "lib"), {
+        recursive: true,
+    });
+    const innerTSConfig = getInnerTSConfig();
+    writeFileSync(join(dotDir, "tsconfig.json"), innerTSConfig);
+    if (!tsconfig)
+        return;
+    const rootTSConfig = getRootTSConfig();
+    writeFileSync(join(dir, "tsconfig.json"), rootTSConfig);
+}
+function compile(path, outPath, options) {
+    const resolvedPath = resolve(process.cwd(), path);
+    const code = readFileSync(path, "utf8");
+    const compiler = new Compiler(options);
+    const [result, error] = compiler.compile(code);
+    if (!error) {
+        writeFileSync(outPath, result);
+        console.log(`Success: Compiled ${path}. Your compiled code is at ${outPath}.`);
+        return;
+    }
+    if (!error.loc) {
+        console.log(error.inner ?? error);
+        return;
+    }
+    const { start, end } = error.loc;
+    const lines = code.split("\n");
+    console.log(chalk.cyanBright([resolvedPath, start.line, start.column].join(":")));
+    for (let i = Math.max(start.line - 3, 0); i < Math.min(end.line + 2, lines.length); i++) {
+        const n = i + 1;
+        if (n !== start.line)
+            continue;
+        const head = chalk.gray(`${n} | `.padStart(6, " "));
+        console.log(head + highlight(lines[i], { language: "ts" }));
+        console.log(chalk.red(" ".repeat(6 + start.column) + "^ " + error.message));
+    }
+}
+function defaultOutPath(path) {
+    const parsed = parse(path);
+    return join(parsed.dir, `${parsed.name}.mlog`);
+}

package/dist/handlers/Import.d.ts

@@ -0,0 +1,5 @@
+import { THandler } from "../types";
+export declare const ImportDeclaration: THandler<null>;
+export declare const ImportDefaultSpecifier: THandler<null>;
+export declare const ImportNamespaceSpecifier: THandler<null>;
+export declare const ImportSpecifier: THandler<null>;

package/dist/handlers/Literal.d.ts

@@ -1,5 +1,5 @@
 import { THandler } from "../types";
-export declare const NumericLiteral: THandler<import("../types").IValue>;
-export declare const StringLiteral: THandler<import("../types").IValue>;
+export declare const NumericLiteral: THandler;
+export declare const StringLiteral: THandler;
 export declare const NullLiteral: THandler;
 export declare const BooleanLiteral: THandler;

package/dist/handlers/Typescript.d.ts

@@ -1,6 +1,6 @@
 import { IValue, THandler } from "../types";
-export declare const TSAsExpression: THandler<IValue>;
-export declare const TSTypeAssertion: THandler<IValue>;
+export declare const TSAsExpression: THandler;
+export declare const TSTypeAssertion: THandler;
 export declare const TSInterfaceDeclaration: THandler<null>;
 export declare const TSTypeAliasDeclaration: THandler<null>;
 export declare const TSEnumDeclaration: THandler<null>;

package/dist/handlers/index.d.ts

@@ -15,3 +15,4 @@ export * from "./TemplateExpression";
 export * from "./BlockStatement";
 export * from "./File";
 export * from "./Typescript";
+export * from "./Import";