mevento 1.2.0 → 1.4.0

package/lib/mevento.d.ts

@@ -1,5 +1,50 @@
 import { Type } from "@angular/core";
-declare class Token {
+export declare class TokenType {
+    static id: number;
+    static comma: number;
+    static semi: number;
+    static numberConst: number;
+    static stringConst: number;
+    static equal: number;
+    static lparen: number;
+    static rparen: number;
+    static eol: number;
+    static eof: number;
+    static lbrace: number;
+    static rbrace: number;
+    static lbracket: number;
+    static rbracket: number;
+    static great: number;
+    static greatEq: number;
+    static less: number;
+    static lessEq: number;
+    static eqeq: number;
+    static IF: number;
+    static ELSE: number;
+    static TRUE: number;
+    static FALSE: number;
+    static NULL: number;
+    static not: number;
+    static notEq: number;
+    static and: number;
+    static or: number;
+    static plus: number;
+    static minus: number;
+    static div: number;
+    static mult: number;
+    static mod: number;
+    static invalid: number;
+    static colon: number;
+    static WHILE_TILL: number;
+    static FOR_LOOP: number;
+    static up: number;
+    static down: number;
+    static with: number;
+    static in: number;
+    static TILL: number;
+    static BREAK: number;
+}
+export declare class Token {
     type: number;
     value: any;
     line?: number;
@@ -8,96 +53,120 @@ declare class Token {
     static from(type: number, value: any): Token;
     toString(): string;
 }
+export declare class LexerDictionary {
+    lang: string;
+    keywords: {
+        [key: string]: string;
+    };
+    constructor(lang: string, keywords: {
+        [key: string]: string;
+    });
+}
 /**
  * Parser
  */
-declare abstract class AST {
+export declare abstract class AST {
     line?: number;
     col?: number;
     constructor(line?: number, col?: number);
     dump(): string;
 }
-declare class RootAST extends AST {
+export declare class RootAST extends AST {
     body: AST[];
     source: string;
     name: string;
     constructor(body: AST[], name: string, source: string);
     dump(): string;
 }
-declare class BlockStatementAST extends AST {
+export declare class BlockStatementAST extends AST {
     body: AST[];
     constructor(body: AST[], token: Token);
     toString(): string;
 }
-declare class IdentifierAST extends AST {
+export declare class IdentifierAST extends AST {
     value: string;
     constructor(token: Token);
     toString(): string;
 }
-declare class LiteralAST extends AST {
+export declare class LiteralAST extends AST {
     value: any;
     raw: string;
     constructor(token: Token, raw: string);
     toString(): string;
 }
-declare class AssignmentExpressionAST extends AST {
+export declare class AssignmentExpressionAST extends AST {
     identifier: AST;
     init: AST;
     constructor(identifier: AST, init: AST);
     toString(): string;
 }
-declare class ExpressionStatementAST extends AST {
+export declare class ExpressionStatementAST extends AST {
     expression: AST;
     constructor(expression: AST);
     toString(): string;
 }
-declare class CallExpressionAST extends AST {
+export declare class CallExpressionAST extends AST {
     callee: IdentifierAST;
     arguments: AST[];
     constructor(callee: IdentifierAST, ags: AST[]);
     toString(): string;
 }
-declare class BinaryExpressionAST extends AST {
+export declare class BinaryExpressionAST extends AST {
     left: AST;
     operation: Token;
     right: AST;
     constructor(left: AST, operation: Token, right: AST);
     toString(): string;
 }
-declare class UnaryExpressionAST extends AST {
+export declare class UnaryExpressionAST extends AST {
     operation: Token;
     argument: AST;
     constructor(operation: Token, argument: AST);
     toString(): string;
 }
-declare class IfStatementAST extends AST {
+export declare class IfStatementAST extends AST {
     test: AST;
     consequent: AST;
     alternate?: AST;
     constructor(test: AST, consequent: AST, alternate?: AST);
     toString(): string;
 }
-declare class LogicalExpressionAST extends AST {
+export declare class LogicalExpressionAST extends AST {
     left: AST;
     operator: Token;
     right: AST;
     constructor(left: AST, operator: Token, right: AST);
     toString(): string;
 }
-declare class IndexAccessorAST extends AST {
+export declare class IndexAccessorAST extends AST {
     owner: AST;
     key: AST;
     computed: boolean;
     constructor(owner: AST, key: AST, computed?: boolean);
     toString(): string;
 }
-declare class WhileLoopStatement extends AST {
+export declare class ObjectExpression extends AST {
+    properties: AST[];
+    constructor(props: AST[], startToken?: Token, endToken?: Token);
+    toString(): string;
+}
+export declare class ArrayExpression extends AST {
+    elements: AST[];
+    constructor(props: AST[], start?: AST, end?: AST);
+    toString(): string;
+}
+export declare class ObjectProperty extends AST {
+    key: AST;
+    value: AST;
+    constructor(key: AST, value: AST);
+}
+export declare class WhileLoopStatement extends AST {
     test: AST;
     body: AST;
     retain: boolean;
     constructor(test: AST, body: AST, startToken?: Token, endToken?: Token, retain?: boolean);
 }
-declare class ForLoopStatement extends AST {
+export declare class ForLoopStatement extends AST {
     init: AssignmentExpressionAST;
     test: AST;
     update: AST;
@@ -106,17 +175,22 @@ declare class ForLoopStatement extends AST {
     retain: boolean;
     constructor(init: AssignmentExpressionAST, test: AST, update: AST, direction: Token, body: AST, startToken?: Token, endToken?: Token, retain?: boolean);
 }
-declare class ForOfStatement extends AST {
+export declare class ForOfStatement extends AST {
     identifier: AST;
     collection: AST;
     body: AST;
     retain: boolean;
     constructor(identifier: AST, collection: AST, body: AST, startToken?: Token, endToken?: Token, retain?: boolean);
 }
-declare class BreakAST extends AST {
+export declare class TupleExpression extends AST {
+    first: AST;
+    second: AST;
+    constructor(first: AST, second: AST);
+}
+export declare class BreakAST extends AST {
     constructor(line?: number, col?: number);
 }
-declare class BreakBranch {
+export declare class BreakBranch {
 }
 declare type Func = (node: any) => any;
 declare abstract class ANodeVisitor {
@@ -126,10 +200,31 @@ declare abstract class ANodeVisitor {
     protected registerVisitor(type: Type<AST>, visitor: Func): void;
     abstract visit(node: AST): any;
 }
-declare abstract class NodeVisitor extends ANodeVisitor {
+export declare abstract class NodeVisitor extends ANodeVisitor {
+    constructor();
     visit(node: AST): any;
+    assignProperty(owner: any, property: any, value: any): any;
+    protected abstract visitRootAST(node: RootAST): any;
+    protected abstract visitBlockStatementAST(node: BlockStatementAST): any;
+    protected abstract visitIdentifierAST(node: IdentifierAST): any;
+    protected abstract visitLiteralAST(node: AST): any;
+    protected abstract visitAssignmentExpressionAST(node: AssignmentExpressionAST): any;
+    protected abstract visitExpressionStatementAST(node: ExpressionStatementAST): any;
+    protected abstract visitCallExpressionAST(node: CallExpressionAST): any;
+    protected abstract visitBinaryExpressionAST(node: BinaryExpressionAST): any;
+    protected abstract visitUnaryExpressionAST(node: UnaryExpressionAST): any;
+    protected abstract visitIfStatementAST(node: IfStatementAST): any;
+    protected abstract visitLogicalExpressionAST(node: LogicalExpressionAST): any;
+    protected abstract visitIndexAccessorAST(node: IndexAccessorAST): any;
+    protected abstract visitObjectProperty(node: AST): any;
+    protected abstract visitObjectExpression(ast: AST): any;
+    protected abstract visitArrayExpression(ast: AST): any;
+    protected abstract visitBreakAST(node: BreakAST): any;
+    protected abstract visitWhileLoopStatement(node: WhileLoopStatement): any;
+    protected abstract visitForLoopStatement(node: ForLoopStatement): any;
+    protected abstract visitForOfStatement(node: ForOfStatement): any;
 }
-declare type MEventoFBinding = (args: any[], vm: MEvento) => any;
+export declare type MEventoFBinding = (args: any[], vm: MEvento) => any;
 export declare class MEvento extends NodeVisitor {
     _memory: {
         [k: string]: any;
@@ -147,7 +242,6 @@ export declare class MEvento extends NodeVisitor {
     protected visitIdentifierAST(node: IdentifierAST): any;
     protected visitLiteralAST(node: AST): any;
     protected visitAssignmentExpressionAST(node: AssignmentExpressionAST): any;
-    assignProperty(owner: any, property: any, value: any): any;
     protected visitExpressionStatementAST(node: ExpressionStatementAST): any;
     protected visitCallExpressionAST(node: CallExpressionAST): any;
     protected visitBinaryExpressionAST(node: BinaryExpressionAST): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mevento",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "dependencies": {
     "tslib": "^2.0.3"
   },