vsn 0.1.27 → 0.1.30

package/src/AST/FunctionArgumentNode.ts

@@ -0,0 +1,27 @@
+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[])
+        ]
+    }
+
+    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

@@ -0,0 +1,32 @@
+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";
+
+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
+        ]
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let functionScope: Scope = scope;
+        if (this.fnc instanceof ScopeMemberNode) {
+            functionScope = await this.fnc.scope.evaluate(scope, dom, tag);
+        }
+        const values = await this.args.evaluate(scope, dom, tag);
+        return (await this.fnc.evaluate(scope, dom, tag)).call(functionScope.wrapped || functionScope, ...values);
+    }
+}

package/src/AST/IfStatementNode.ts

@@ -0,0 +1,67 @@
+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[])
+        ]
+    }
+
+    public 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

@@ -0,0 +1,46 @@
+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();
+    }
+
+    public 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

@@ -0,0 +1,61 @@
+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;
+    }
+
+    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 {
+            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

@@ -0,0 +1,17 @@
+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();
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        return this.value;
+    }
+}

package/src/AST/Node.ts

@@ -0,0 +1,71 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {TreeNode} from "../AST";
+
+export abstract class Node implements TreeNode {
+    protected requiresPrep: boolean = false;
+    protected _isPreparationRequired: boolean;
+    protected childNodes: Node[];
+    protected nodeCache: {[key: string]: Node[]} = {};
+    abstract evaluate(scope: Scope, dom: DOM, tag?: Tag);
+
+    isPreparationRequired(): boolean {
+        if (this.requiresPrep)
+            return true;
+
+        if (this._isPreparationRequired !== undefined)
+            return this._isPreparationRequired;
+
+        for (const node of this.getChildNodes()) {
+            if (node.isPreparationRequired()) {
+                this._isPreparationRequired = true;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
+        for (const node of this.getChildNodes()) {
+            await node.prepare(scope, dom, tag);
+        }
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [];
+    }
+
+    getChildNodes(): Node[] {
+        if (this.childNodes === undefined) {
+            this.childNodes = this._getChildNodes();
+        }
+        return this.childNodes;
+    }
+
+    findChildrenByType<T = Node>(t: any): T[] {
+        return this.findChildrenByTypes([t]);
+    }
+
+    findChildrenByTypes<T = Node>(types: any[], cacheKey: string = null): T[] {
+        if (cacheKey !== null && this.nodeCache[cacheKey])
+            return this.nodeCache[cacheKey] as any;
+
+        const nodes: T[] = [];
+        for (const child of this.getChildNodes()) {
+            for (const t of types) {
+                if (child instanceof t)
+                    nodes.push(child as any as T);
+                const childNodes: T[] = child.findChildrenByType<T>(t);
+                nodes.push(...childNodes);
+            }
+        }
+
+        if (cacheKey !== null)
+            this.nodeCache[cacheKey] = nodes as any;
+
+        return nodes;
+    }
+}
+

package/src/AST/NotNode.ts

@@ -0,0 +1,41 @@
+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 NotNode extends Node implements TreeNode {
+    constructor(
+        public readonly toFlip: Node
+    ) {
+        super();
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const flipping = await this.toFlip.evaluate(scope, dom, tag);
+        return !flipping;
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.toFlip
+        ];
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        tokens.splice(0, 1); // Remove not operator
+        let containedTokens;
+        if (tokens[0].type === TokenType.L_PAREN) {
+            containedTokens = Tree.getNextStatementTokens(tokens);
+        } else {
+            containedTokens = Tree.consumeTypes(tokens, [
+                TokenType.BOOLEAN_LITERAL,
+                TokenType.NUMBER_LITERAL,
+                TokenType.STRING_LITERAL,
+                TokenType.NAME,
+                TokenType.PERIOD
+            ]);
+        }
+        return new NotNode(Tree.processTokens(containedTokens));
+    }
+}

package/src/AST/NumberLiteralNode.ts

@@ -0,0 +1,14 @@
+import {LiteralNode} from "./LiteralNode";
+
+export class NumberLiteralNode extends LiteralNode<number> {
+    constructor(
+        public readonly value: any
+    ) {
+        super(value);
+        if (this.value.indexOf('.') > -1) {
+            this.value = parseFloat(this.value)
+        } else {
+            this.value = parseInt(this.value);
+        }
+    }
+}

package/src/AST/ObjectNode.ts

@@ -0,0 +1,55 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {BlockType, Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class ObjectNode extends Node implements TreeNode {
+    constructor(
+        public readonly keys: Node[],
+        public readonly values: Node[]
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return new Array(...this.values);
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const obj: Scope = new Scope();
+        for (let i = 0; i < this.values.length; i++) {
+            const key = this.keys[i];
+            const val = this.values[i];
+            obj.set(await key.evaluate(scope, dom, tag), await val.evaluate(scope, dom, tag));
+        }
+        return obj;
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return tokens[0].type === TokenType.L_BRACE;
+    }
+
+    public static parse(lastNode, token, tokens: Token[]): ObjectNode {
+        const valueTokens: Token[] = Tree.getNextStatementTokens(tokens);
+        const keys: Node[] = [];
+        const values: Node[] = [];
+
+        while (valueTokens.length > 0) {
+            const key: Token[] = Tree.getTokensUntil(valueTokens, TokenType.COLON, false);
+            if (valueTokens[0].type !== TokenType.COLON)
+                throw Error('Invalid object literal syntax. Expecting :');
+            valueTokens.splice(0, 1); // Consume :
+            const val: Token[] = Tree.getTokensUntil(valueTokens, TokenType.COMMA, true, false, true, {
+                type: BlockType.STATEMENT,
+                open: null,
+                close: null,
+                openCharacter: null,
+                closeCharacter: null
+            });
+            keys.push(Tree.processTokens(key));
+            values.push(Tree.processTokens(val));
+        }
+        return new ObjectNode(keys, values);
+    }
+}

package/src/AST/RootScopeMemberNode.ts

@@ -0,0 +1,25 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class RootScopeMemberNode<T = any> extends Node implements TreeNode {
+    constructor(
+        public readonly name: TreeNode<string>
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.name as Node
+        ]
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const name = await this.name.evaluate(scope, dom, tag);
+        const value = scope.get(name);
+        return value instanceof Scope && value.wrapped || value;
+    }
+}

package/src/AST/ScopeMemberNode.ts

@@ -0,0 +1,58 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {TagList} from "../Tag/List";
+import {DOMObject} from "../DOM/DOMObject";
+import {TreeNode} from "../AST";
+import {Node} from "./Node";
+import {ElementQueryNode} from "./ElementQueryNode";
+
+export class ScopeMemberNode extends Node implements TreeNode {
+    constructor(
+        public readonly scope: TreeNode<Scope>,
+        public readonly name: TreeNode<string>
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.scope as Node,
+            this.name as Node
+        ]
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let scopes = [];
+        const values = [];
+
+        if (this.scope instanceof ElementQueryNode) {
+            const elements = await this.scope.evaluate(scope, dom, tag);
+            if (this.scope.first) {
+                scopes.push(elements);
+            } else {
+                scopes = elements;
+            }
+        } else {
+            const evalScope = await this.scope.evaluate(scope, dom, tag);
+            if (evalScope instanceof TagList) {
+                scopes = evalScope;
+            } else {
+                scopes.push(evalScope);
+            }
+        }
+
+        for (let parent of scopes) {
+            if (parent instanceof DOMObject)
+                parent = parent.scope;
+
+            if (!parent) {
+                throw Error(`Cannot access "${await this.name.evaluate(scope, dom, tag)}" of undefined.`);
+            }
+            const name = await this.name.evaluate(scope, dom, tag);
+            const value: any = parent.get(name, false);
+            values.push(value instanceof Scope && value.wrapped || value);
+        }
+        return values.length === 1 ? values[0] : values;
+    }
+}

package/src/AST/UnitLiteralNode.ts

@@ -0,0 +1,51 @@
+import {LiteralNode} from "./LiteralNode";
+
+export class UnitLiteral {
+    protected _amount: number;
+    protected _unit: string;
+
+    constructor(
+        protected _value: any
+    ) {
+        this.value = this._value;
+    }
+
+    get amount(): number {
+        return this._amount;
+    }
+
+    get unit(): string {
+        return this._unit;
+    }
+
+    get value(): string {
+        return `${this._amount}${this._unit}`;
+    }
+
+    set value(value: string) {
+        if (value.indexOf('.') > -1) {
+            this._amount = parseFloat(value)
+        } else {
+            this._amount = parseInt(value);
+        }
+
+        if (isNaN(this._amount))
+            this._amount = 0;
+
+        const unit = /[^\d.]+$/.exec(value);
+        this._unit = unit && unit[0] || '';
+    }
+
+    public toString() {
+        return this.value;
+    }
+}
+
+
+export class UnitLiteralNode extends LiteralNode<UnitLiteral> {
+    constructor(
+        _value: any
+    ) {
+        super(new UnitLiteral(_value));
+    }
+}