mlogjs 0.3.0 → 0.4.1

package/dist/{types/Compiler.d.ts → Compiler.d.ts}

@@ -7,20 +7,33 @@ export interface CompilerOptions {
     stackName?: string;
     /** 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;
-    constructor({ stackName, compactNames }?: CompilerOptions);
-    compile(script: string): [string, null, es.Node[]] | [null, Error | CompilerError, es.Node[]];
+    readonly sourcemap: boolean;
+    constructor({ stackName, 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>;
-    handle(scope: IScope, node: es.Node): TValueInstructions<IValue | null>;
+    protected mapSources(valueInst: TValueInstructions<IValue | null>): es.SourceLocation[];
+    handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined): TValueInstructions<IValue | null>;
     handleEval(scope: IScope, node: es.Node): TValueInstructions;
     handleConsume(scope: IScope, node: es.Node): TValueInstructions;
-    handleMany<T extends es.Node>(scope: IScope, nodes: T[], handler?: (scope: IScope, node: T) => TValueInstructions<IValue | null>): TValueInstructions<null>;
+    /**
+     * 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}, {@link handleConsume}
+     * and {@link handleMany})
+     *
+     */
+    handleMany<T extends es.Node>(scope: IScope, nodes: T[], handler?: (node: T) => TValueInstructions<IValue | null>): TValueInstructions<null>;
 }
 export {};

package/dist/CompilerError.d.ts

@@ -0,0 +1,33 @@
+import { es } from "./types";
+/**
+ * Error thrown by the babel parser.
+ *
+ * It doesn't export the type so we are writing it ourselves
+ */
+export interface ParsingError extends Error {
+    code: string;
+    reasonCode: string;
+    loc: {
+        line: number;
+        column: number;
+    };
+}
+declare type CompilerErrorSource = es.Node | es.SourceLocation | {
+    line: number;
+    column: number;
+};
+export declare class CompilerError extends Error {
+    protected _loc?: es.SourceLocation;
+    /**
+     * 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;
+    set loc(value: CompilerErrorSource | undefined);
+    static from(error: unknown, source?: CompilerErrorSource): CompilerError;
+}
+export {};

package/dist/assertions.d.ts

@@ -0,0 +1,28 @@
+import { IValue } from "./types";
+import { LiteralValue, ObjectValue, StoreValue } from "./values";
+/** Asserts that `value` is a `LiteralValue` that contains a string */
+export declare function assertStringLiteral(value: IValue | undefined, name: string): asserts value is LiteralValue & {
+    data: string;
+};
+/** Asserts that `value` is a string literal that is part of a given set of `members`*/
+export declare function assertLiteralOneOf<T extends readonly string[]>(value: IValue | undefined, members: T, name: string): asserts value is LiteralValue & {
+    data: T[number];
+};
+/** Asserts that `value` is either a store or a literal */
+export declare function assertIsRuntimeValue(value: IValue | undefined, name: string): asserts value is LiteralValue | StoreValue;
+/** Asserts that `value` is an `ObjectValue` */
+export declare function assertIsObjectMacro(value: IValue | undefined, name: string): asserts value is ObjectValue;
+/** Asserts that `value` is an `ObjectValue` that has a length property */
+export declare function assertIsArrayMacro(value: IValue | undefined, name: string): asserts value is ObjectValue;
+/** Helper type used to describe the overloads of a macro function. See {@link assertObjectFields} */
+export declare type TOverloadDescriptor<K extends string> = Record<K, (string | IParameterDescriptor)[]>;
+/** Describes an object destructuring paremeter. Generally used with `assertObjectFields` */
+export interface IParameterDescriptor {
+    key: string;
+    name?: string;
+    default?: string;
+    /** Throw an error on invalid values */
+    validate?(value: IValue): void;
+}
+/** Asserts that all of the fields described are present on `value`*/
+export declare function assertObjectFields(value: ObjectValue, fields: (string | IParameterDescriptor)[]): (IValue | string)[];

package/dist/bin.cjs

@@ -43,29 +43,22 @@ yargs__default["default"](helpers.hideBin(process.argv))
         compactNames: argv["compact-names"],
     });
     const code = fs.readFileSync(path$1, "utf8");
-    const [output, error, [node]] = compiler.compile(code);
+    const [output, error] = compiler.compile(code);
     if (error) {
-        if (!(error instanceof index_cjs.CompilerError)) {
-            console.error(error);
+        if (!error.loc) {
+            console.log(error.inner ?? error);
             return;
         }
-        let start = error.loc;
-        let end = start;
-        if (node) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            start = node.loc.start;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            end = node.loc.end;
-        }
+        const { start, end } = error.loc;
         const lines = code.split("\n");
         console.log(chalk__default["default"].cyanBright([path.resolve(path$1), 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__default["default"].gray(`${n} | `.padStart(6, " "));
             console.log(head + cliHighlight.highlight(lines[i], { language: "js" }));
-            if (n === start.line) {
-                console.log(chalk__default["default"].red(" ".repeat(6 + start.column) + "^ " + error.message));
-            }
+            console.log(chalk__default["default"].red(" ".repeat(6 + start.column) + "^ " + error.message));
         }
         return;
     }

package/dist/{types/handlers → handlers}/CallExpression.d.ts

@@ -1,3 +1,4 @@
 import { IValue, THandler } from "../types";
 export declare const CallExpression: THandler<IValue | null>;
 export declare const NewExpression: THandler<IValue | null>;
+export declare const TaggedTemplateExpression: THandler<IValue | null>;

package/dist/handlers/SwitchStatement.d.ts

@@ -0,0 +1,2 @@
+import { THandler } from "../types";
+export declare const SwitchStatement: THandler<null>;

package/dist/{types/handlers → handlers}/index.d.ts

@@ -5,6 +5,7 @@ export * from "./OperationExpressions";
 export * from "./Identifier";
 export * from "./Statements";
 export * from "./IfStatement";
+export * from "./SwitchStatement";
 export * from "./WhileStatement";
 export * from "./ForStatement";
 export * from "./Function";