mlogjs 0.1.11 → 0.2.2

package/dist/types/Compiler.d.ts

@@ -0,0 +1,18 @@
+import { es, IScope, IValue, THandler, TValueInstructions } from "./types";
+declare type THandlerMap = {
+    [k in es.Node["type"]]?: THandler<IValue | null>;
+};
+export declare class Compiler {
+    protected stackName?: string;
+    protected usingStack: boolean;
+    protected handlers: THandlerMap;
+    constructor(stackName?: string);
+    compile(script: string): [string, null, es.Node[]] | [null, Error, es.Node[]];
+    protected resolve(valueInst: TValueInstructions<IValue | null>): void;
+    protected serialize(resLines: TValueInstructions<IValue | null>): string;
+    protected parse(script: string): es.Node;
+    handle(scope: IScope, node: es.Node): TValueInstructions<IValue | null>;
+    handleEval(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>;
+}
+export {};

package/{build → dist/types}/Scope.d.ts

@@ -1,26 +1,23 @@
+import { StoreValue } from "./values";
 import { AddressResolver } from "./instructions";
 import { IFunctionValue, IInstruction, IScope, IValue } from "./types";
 export declare class Scope implements IScope {
-    parent: IScope;
-    name: string;
-    data: {
-        [k: string]: IValue;
-    };
+    parent: IScope | null;
     stacked: boolean;
     ntemp: number;
+    name: string;
     inst: IInstruction[];
+    data: Record<string, IValue | null>;
     break: AddressResolver;
     continue: AddressResolver;
     function: IFunctionValue;
-    constructor(values: {
-        [k: string]: IValue;
-    }, parent?: IScope, stacked?: boolean, ntemp?: number, name?: string, inst?: any[]);
+    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[]);
     copy(): IScope;
     createScope(): IScope;
     createFunction(name: string, stacked?: boolean): IScope;
     has(name: string): boolean;
     get(name: string): IValue;
-    set(name: string, value: IValue): IValue;
-    hardSet(name: string, value: IValue): IValue;
-    make(name: string, storeName: string): IValue;
+    set<T extends IValue>(name: string, value: T): T;
+    hardSet<T extends IValue>(name: string, value: T): T;
+    make(name: string, storeName: string): StoreValue;
 }

package/dist/types/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/handlers/BlockStatement.d.ts

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

package/dist/types/handlers/CallExpression.d.ts

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

package/dist/types/handlers/ForStatement.d.ts

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

package/dist/types/handlers/IfStatement.d.ts

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

package/dist/types/handlers/Program.d.ts

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

package/dist/types/handlers/Statements.d.ts

@@ -0,0 +1,5 @@
+import { IValue, THandler } from "../types";
+export declare const ExpressionStatement: THandler<IValue | null>;
+export declare const BreakStatement: THandler<null>;
+export declare const ContinueStatement: THandler<null>;
+export declare const ReturnStatement: THandler<IValue | null>;

package/dist/types/handlers/TemplateExpression.d.ts

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

package/dist/types/handlers/VariableDeclaration.d.ts

@@ -0,0 +1,3 @@
+import { THandler, IValue } from "../types";
+export declare const VariableDeclaration: THandler<null>;
+export declare const VariableDeclarator: THandler<IValue | null>;

package/dist/types/handlers/WhileStatement.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export declare const compile: (script: string) => [string, null, import("estree").Node[]] | [null, Error, import("estree").Node[]];

package/dist/types/initScope.d.ts

@@ -0,0 +1,2 @@
+import { Scope } from "./Scope";
+export declare function initScope(scope: Scope): void;

package/{build → dist/types}/instructions/AddressResolver.d.ts

@@ -1,5 +1,5 @@
 import { InstructionBase } from ".";
