mevento 1.0.0 → 1.2.2

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,89 +53,145 @@ 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;
 }
+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);
+}
+export declare class ForLoopStatement extends AST {
+    init: AssignmentExpressionAST;
+    test: AST;
+    update: AST;
+    direction: Token;
+    body: AST;
+    retain: boolean;
+    constructor(init: AssignmentExpressionAST, test: AST, update: AST, direction: Token, body: AST, startToken?: Token, endToken?: Token, retain?: boolean);
+}
+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);
+}
+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);
+}
+export declare class BreakBranch {
+}
 declare type Func = (node: any) => any;
 declare abstract class ANodeVisitor {
     protected _nodesVisitors: {
@@ -99,20 +200,22 @@ 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 {
     visit(node: AST): 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;
     };
+    debug: boolean;
     private static _globalFunctionsRegistry;
     private static _cache;
     _functionsRegistry: {
         [k: string]: MEventoFBinding;
     };
     constructor();
+    protected log(message: any): void;
     protected visitRootAST(node: RootAST): any;
     protected visitBlockStatementAST(node: BlockStatementAST): any;
     protected visitIdentifierAST(node: IdentifierAST): any;
@@ -129,6 +232,11 @@ export declare class MEvento extends NodeVisitor {
     protected visitObjectProperty(node: AST): any;
     protected visitObjectExpression(ast: AST): any;
     protected visitArrayExpression(ast: AST): any;
+    protected visitBreakAST(node: BreakAST): BreakBranch;
+    protected visitWhileLoopStatement(node: WhileLoopStatement): any;
+    protected visitForLoopStatement(node: ForLoopStatement): any;
+    protected visitForOfStatement(node: ForOfStatement): any;
+    protected _declareForIdentifier(node: AST, value: any): any;
     resolveArguments(args: AST[]): any;
     registerFunction(id: string, fn: MEventoFBinding): void;
     unregisterFunction(id: string): void;
@@ -158,6 +266,9 @@ export declare class MEventoAsync extends MEvento {
     protected visitObjectProperty(node: AST): Promise<void>;
     protected visitObjectExpression(ast: AST): Promise<any>;
     protected visitArrayExpression(ast: AST): Promise<any[]>;
+    protected visitWhileLoopStatement(node: WhileLoopStatement): Promise<any[] | undefined>;
+    protected visitForLoopStatement(node: ForLoopStatement): Promise<any[] | undefined>;
+    protected visitForOfStatement(node: ForOfStatement): Promise<any[] | undefined>;
     resolveArgumentsAsync(args: AST[]): Promise<any[]>;
     registerFunction(id: string, fn: MEventoFBinding): void;
     unregisterFunction(id: string): void;

package/package.json

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