vsn 0.1.149 → 1.0.1

package/src/AST/ForStatementNode.ts

@@ -1,59 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, TokenType, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-import {LiteralNode} from "./LiteralNode";
-import {RootScopeMemberNode} from "./RootScopeMemberNode";
-import {ScopeMemberNode} from "./ScopeMemberNode";
-
-export class ForStatementNode extends Node implements TreeNode {
-    constructor(
-        public readonly variable: LiteralNode<string>,
-        public readonly list: RootScopeMemberNode | ScopeMemberNode,
-        public readonly block: RootScopeMemberNode | ScopeMemberNode,
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.variable,
-            this.list,
-            this.block
-        ];
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const variable: string = await this.variable.evaluate(scope, dom, tag);
-        const list: any[] = await this.list.evaluate(scope, dom, tag);
-        for (let i = 0;i < list.length; i++) {
-            scope.set(variable, list[i]);
-            await this.block.evaluate(scope, dom, tag);
-        }
-
-        return null;
-    }
-
-    public static parse(lastNode, token, tokens: Token[]): ForStatementNode {
-        if (tokens[1].type !== TokenType.L_PAREN) {
-            throw SyntaxError('Syntax error: Missing (');
-        }
-        if (tokens[3].type !== TokenType.OF) {
-            throw SyntaxError('Syntax error: Missing of');
-        }
-
-        tokens.splice(0, 1); // consume for
-        const loopDef: Token[] = Tree.getNextStatementTokens(tokens);
-        const variableName: Token = loopDef.splice(0, 1)[0];
-        loopDef.splice(0, 1); // consume of
-        const list: TreeNode = Tree.processTokens(loopDef);
-        const block: TreeNode = Tree.processTokens(Tree.getBlockTokens(tokens, null)[0]);
-
-        return new ForStatementNode(
-            new LiteralNode<string>(variableName.value),
-            list as any,
-            block as any
-        );
-    }
-}

package/src/AST/FunctionArgumentNode.ts

@@ -1,27 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {TreeNode} from "../AST";
-import {Node} from "./Node";
-
-export class FunctionArgumentNode<T = any> extends Node implements TreeNode {
-    constructor(
-        protected args: Node[]
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            ...(this.args as Node[])
-        ]
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const values: any[] = [];
-        for (const arg of this.args) {
-            values.push(await arg.evaluate(scope, dom, tag));
-        }
-        return values;
-    }
-}

package/src/AST/FunctionCallNode.ts

@@ -1,93 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {TreeNode} from "../AST";
-import {Node} from "./Node";
-import {FunctionArgumentNode} from "./FunctionArgumentNode";
-import {ScopeMemberNode} from "./ScopeMemberNode";
-import {FunctionNode} from "./FunctionNode";
-import {ElementQueryNode} from "./ElementQueryNode";
-
-export class FunctionCallNode<T = any> extends Node implements TreeNode {
-    constructor(
-        public readonly fnc: TreeNode<(...args: any[]) => any>,
-        public readonly args: FunctionArgumentNode<any[]>
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.fnc as Node,
-            this.args as Node
-        ]
-    }
-
-    protected async callFunction(func, functionScope, dom, tag, ...values): Promise<[any, boolean]> {
-        if (func instanceof FunctionNode) {
-            const r = await (await func.evaluate(functionScope, dom, tag) as any)(...values);
-            await func.collectGarbage();
-            return [r, true];
-        } else if (typeof func === 'function') {
-            return [func.call(functionScope.wrapped || functionScope, ...values), true];
-        }
-        return [null, false];
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        let tags: Tag[] = [];
-        let functionScope: Scope = scope;
-        if (this.fnc instanceof ScopeMemberNode) {
-            if (this.fnc.scope instanceof ElementQueryNode) {
-                const _tags = await this.fnc.scope.evaluate(scope, dom, tag);
-                if (_tags instanceof Array) {
-                    tags = _tags;
-                } else if (_tags instanceof Tag) {
-                    tags = [_tags];
-                    functionScope = _tags.scope;
-                } else {
-                    throw new Error('Invalid element query result');
-                }
-            } else {
-                functionScope = await this.fnc.scope.evaluate(scope, dom, tag);
-            }
-        }
-
-        if (tags.length === 0)
-            tags.push(tag);
-
-        const values = await this.args.evaluate(scope, dom, tag);
-        const functionName = await (this.fnc as any).name.evaluate(scope, dom, tag);
-        const returnValues = [];
-        let calls = 0;
-        let func;
-        let _functionScope: Scope = functionScope;
-
-        for (const _tag of tags) {
-            if (_tag && _tag.scope.has(functionName)) {
-                func = _tag.scope.get(functionName);
-                _functionScope = _tag.scope;
-            } else if (_functionScope instanceof Scope && _functionScope.has(functionName)) {
-                func = _functionScope.get(functionName);
-            } else {
-                func = await this.fnc.evaluate(scope, dom, _tag);
-            }
-
-            const [result, success] = await this.callFunction(func, _functionScope, dom, _tag, ...values);
-            if (success) {
-                returnValues.push(result);
-                calls++;
-            } else {
-                console.warn(`Function ${functionName} was not found in current scope.`);
-            }
-        }
-
-        if (calls === 1) {
-            return returnValues[0];
-        } else if (calls === 0) {
-            throw new Error(`Function ${functionName} not found`);
-        } else {
-            return returnValues;
-        }
-    }
-}

