mevento 3.0.0 → 3.0.1

package/dist/cjs/index.d.ts

@@ -0,0 +1,349 @@
+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;
+    static CONTINUE: number;
+    static nullity: number;
+    static RETURN: number;
+}
+declare class Token {
+    type: number;
+    value: any;
+    line?: number;
+    col?: number;
+    constructor(type: number, value: any, line?: number, col?: number);
+    static from(type: number, value: any): Token;
+    toString(): string;
+}
+declare class LexerDictionary {
+    lang: string;
+    keywords: {
+        [key: string]: string;
+    };
+    constructor(lang: string, keywords: {
+        [key: string]: string;
+    });
+}
+/**
+ * Parser
+ */
+declare abstract class AST {
+    line?: number;
+    col?: number;
+    constructor(line?: number, col?: number);
+    dump(): string;
+}
+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 {
+    body: AST[];
+    constructor(body: AST[], token: Token);
+    toString(): string;
+}
+declare class IdentifierAST extends AST {
+    value: string;
+    constructor(token: Token);
+    toString(): string;
+}
+declare class LiteralAST extends AST {
+    value: any;
+    raw: string;
+    constructor(token: Token, raw: string);
+    toString(): string;
+}
+declare class AssignmentExpressionAST extends AST {
+    identifier: AST;
+    init: AST;
+    constructor(identifier: AST, init: AST);
+    toString(): string;
+}
+declare class ExpressionStatementAST extends AST {
+    expression: AST;
+    constructor(expression: AST);
+    toString(): string;
+}
+declare class CallExpressionAST extends AST {
+    callee: IdentifierAST;
+    arguments: AST[];
+    constructor(callee: IdentifierAST, ags: AST[]);
+    toString(): string;
+}
+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 {
+    operation: Token;
+    argument: AST;
+    constructor(operation: Token, argument: AST);
+    toString(): string;
+}
+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 {
+    left: AST;
+    operator: Token;
+    right: AST;
+    constructor(left: AST, operator: Token, right: AST);
+    toString(): string;
+}
+declare class IndexAccessorAST extends AST {
+    owner: AST;
+    key: AST;
+    computed: boolean;
+    constructor(owner: AST, key: AST, computed?: boolean);
+    toString(): string;
+}
+declare class ObjectExpression extends AST {
+    properties: AST[];
+    constructor(props: AST[], startToken?: Token, endToken?: Token);
+    toString(): string;
+}
+declare class ArrayExpression extends AST {
+    elements: AST[];
+    constructor(props: AST[], start?: AST, end?: AST);
+    toString(): string;
+}
+declare class ObjectProperty extends AST {
+    key: AST;
+    value: AST;
+    constructor(key: AST, value: AST);
+}
+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 {
+    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);
+}
+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 TupleExpression extends AST {
+    first: AST;
+    second: AST;
+    constructor(first: AST, second: AST);
+}
+declare class BreakAST extends AST {
+    constructor(line?: number, col?: number);
+}
+declare class ReturnAST extends AST {
+    value?: AST;
+    constructor(value?: AST, line?: number, col?: number);
+}
+declare class ContinueAST extends AST {
+    constructor(line?: number, col?: number);
+}
+declare class LoopControl {
+}
+declare class BreakBranch extends LoopControl {
+}
+declare class ContinueBranch extends LoopControl {
+}
+declare class ReturnBranch {
+    value: any;
+    constructor(value: any);
+}
+type Func = (node: any) => any;
+declare abstract class ANodeVisitor {
+    protected _nodesVisitors: {
+        [k: string]: Func;
+    };
+    protected registerVisitor(type: any, visitor: Func): void;
+    abstract visit(node: AST): any;
+}
+declare abstract class NodeVisitor extends ANodeVisitor {
+    constructor();
+    visit(node: AST): any;
+    protected 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;
+    protected abstract visitContinueAST(node: ContinueAST): any;
+    protected abstract visitReturnAST(node: ReturnAST): any;
+}
+declare class MEventScope {
+    name: string;
+    parent?: MEventScope;
+    memory: {
+        [k: string]: any;
+    };
+    constructor(name: string, memory: {
+        [k: string]: any;
+    }, parent?: MEventScope);
+    resolve(key: string): any;
+    change(key: string, value: any, declare?: boolean): boolean;
+}
+type MEventoFBinding = (args: any[], vm: MEvento) => any;
+declare class MEvento extends NodeVisitor {
+    rootScope: MEventScope;
+    protected currentScope?: MEventScope;
+    debug: boolean;
+    private static _globalFunctionsRegistry;
+    private static _cache;
+    protected _functionsRegistry: {
+        [k: string]: MEventoFBinding;
+    };
+    protected _functionResolver?: (name: string) => MEventoFBinding | undefined;
+    constructor();
+    protected resolve(name: string): any;
+    protected changeVariable(name: string, value: any): any;
+    protected pushScope(name: string): void;
+    protected popScope(): void;
+    protected log(message: any): void;
+    protected visitRootAST(node: RootAST): any;
+    protected visitBlockStatementAST(node: BlockStatementAST): any;
+    protected visitIdentifierAST(node: IdentifierAST): any;
+    protected visitLiteralAST(node: AST): any;
+    protected visitAssignmentExpressionAST(node: AssignmentExpressionAST): any;
+    protected visitExpressionStatementAST(node: ExpressionStatementAST): any;
+    protected visitCallExpressionAST(node: CallExpressionAST): any;
+    protected visitBinaryExpressionAST(node: BinaryExpressionAST): any;
+    protected visitUnaryExpressionAST(node: UnaryExpressionAST): any;
+    protected visitIfStatementAST(node: IfStatementAST): any;
+    protected visitLogicalExpressionAST(node: LogicalExpressionAST): any;
+    protected visitIndexAccessorAST(node: IndexAccessorAST): any;
+    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 visitContinueAST(node: ContinueAST): ContinueBranch;
+    protected visitReturnAST(node: ReturnAST): any;
+    protected _declareForIdentifier(node: AST, value: any): any;
+    resolveArguments(args: AST[]): any;
+    setFunctionResolver(resolver: (name: string) => MEventoFBinding | undefined): void;
+    resolveFunction(name: string): MEventoFBinding | undefined;
+    registerFunction(id: string, fn: MEventoFBinding): void;
+    unregisterFunction(id: string): void;
+    execute(source: string, cache?: boolean, input?: {
+        [k: string]: any;
+    }): any;
+    static compile(source: string, cache?: boolean): AST;
+    static register(id: string, fn: MEventoFBinding): void;
+    static unregister(id: string): void;
+    static run(source: string, cache?: boolean, input?: {
+        [k: string]: any;
+    }): any;
+    static newInstance(): MEvento;
+    clone(): MEvento;
+    newAsyncInstance(): MEventoAsync;
+}
+declare class MEventoAsync extends MEvento {
+    constructor();
+    protected visitRootAST(node: RootAST): Promise<any>;
+    protected visitBlockStatementAST(node: BlockStatementAST): Promise<any>;
+    protected visitIdentifierAST(node: AST): Promise<any>;
+    protected visitLiteralAST(node: LiteralAST): Promise<any>;
+    protected visitAssignmentExpressionAST(node: AssignmentExpressionAST): Promise<any>;
+    protected visitExpressionStatementAST(node: ExpressionStatementAST): Promise<any>;
+    protected visitCallExpressionAST(node: CallExpressionAST): Promise<any>;
+    protected visitBinaryExpressionAST(node: BinaryExpressionAST): Promise<string | number | boolean>;
+    protected visitUnaryExpressionAST(node: UnaryExpressionAST): Promise<number | boolean>;
+    protected visitIfStatementAST(node: IfStatementAST): Promise<any>;
+    protected visitLogicalExpressionAST(node: LogicalExpressionAST): Promise<any>;
+    protected visitIndexAccessorAST(node: IndexAccessorAST): Promise<any>;
+    protected visitObjectProperty(node: AST): Promise<void>;
+    protected visitObjectExpression(ast: AST): Promise<any>;
+    protected visitArrayExpression(ast: AST): Promise<any[]>;
+    protected visitWhileLoopStatement(node: WhileLoopStatement): Promise<any[] | ReturnBranch>;
+    protected visitForLoopStatement(node: ForLoopStatement): Promise<any[] | ReturnBranch>;
+    protected visitForOfStatement(node: ForOfStatement): Promise<any[] | ReturnBranch>;
+    protected visitReturnAST(node: ReturnAST): Promise<any>;
+    resolveArgumentsAsync(args: AST[]): Promise<any[]>;
+    registerFunction(id: string, fn: MEventoFBinding): void;
+    unregisterFunction(id: string): void;
+    execute(source: string, cache?: boolean, input?: {
+        [k: string]: any;
+    }): Promise<any>;
+    static run(source: string, cache?: boolean, input?: {
+        [k: string]: any;
+    }): Promise<any>;
+    static newInstance(): MEventoAsync;
+    clone(): MEventoAsync;
+}
+
+export { AST, ArrayExpression, AssignmentExpressionAST, BinaryExpressionAST, BlockStatementAST, BreakAST, BreakBranch, CallExpressionAST, ContinueAST, ContinueBranch, ExpressionStatementAST, ForLoopStatement, ForOfStatement, IdentifierAST, IfStatementAST, IndexAccessorAST, LexerDictionary, LiteralAST, LogicalExpressionAST, LoopControl, MEventScope, MEvento, MEventoAsync, type MEventoFBinding, NodeVisitor, ObjectExpression, ObjectProperty, ReturnAST, ReturnBranch, RootAST, Token, TokenType, TupleExpression, UnaryExpressionAST, WhileLoopStatement };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mevento",
-    "version": "3.0.0",
+    "version": "3.0.1",
     "main": "dist/cjs/index.js",  
     "module": "dist/esm/index.js", 
     "types": "dist/esm/index.d.ts",