vsn 0.1.26 → 0.1.29

package/src/AST/ElementAttributeNode.ts

@@ -0,0 +1,63 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {TagList} from "../Tag/List";
+import {TreeNode} from "../AST";
+import {Node} from "./Node";
+import {ElementQueryNode} from "./ElementQueryNode";
+import {LiteralNode} from "./LiteralNode";
+
+export class ElementAttributeNode extends Node implements TreeNode {
+    protected requiresPrep: boolean = true;
+
+    constructor(
+        public readonly elementRef: ElementQueryNode | null,
+        public readonly attr: string
+    ) {
+        super();
+    }
+
+    public get name(): LiteralNode<string> {
+        return new LiteralNode<string>(`@${this.attributeName}`);
+    }
+
+    protected _getChildNodes(): Node[] {
+        let nodes = [];
+        if (this.elementRef)
+            nodes.push(this.elementRef)
+        return nodes;
+    }
+
+    get attributeName(): string {
+        if (this.attr.startsWith('.'))
+            return this.attr.substring(2);
+        return this.attr.substring(1);
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let tags: TagList;
+        if (this.elementRef) {
+            tags = await this.elementRef.evaluate(scope, dom, tag);
+        } else if (tag) {
+            tags = new TagList(tag)
+        } else {
+            return;
+        }
+
+        if (tags.length === 1)
+            return tags[0].scope.get(`@${this.attributeName}`);
+
+        return tags.map((tag) => tag.scope.get(`@${this.attributeName}`));
+    }
+
+    async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
+        if (this.elementRef) {
+            await this.elementRef.prepare(scope, dom, tag);
+            const tags: TagList = await this.elementRef.evaluate(scope, dom, tag);
+            for (const t of tags)
+                await t.watchAttribute(this.attributeName);
+        } else if(tag) {
+            await tag.watchAttribute(this.attributeName);
+        }
+    }
+}

package/src/AST/ElementQueryNode.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 ElementQueryNode extends Node implements TreeNode {
+    protected requiresPrep: boolean = true;
+
+    constructor(
+        public readonly query: string
+    ) {
+        super();
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        tag = tag || await dom.getTagForScope(scope);
+        return await dom.get(this.query, true, tag);
+    }
+
+    async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
+        tag = tag || await dom.getTagForScope(scope);
+        await dom.get(this.query, true, tag);
+    }
+}

package/src/AST/ElementStyleNode.ts

@@ -0,0 +1,63 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {TagList} from "../Tag/List";
+import {TreeNode} from "../AST";
+import {Node} from "./Node";
+import {ElementQueryNode} from "./ElementQueryNode";
+import {LiteralNode} from "./LiteralNode";
+
+export class ElementStyleNode extends Node implements TreeNode {
+    protected requiresPrep: boolean = true;
+
+    constructor(
+        public readonly elementRef: ElementQueryNode | null,
+        public readonly attr: string
+    ) {
+        super();
+    }
+
+    public get name(): LiteralNode<string> {
+        return new LiteralNode<string>(`$${this.attributeName}`);
+    }
+
+    protected _getChildNodes(): Node[] {
+        let nodes = [];
+        if (this.elementRef)
+            nodes.push(this.elementRef)
+        return nodes;
+    }
+
+    get attributeName(): string {
+        if (this.attr.startsWith('.'))
+            return this.attr.substring(2);
+        return this.attr.substring(1);
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let tags: TagList;
+        if (this.elementRef) {
+            tags = await this.elementRef.evaluate(scope, dom, tag);
+        } else if (tag) {
+            tags = new TagList(tag)
+        } else {
+            return;
+        }
+
+        if (tags.length === 1)
+            return tags[0].scope.get(`$${this.attributeName}`);
+
+        return tags.map((tag) => tag.scope.get(`$${this.attributeName}`));
+    }
+
+    async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
+        if (this.elementRef) {
+            await this.elementRef.prepare(scope, dom, tag);
+            const tags: TagList = await this.elementRef.evaluate(scope, dom, tag);
+            for (const t of tags)
+                await t.watchStyle(this.attributeName);
+        } else if(tag) {
+            await tag.watchStyle(this.attributeName);
+        }
+    }
+}

package/src/AST/ForStatementNode.ts

@@ -0,0 +1,59 @@
+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
+        ];
+    }
+
+    public 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

@@ -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;
+    }
+}