-import { IScope, IBindableValue } from "../types";
+import { IBindableValue, IScope } from "../types";
 export declare class AddressResolver extends InstructionBase {
     get hidden(): boolean;
     set hidden(value: boolean);

package/{build → dist/types}/instructions/InstructionBase.d.ts

@@ -3,8 +3,8 @@ export declare class InstructionBase implements IInstruction {
     private _hidden;
     get hidden(): boolean;
     set hidden(value: boolean);
-    args: (string | IValue)[];
-    constructor(...args: (string | IValue)[]);
+    args: (string | IValue | null)[];
+    constructor(...args: (string | IValue | null)[]);
     resolve(i: number): void;
     toString(): string;
 }

package/{build → dist/types}/instructions/JumpInstruction.d.ts

@@ -11,5 +11,5 @@ export declare enum EJumpKind {
     Always = "always"
 }
 export declare class JumpInstruction extends InstructionBase {
-    constructor(address: IBindableValue, kind: EJumpKind, left?: IValue, right?: IValue);
+    constructor(address: IBindableValue, kind: EJumpKind, left?: IValue | null, right?: IValue | null);
 }

package/{build → dist/types}/instructions/OperationInstruction.d.ts

@@ -1,5 +1,5 @@
 import { InstructionBase } from ".";
 import { IValue } from "../types";
 export declare class OperationInstruction extends InstructionBase {
-    constructor(kind: string, temp: IValue, left: IValue, right?: IValue);
+    constructor(kind: string, temp: IValue, left: IValue, right: IValue | null);
 }

package/dist/types/macros/Building.d.ts

@@ -0,0 +1,11 @@
+import { IScope } from "../types";
+import { ObjectValue } from "../values";
+export declare const itemNames: string[];
+export declare class Building extends ObjectValue {
+    name: string;
+    toString(): string;
+    constructor(scope: IScope, name: string);
+}
+export declare class BuildingBuilder extends ObjectValue {
+    constructor(scope: IScope);
+}

package/dist/types/macros/Function.d.ts

@@ -0,0 +1,12 @@
+import { IScope, IValue, TValueInstructions } from "../types";
+import { VoidValue } from "../values";
+declare type TFunction<T extends IValue | null> = (...args: IValue[]) => TValueInstructions<T>;
+export declare class MacroFunction<RT extends IValue | null = IValue> extends VoidValue {
+    macro: boolean;
+    constant: boolean;
+    fn: TFunction<RT>;
+    constructor(scope: IScope, fn: TFunction<RT>);
+    call(scope: IScope, args: IValue[]): TValueInstructions<RT>;
+    eval(scope: IScope): TValueInstructions;
+}
+export {};

package/{build/macros/Blocks.d.ts → dist/types/macros/Memory.d.ts}

@@ -1,5 +1,5 @@
 import { IScope } from "../types";
 import { ObjectValue } from "../values";
-export declare class BlockBuilder extends ObjectValue {
+export declare class MemoryBuilder extends ObjectValue {
     constructor(scope: IScope);
 }

package/dist/types/macros/Namespace.d.ts

@@ -0,0 +1,21 @@
+import { IScope } from "../types";
+import { ObjectValue } from "../values";
+interface NamespaceMacroOptions {
+    changeCasing?: boolean;
+}
+export declare class NamespaceMacro extends ObjectValue {
+    changeCasing: boolean;
+    constructor(scope: IScope, { changeCasing }?: NamespaceMacroOptions);
+}
+export declare class VarsNamespace extends NamespaceMacro {
+    constructor(scope: IScope);
+}
+export declare class UCommandsNamespace extends NamespaceMacro {
+    constructor(scope: IScope);
+}
+export declare class Unit extends ObjectValue {
+    name: string;
+    constructor(scope: IScope, name: string);
+    toString(): string;
+}
+export {};

package/{build/macros/Draw.d.ts → dist/types/macros/Other.d.ts}

@@ -1,5 +1,5 @@
 import { IScope } from "../types";
 import { MacroFunction } from "./Function";
-export declare class Draw extends MacroFunction {
+export declare class Concat extends MacroFunction {
     constructor(scope: IScope);
 }

package/dist/types/macros/RawValue.d.ts

@@ -0,0 +1,5 @@
+import { IScope } from "../types";
+import { MacroFunction } from "./Function";
+export declare class RawValueMacro extends MacroFunction {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Control.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Control extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Draw.d.ts

@@ -0,0 +1,5 @@
+import { IScope } from "../../types";
+import { MacroFunction } from "../Function";
+export declare class Draw extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/DrawFlush.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class DrawFlush extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/GetLink.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class GetLink extends MacroFunction {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Lookup.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Lookup extends MacroFunction {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Print.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Print extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/PrintFlush.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class PrintFlush extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Radar.d.ts

@@ -0,0 +1,7 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare const validRadarFilters: string[];
+export declare const validRadarSorts: string[];
+export declare class Radar extends MacroFunction {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Sensor.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Sensor extends MacroFunction {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/UnitBind.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class UnitBind extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/UnitControl.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope, IValue } from "../../types";
+export declare class UnitControl extends MacroFunction<IValue | null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/UnitLocate.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class UnitLocate extends MacroFunction {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/UnitRadar.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class UnitRadar extends MacroFunction {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Wait.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Wait extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./Draw";
+export * from "./Print";
+export * from "./PrintFlush";
+export * from "./DrawFlush";
+export * from "./GetLink";
+export * from "./Control";
+export { Radar } from "./Radar";
+export * from "./Sensor";
+export * from "./Wait";
+export * from "./Lookup";
+export * from "./UnitBind";
+export * from "./UnitControl";
+export * from "./UnitRadar";
+export * from "./UnitLocate";

package/dist/types/macros/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Function";
+export * from "./Math";
+export * from "./Other";
+export * as commands from "./commands";
+export * from "./Memory";
+export { BuildingBuilder } from "./Building";
+export { NamespaceMacro, VarsNamespace } from "./Namespace";

package/{build → dist/types}/operators.d.ts

@@ -20,3 +20,6 @@ export declare const singleOperators: readonly ["!", "u+", "u-", "delete", "type
 export declare type SingleOperator = typeof singleOperators[number];
 export declare const operators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "=", "!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
 export declare type Operator = typeof operators[number];
+export declare const operatorMap: {
+    [k in Exclude<BinaryOperator, "instanceof" | "in"> | Extract<LogicalOperator, "&&" | "||">]: string;
+};

package/dist/types/types.d.ts

@@ -0,0 +1,100 @@
+export * as es from "estree";
+import { Compiler } from "./Compiler";
+import { AddressResolver } from "./instructions";
+import { MacroFunction } from "./macros";
+import { LeftRightOperator, UnaryOperator, UpdateOperator } from "./operators";
+import { StoreValue } from "./values";
+export interface IInstruction {
+    hidden: boolean;
+    resolve(i: number): void;
+}
+export declare type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, arg: any) => TValueInstructions<T>;
+export interface IScope {
+    parent: IScope | null;
+    data: {};
+    name: string;
+    inst: IInstruction[];
+    break: AddressResolver;
+    continue: AddressResolver;
+    function: IFunctionValue;
+    ntemp: number;
+    createScope(): IScope;
+    createFunction(name: string, stacked?: boolean): IScope;
+    has(name: string): boolean;
+    get(name: string): IValue;
+    set<T extends IValue>(name: string, value: T): T;
+    hardSet<T extends IValue>(name: string, value: T): T;
+    make(name: string, storeName: string): StoreValue;
+    copy(): IScope;
+}
+export interface IValue {
+    scope: IScope;
+    constant: boolean;
+    macro: boolean;
+    eval(scope: IScope): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
+    get(scope: IScope, name: IValue): TValueInstructions;
+    "!"(scope: IScope): TValueInstructions;
+    "u+"(scope: IScope): TValueInstructions;
+    "u-"(scope: IScope): TValueInstructions;
+    "delete"(scope: IScope): TValueInstructions;
+    "typeof"(scope: IScope): TValueInstructions;
+    "void"(scope: IScope): TValueInstructions;
+    "~"(scope: IScope): TValueInstructions;
+    "++"(scope: IScope, prefix: boolean): TValueInstructions;
+    "--"(scope: IScope, prefix: boolean): TValueInstructions;
+    "*"(scope: IScope, value: IValue): TValueInstructions;
+    "**"(scope: IScope, value: IValue): TValueInstructions;
+    "+"(scope: IScope, value: IValue): TValueInstructions;
+    "-"(scope: IScope, value: IValue): TValueInstructions;
+    "/"(scope: IScope, value: IValue): TValueInstructions;
+    "%"(scope: IScope, value: IValue): TValueInstructions;
+    "!="(scope: IScope, value: IValue): TValueInstructions;
+    "!=="(scope: IScope, value: IValue): TValueInstructions;
+    "<"(scope: IScope, value: IValue): TValueInstructions;
+    "<="(scope: IScope, value: IValue): TValueInstructions;
+    "=="(scope: IScope, value: IValue): TValueInstructions;
+    "==="(scope: IScope, value: IValue): TValueInstructions;
+    ">"(scope: IScope, value: IValue): TValueInstructions;
+    ">="(scope: IScope, value: IValue): TValueInstructions;
+    "&"(scope: IScope, value: IValue): TValueInstructions;
+    "<<"(scope: IScope, value: IValue): TValueInstructions;
+    ">>"(scope: IScope, value: IValue): TValueInstructions;
+    ">>>"(scope: IScope, value: IValue): TValueInstructions;
+    "^"(scope: IScope, value: IValue): TValueInstructions;
+    "|"(scope: IScope, value: IValue): TValueInstructions;
+    instanceof(scope: IScope, value: IValue): TValueInstructions;
+    in(scope: IScope, value: IValue): TValueInstructions;
+    "&&"(scope: IScope, value: IValue): TValueInstructions;
+    "??"(scope: IScope, value: IValue): TValueInstructions;
+    "||"(scope: IScope, value: IValue): TValueInstructions;
+    "%="(scope: IScope, value: IValue): TValueInstructions;
+    "&="(scope: IScope, value: IValue): TValueInstructions;
+    "*="(scope: IScope, value: IValue): TValueInstructions;
+    "**="(scope: IScope, value: IValue): TValueInstructions;
+    "+="(scope: IScope, value: IValue): TValueInstructions;
+    "-="(scope: IScope, value: IValue): TValueInstructions;
+    "/="(scope: IScope, value: IValue): TValueInstructions;
+    "&&="(scope: IScope, value: IValue): TValueInstructions;
+    "||="(scope: IScope, value: IValue): TValueInstructions;
+    "<<="(scope: IScope, value: IValue): TValueInstructions;
+    ">>="(scope: IScope, value: IValue): TValueInstructions;
+    ">>>="(scope: IScope, value: IValue): TValueInstructions;
+    "^="(scope: IScope, value: IValue): TValueInstructions;
+    "|="(scope: IScope, value: IValue): TValueInstructions;
+    "="(scope: IScope, value: IValue): TValueInstructions;
+}
+export declare type TLiteral = string | number;
+export interface IBindableValue extends IValue {
+    data: TLiteral;
+}
+export interface IFunctionValue extends IValue {
+    return(scope: IScope, argument: IValue): TValueInstructions<IValue | null>;
+}
+export declare type TValueInstructions<Content extends IValue | null = IValue> = [
+    Content,
+    IInstruction[]
+];
+export declare type TOperatorMacroMap = {
+    [K in UnaryOperator | UpdateOperator | LeftRightOperator as `$${K}`]?: MacroFunction;
+};

package/{build → dist/types}/utils.d.ts

@@ -1,2 +1,3 @@
 import { es } from "./types";
 export declare function nodeName(node: es.Node): string;
+export declare function camelToDashCase(name: string): string;

package/{build → dist/types}/values/FunctionValue.d.ts

@@ -29,6 +29,6 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     private inlineReturn;
     private inlineCall;
     call(scope: IScope, args: IValue[]): TValueInstructions;
-    return(scope: IScope, arg: IValue): TValueInstructions;
+    return(scope: IScope, arg: IValue): TValueInstructions<IValue | null>;
     eval(scope: IScope): TValueInstructions;
 }

package/dist/types/values/ObjectValue.d.ts

@@ -0,0 +1,19 @@
+import { MacroFunction } from "../macros";
+import { IScope, IValue, TOperatorMacroMap, TValueInstructions } from "../types";
+import { LiteralValue } from "./LiteralValue";
+import { VoidValue } from "./VoidValue";
+export interface IObjectValueData extends TOperatorMacroMap {
+    [k: string]: IValue | undefined;
+    $get?: MacroFunction<IValue>;
+    $eval?: MacroFunction<IValue>;
+}
+export declare class ObjectValue extends VoidValue {
+    constant: boolean;
+    macro: boolean;
+    data: IObjectValueData;
+    constructor(scope: IScope, data?: IObjectValueData);
+    typeof(scope: IScope): TValueInstructions;
+    get(scope: IScope, key: LiteralValue): TValueInstructions;
+    eval(scope: IScope): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
+}

package/{build → dist/types}/values/VoidValue.d.ts

@@ -5,7 +5,9 @@ export declare class VoidValue implements IValue {
     macro: boolean;
     constructor(scope: IScope);
     eval(scope: IScope): TValueInstructions;
-    call(scope: IScope, args: IValue[]): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
     get(scope: IScope, name: IValue): TValueInstructions;
     toString(): string;
 }
+export interface VoidValue extends IValue {
+}

package/{docs → doc}/README.md

@@ -1,17 +1,9 @@
-# MlogJS
-
-MlogJS is a compiler that allows users to compile complex JavaScript programs into Mindustry Logic Code.
-
-## Discord
-
-You can join the Discord server for more information and for help.
-
-<iframe src="https://discord.com/widget?id=841105039211888710&theme=dark" width="350" height="300" allowtransparency="true" frameborder="0" sandbox="allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts"></iframe>
-
-## Getting started!
-
-```
-npm i mlogjs -g
-```
-
-After installing the package from NPM, read the [docs](https://str1z.github.io/mlogjs).
+# MlogJS
+
+MlogJS is a compiler that allows users to compile complex JavaScript programs into Mindustry Logic Code.
+
+## Discord
+
+You can join the Discord server for more information and for help.
+
+<iframe src="https://discord.com/widget?id=841105039211888710&theme=dark" width="350" height="300" allowtransparency="true" frameborder="0" sandbox="allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts"></iframe>