package/src/AST/FunctionNode.ts

@@ -1,82 +0,0 @@
-import {FunctionScope, Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-import {BlockNode} from "./BlockNode";
-
-export class FunctionNode extends Node implements TreeNode {
-    protected requiresPrep: boolean = true;
-    protected garbage: FunctionScope[] = [];
-
-    constructor(
-        public readonly name: string,
-        public readonly args: string[],
-        public readonly block: BlockNode
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.block
-        ];
-    }
-
-    public async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta?: any): Promise<void> {
-        // if (meta?.ClassNode) {
-        //     // Set on object instance
-        //     if (tag && tag.scope.has('this')) {
-        //         tag.scope.get('this').set(this.name, this);
-        //     }
-        // } else {
-        //     scope.set(this.name, this);
-        // }
-        scope.set(this.name, this);
-        await super.prepare(scope, dom, tag, meta);
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        return await this.getFunction(scope, dom, tag);
-    }
-
-    public async collectGarbage() {
-        for (const f of this.garbage) {
-            DOM.instance.addGarbage(f);
-        }
-        this.garbage.length = 0;
-    }
-
-    public async getFunction(scope: Scope, dom: DOM, tag: Tag = null, createFunctionScope: boolean = true) {
-        const self = this;
-        return async (...args) => {
-            let functionScope;
-            if (createFunctionScope && !(scope instanceof FunctionScope)) {
-                functionScope = new FunctionScope(scope);
-                functionScope.set('this', scope);
-                self.garbage.push(functionScope);
-            } else {
-                functionScope = scope;
-            }
-
-            for (const arg of this.args) {
-                functionScope.set(arg, args.shift());
-            }
-            return await this.block.evaluate(functionScope, dom, tag);
-        }
-    }
-
-    public static parse<T = FunctionNode>(lastNode, token, tokens: Token[], cls: any = FunctionNode): T {
-        tokens.shift(); // skip 'func'
-        const name = tokens.shift();
-        const modifiers = this.moveModifiers(tokens);
-        const argTokens = Tree.getBlockTokens(tokens);
-        const funcArgs: string[] = [];
-        for (const t of argTokens) {
-            funcArgs.push(t[0].value);
-        }
-        const block = Tree.processTokens(Tree.getNextStatementTokens(tokens, true, true));
-        this.moveModifiers(modifiers, tokens);
-        return new cls(name.value, funcArgs, block);
-    }
-}

package/src/AST/IfStatementNode.ts

@@ -1,67 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, TokenType, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-import {ConditionalNode} from "./ConditionalNode";
-import {LiteralNode} from "./LiteralNode";
-
-export class IfStatementNode extends Node implements TreeNode {
-    constructor(
-        protected nodes: ConditionalNode[]
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            ...(this.nodes as Node[])
-        ]
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        for (const condition of this.nodes) {
-            const uno: boolean = await condition.evaluate(scope, dom, tag);
-            if (uno) {
-                return await condition.block.evaluate(scope, dom, tag);
-            }
-        }
-    }
-
-    public static parseConditional(tokens: Token[]): ConditionalNode {
-        if ([
-            TokenType.IF,
-            TokenType.ELSE_IF
-        ].indexOf(tokens[0].type) === -1)  {
-            throw SyntaxError('Invalid Syntax');
-        }
-
-        tokens.splice(0, 1); // consume if and else if
-        return new ConditionalNode(
-            Tree.processTokens(Tree.getBlockTokens(tokens, null)[0]),
-            Tree.processTokens(Tree.getBlockTokens(tokens, null)[0])
-        );
-    }
-
-    public static parse(lastNode, token, tokens: Token[]): IfStatementNode {
-        if (tokens[1].type !== TokenType.L_PAREN) {
-            throw SyntaxError('If statement needs to be followed by a condition encased in parenthesis.');
-        }
-        const nodes: ConditionalNode[] = [];
-        nodes.push(IfStatementNode.parseConditional(tokens));
-
-        while(tokens.length > 0 && TokenType.ELSE_IF === tokens[0].type) {
-            nodes.push(IfStatementNode.parseConditional(tokens));
-        }
-
-        if (tokens.length > 0 && TokenType.ELSE === tokens[0].type) {
-            tokens.splice(0, 1); // Consume else
-            nodes.push(new ConditionalNode(
-                new LiteralNode(true),
-                Tree.processTokens(Tree.getBlockTokens(tokens, null)[0])
-            ))
-        }
-
-        return new IfStatementNode(nodes);
-    }
-}

package/src/AST/InNode.ts

@@ -1,46 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, TokenType, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-
-export class InNode extends Node implements TreeNode {
-    constructor(
-        public readonly left: TreeNode,
-        public readonly right: TreeNode,
-        public readonly flip: boolean = false
-    ) {
-        super();
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const toCheck = await this.left.evaluate(scope, dom, tag);
-        const array = await this.right.evaluate(scope, dom, tag);
-
-        let inArray = array.indexOf(toCheck) > -1;
-        if (this.flip)
-            inArray = !inArray;
-        return inArray;
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.left as Node,
-            this.right as Node
-        ];
-    }
-
-    public static match(tokens: Token[]): boolean {
-        return tokens[0].type === TokenType.IN || (tokens[0].type === TokenType.NOT && tokens[1].type === TokenType.IN);
-    }
-
-    public static parse(lastNode, token, tokens: Token[]) {
-        const flip: boolean = tokens[0].type === TokenType.NOT;
-        if (flip)
-            tokens.splice(0, 1); // consume not
-        tokens.splice(0, 1); // consume in
-
-        const containedTokens = Tree.getNextStatementTokens(tokens, false, false, true);
-        return new InNode(lastNode, Tree.processTokens(containedTokens), flip);
-    }
-}

package/src/AST/IndexNode.ts

@@ -1,64 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, TokenType, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-
-export class IndexNode extends Node implements TreeNode {
-    constructor(
-        public readonly object: Node,
-        public readonly index: Node,
-        public readonly indexTwo: Node = null
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        const children = [
-            this.object,
-            this.index
-        ];
-        if (this.indexTwo)
-            children.push(this.indexTwo);
-
-        return children;
-    }
-
-    public negativeIndex(obj: any[], index: number | string): number | string {
-        if (Number.isFinite(index) && index < 0)
-            return obj.length + (index as number);
-        return index;
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const obj = await this.object.evaluate(scope, dom, tag);
-        const index: string | number = this.negativeIndex(obj, await this.index.evaluate(scope, dom, tag));
-
-        if (Number.isFinite(index) && this.indexTwo) {
-            const indexTwo: number = this.negativeIndex(obj, await this.indexTwo.evaluate(scope, dom, tag)) as number;
-            const values = [];
-            for (let i: number = index as number; i <= indexTwo; i++) {
-                values.push(obj[i]);
-            }
-            return values;
-        } else {
-            if (obj instanceof Scope) {
-                return obj.get(index as string);
-            }
-            return (obj)[index];
-        }
-    }
-
-    public static match(tokens: Token[]): boolean {
-        return tokens[0].type === TokenType.L_BRACKET;
-    }
-
-    public static parse(lastNode, token, tokens: Token[]): IndexNode {
-        const valueTokens: Token[][] = Tree.getBlockTokens(tokens, TokenType.COLON);
-        const values: Node[] = [];
-        for (const arg of valueTokens) {
-            values.push(Tree.processTokens(arg));
-        }
-        return new IndexNode(lastNode, values[0], values.length > 1 && values[1]);
-    }
-}

package/src/AST/LiteralNode.ts

@@ -1,17 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {TreeNode} from "../AST";
-import {Node} from "./Node";
-
-export class LiteralNode<T = any> extends Node implements TreeNode {
-    constructor(
-        public readonly value: T
-    ) {
-        super();
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        return this.value;
-    }
-}

package/src/AST/LoopNode.ts

@@ -1,35 +0,0 @@
-import {Token, TreeNode} from "../AST";
-import {FunctionNode} from "./FunctionNode";
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-
-export class LoopNode extends FunctionNode implements TreeNode {
-    protected looping?: boolean = true;
-
-    public async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta): Promise<void> {
-        const classPrep = meta?.ClassNodePrepare; // Don't add event handler if we're in class prep
-        if (tag && !classPrep) {
-            const func = await this.getFunction(tag.scope || scope, dom, tag);
-            this.setTimeout(func);
-        }
-        await super.prepare(scope, dom, tag, meta);
-    }
-
-    async loop(func) {
-        if (this.looping) {
-            await func();
-            this.setTimeout(func);
-        }
-    }
-
-    setTimeout(func, time: number = 33) {
-        setTimeout(async () => {
-            await this.loop(func);
-        }, time);
-    }
-
-    public static parse<T = LoopNode>(lastNode, token, tokens: Token[]): T {
-        return super.parse<T>(lastNode, token, tokens, LoopNode);
-    }
-}

package/src/AST/ModifierNode.ts

@@ -1,32 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, TreeNode} from "../AST";
-import {Node} from "./Node";
-import {BlockNode} from "./BlockNode";
-
-
-export class ModifierNode extends Node implements TreeNode {
-    constructor(
-        public readonly name: string,
-        public readonly block: BlockNode
-    ) {
-        super();
-    }
-
-    public async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta?: any): Promise<void> {
-        return null;
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        return null;
-    }
-
-    public static parse(lastNode, token, tokens: Token[]): Node {
-        const modifier = tokens.shift().value.substr(1);
-        if (lastNode) {
-            lastNode.modifiers.add(modifier);
-        }
-        return lastNode;
-    }
-}

package/src/AST/NamedStackNode.ts

@@ -1,83 +0,0 @@
-import {FunctionScope, Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-import {BlockNode} from "./BlockNode";
-import {LiteralNode} from "./LiteralNode";
-
-type StackContext = {
-    block: BlockNode;
-    scope: Scope;
-    dom: DOM;
-    tag: Tag;
-}
-
-export class NamedStackNode extends Node implements TreeNode {
-    protected requiresPrep: boolean = true;
-    protected static stacks: { [key: string]: StackContext[] } = {};
-    protected static executions: string[] = [];
-
-    constructor(
-        public readonly stackName: LiteralNode<string>,
-        public readonly statements: BlockNode
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.stackName,
-            this.statements
-        ]
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        if (scope instanceof FunctionScope) { // NamedStackNode doesn't work with FunctionScope
-            scope = scope.parentScope;
-        }
-        const stackName = await this.stackName.evaluate(scope, dom, tag);
-        let execute = false;
-        if (!NamedStackNode.stacks[stackName]) {
-            NamedStackNode.stacks[stackName] = [];
-        }
-
-        if (NamedStackNode.executions.indexOf(stackName) === -1)
-            execute = true;
-
-        NamedStackNode.stacks[stackName].push({
-            block: this.statements,
-            scope: scope,
-            dom: dom,
-            tag: tag
-        });
-
-        if (execute) {
-            NamedStackNode.execute(stackName);
-        }
-    }
-
-    public static async execute(stackName: string): Promise<boolean> {
-        if (NamedStackNode.stacks[stackName].length > 0) {
-            const stack = NamedStackNode.stacks[stackName].shift();
-            if (NamedStackNode.executions.indexOf(stackName) === -1)
-                NamedStackNode.executions.push(stackName);
-
-            await stack.block.evaluate(stack.scope, stack.dom, stack.tag);
-            if (!(await NamedStackNode.execute(stackName))) {
-                NamedStackNode.executions.splice(NamedStackNode.executions.indexOf(stackName), 1);
-            }
-
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    public static parse(lastNode, token, tokens: Token[]) {
-        tokens.shift(); // Consume stack
-        const stackName = tokens.shift();
-        const statementTokens = Tree.getNextStatementTokens(tokens);
-        return new NamedStackNode(new LiteralNode<string>(stackName.value), Tree.processTokens(statementTokens));
-    }
-}