vsn 0.1.27 → 0.1.30

package/src/AST/ArithmeticAssignmentNode.ts

@@ -0,0 +1,243 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {DOMObject} from "../DOM/DOMObject";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+import {RootScopeMemberNode} from "./RootScopeMemberNode";
+import {ScopeMemberNode} from "./ScopeMemberNode";
+import {ElementQueryNode} from "./ElementQueryNode";
+import {ElementAttributeNode} from "./ElementAttributeNode";
+import {ElementStyleNode} from "./ElementStyleNode";
+import {UnitLiteral} from "./UnitLiteralNode";
+import {Controller} from "../vsn";
+
+export class ArithmeticAssignmentNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: RootScopeMemberNode | ScopeMemberNode,
+        public readonly right: TreeNode,
+        public readonly type: TokenType
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.left as Node,
+            this.right as Node
+        ]
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let scopes = [];
+        const name: string = await this.left.name.evaluate(scope, dom, tag);
+        if (this.left instanceof ScopeMemberNode) {
+            const inner = await this.left.scope.evaluate(scope, dom, tag);
+            if (this.left.scope instanceof ElementQueryNode) {
+                if (this.left.scope.first) {
+                    scopes.push(inner);
+                } else {
+                    scopes.push(...inner);
+                }
+            } else if (inner instanceof Scope) {
+                scopes.push(inner);
+            } else if (inner instanceof Controller) {
+                scopes.push(inner.scope);
+            } else {
+                scopes.push(scope)
+            }
+        } else if ((this.left instanceof ElementAttributeNode || this.left instanceof ElementStyleNode) && this.left.elementRef) {
+            const elements = await this.left.elementRef.evaluate(scope, dom, tag);
+            if (this.left.elementRef.first) {
+                scopes.push(elements);
+            } else {
+                scopes = elements;
+            }
+        } else
+            scopes.push(scope);
+
+        const values = [];
+        for (let localScope of scopes) {
+            if (localScope instanceof DOMObject) {
+                await this.handleDOMObject(name, dom, localScope, tag);
+            } else {
+                if (localScope['$wrapped'] && localScope['$scope']) {
+                    localScope = localScope['$scope'];
+                }
+
+                // We get the values from the passed scope, but set the value on the local scope
+                let left: number | Array<any> | string = await this.left.evaluate(scope, dom, tag);
+                let right: number | Array<any> | string = await this.right.evaluate(scope, dom, tag);
+
+                if (left instanceof Array) {
+                    left = this.handleArray(name, left, right, localScope);
+                } else if ((left as any) instanceof UnitLiteral || right instanceof UnitLiteral) {
+                    left = this.handleUnit(name, left, right, localScope);
+                } else if (Number.isFinite(left)) {
+                    left = this.handleNumber(name, left, right, localScope);
+                } else {
+                    left = this.handleString(name, left, right, localScope);
+                }
+
+                values.push(left);
+            }
+        }
+        return values.length > 1 ? values : values[0];
+    }
+
+    public handleNumber(key, left, right, scope) {
+        if (right !== null && !Number.isFinite(right))
+            right = parseFloat(`${right}`);
+
+        left = left as number;
+        right = right as number;
+
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left = right;
+                break;
+            case TokenType.ADD_ASSIGN:
+                left += right;
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                left -= right;
+                break;
+            case TokenType.MULTIPLY_ASSIGN:
+                left *= right;
+                break;
+            case TokenType.DIVIDE_ASSIGN:
+                left /= right;
+                break;
+        }
+        scope.set(key, left);
+        return left;
+    }
+
+    public handleString(key, left, right, scope) {
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left = right;
+                break;
+            case TokenType.ADD_ASSIGN:
+                left = `${left}${right}`;
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                left.replace(right, '');
+                break;
+            case TokenType.MULTIPLY_ASSIGN:
+                left *= right;
+                break;
+            case TokenType.DIVIDE_ASSIGN:
+                left /= right;
+                break;
+        }
+        scope.set(key, left);
+        return left;
+    }
+
+    public handleUnit(key, left, right, scope) {
+        if (!(left instanceof UnitLiteral)) {
+            left = new UnitLiteral(left);
+        }
+
+        if (!(right instanceof UnitLiteral)) {
+            right = new UnitLiteral(right);
+        }
+        const unit = left.unit || right.unit || 'px';
+
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left = right;
+                break;
+            case TokenType.ADD_ASSIGN:
+                left = new UnitLiteral(`${left.amount+right.amount}${unit}`);
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                left = new UnitLiteral(`${left.amount-right.amount}${unit}`);
+                break;
+            case TokenType.MULTIPLY_ASSIGN:
+                left = new UnitLiteral(`${left.amount*right.amount}${unit}`);
+                break;
+            case TokenType.DIVIDE_ASSIGN:
+                left = new UnitLiteral(`${left.amount/right.amount}${unit}`);
+                break;
+        }
+
+        scope.set(key, left);
+        return left;
+    }
+
+    public async handleDOMObject(key: string, dom: DOM, domObject: DOMObject, tag: Tag) {
+        let left = domObject.scope.get(key);
+        let right: number | Array<any> | string = await this.right.evaluate(domObject.scope, dom, tag);
+        if (left instanceof Array)
+            return this.handleArray(key, left, right, domObject.scope);
+
+        return this.handleString(key, left, right, domObject.scope);
+    }
+
+    public handleArray(key, left, right, scope) {
+        if (!(right instanceof Array))
+            right = [right];
+        switch (this.type) {
+            case TokenType.ASSIGN:
+                left.splice(0, left.length);
+                left.push(...right);
+                break;
+            case TokenType.ADD_ASSIGN:
+                left.push(...right);
+                break;
+            case TokenType.SUBTRACT_ASSIGN:
+                for (let i = left.length - 1; i >= 0; i--) {
+                    if (right.indexOf(left[i]) > -1) {
+                        left.splice(i, 1);
+                        i++;
+                    }
+                }
+                break;
+            case TokenType.TILDE:
+                for (const toggle of right) {
+                    const index = left.indexOf(toggle);
+                    if (index > -1) {
+                        left.splice(index, 1);
+                    } else {
+                        left.push(toggle);
+                    }
+                }
+                break;
+        }
+
+        /*
+         We have to trigger a change manually here. Setting the variable on the scope with an array won't trigger
+         it since we are modifying values inside of the array instance.
+         */
+        scope.dispatch(`change:${key}`);
+
+        return left;
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return [
+            TokenType.ASSIGN,
+            TokenType.ADD_ASSIGN,
+            TokenType.SUBTRACT_ASSIGN,
+            TokenType.MULTIPLY_ASSIGN,
+            TokenType.DIVIDE_ASSIGN,
+            TokenType.TILDE,
+        ].indexOf(tokens[0].type) > -1;
+    }
+
+    public static parse(lastNode: any, token, tokens: Token[]): ArithmeticAssignmentNode {
+        if (!(lastNode instanceof RootScopeMemberNode) && !(lastNode instanceof ScopeMemberNode) && !(lastNode instanceof ElementAttributeNode) && !(lastNode instanceof ElementStyleNode)) {
+            throw SyntaxError(`Invalid assignment syntax near ${Tree.toCode(tokens.splice(0, 10))}`);
+        }
+        tokens.splice(0, 1); // consume =
+        const assignmentTokens: Token[] = Tree.getNextStatementTokens(tokens, false, false, true);
+
+        return new ArithmeticAssignmentNode(
+            lastNode as RootScopeMemberNode,
+            Tree.processTokens(assignmentTokens),
+            token.type
+        );
+    }
+}

package/src/AST/ArithmeticNode.ts

@@ -0,0 +1,52 @@
+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 ArithmeticNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: TreeNode,
+        public readonly right: TreeNode,
+        public readonly type: TokenType
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.left as Node,
+            this.right as Node
+        ]
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const left: any = await this.left.evaluate(scope, dom, tag);
+        const right: any = await this.right.evaluate(scope, dom, tag);
+
+        switch (this.type) {
+            case TokenType.ADD:
+                return left + right;
+            case TokenType.SUBTRACT:
+                return left - right;
+            case TokenType.MULTIPLY:
+                return left * right;
+            case TokenType.DIVIDE:
+                return left / right;
+        }
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return [
+            TokenType.ADD,
+            TokenType.SUBTRACT,
+            TokenType.MULTIPLY,
+            TokenType.DIVIDE
+        ].indexOf(tokens[0].type) > -1
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        tokens.splice(0, 1); // Remove arithmetic operator
+        return new ArithmeticNode(lastNode, Tree.processTokens(Tree.getNextStatementTokens(tokens)), token.type)
+    }
+}

package/src/AST/ArrayNode.ts

@@ -0,0 +1,39 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {WrappedArray} from "../Scope/WrappedArray";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class ArrayNode extends Node implements TreeNode {
+    constructor(
+        public readonly values: Node[]
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return new Array(...this.values);
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const arr: WrappedArray<any> = new WrappedArray();
+        for (const val of this.values) {
+            arr.push(await val.evaluate(scope, dom, tag));
+        }
+        return arr;
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return tokens[0].type === TokenType.L_BRACKET;
+    }
+
+    public static parse(lastNode, token, tokens: Token[]): ArrayNode {
+        const valueTokens: Token[][] = Tree.getBlockTokens(tokens);
+        const values: Node[] = [];
+        for (const arg of valueTokens) {
+            values.push(Tree.processTokens(arg));
+        }
+        return new ArrayNode(values);
+    }
+}

package/src/AST/BlockNode.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 BlockNode extends Node implements TreeNode {
+    constructor(
+        public readonly statements: Node[]
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [...(this.statements as Node[])];
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let returnValue: any = null;
+        for (let i = 0; i < this.statements.length; i++) {
+            returnValue = await this.statements[i].evaluate(scope, dom, tag);
+        }
+        return returnValue;
+    }
+}

package/src/AST/BooleanLiteralNode.ts

@@ -0,0 +1,10 @@
+import {LiteralNode} from "./LiteralNode";
+
+export class BooleanLiteralNode extends LiteralNode<number> {
+    constructor(
+        public readonly value: any
+    ) {
+        super(value);
+        this.value = value === 'true';
+    }
+}

package/src/AST/ComparisonNode.ts

@@ -0,0 +1,57 @@
+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 ComparisonNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: Node,
+        public readonly right: Node,
+        public readonly type: TokenType
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.left as Node,
+            this.right as Node
+        ];
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const left: any = await this.left.evaluate(scope, dom, tag);
+        const right: any = await this.right.evaluate(scope, dom, tag);
+        switch (this.type) {
+            case TokenType.EQUALS:
+                return left === right;
+            case TokenType.NOT_EQUALS:
+                return left !== right;
+            case TokenType.GREATER_THAN:
+                return left > right;
+            case TokenType.LESS_THAN:
+                return left < right;
+            case TokenType.GREATER_THAN_EQUAL:
+                return left >= right;
+            case TokenType.LESS_THAN_EQUAL:
+                return left <= right;
+        }
+    }
+
+    public static match(tokens: Token[]): boolean {
+        return [
+            TokenType.EQUALS,
+            TokenType.NOT_EQUALS,
+            TokenType.GREATER_THAN,
+            TokenType.LESS_THAN,
+            TokenType.GREATER_THAN_EQUAL,
+            TokenType.LESS_THAN_EQUAL
+        ].indexOf(tokens[0].type) > -1
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        tokens.splice(0, 1); // Remove comparison operator
+        return new ComparisonNode(lastNode, Tree.processTokens(Tree.getNextStatementTokens(tokens)), token.type)
+    }
+}

package/src/AST/ConditionalNode.ts

@@ -0,0 +1,36 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {WrappedArray} from "../Scope/WrappedArray";
+import {TreeNode} from "../AST";
+import {BlockNode} from "./BlockNode";
+import {Node} from "./Node";
+
+export class ConditionalNode extends Node implements TreeNode {
+    constructor(
+        public readonly condition: Node,
+        public readonly block: BlockNode
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.condition as Node,
+            this.block as Node
+        ];
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const condition = await this.condition.evaluate(scope, dom, tag);
+        let evaluation = false;
+
+        if (condition instanceof WrappedArray) {
+            evaluation = condition.length > 0;
+        } else {
+            evaluation = !!condition;
+        }
+
+        return evaluation;
+    }
+}

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, true);
+        } 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, true);
+            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,27 @@
+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,
+        public readonly first: boolean = false
+    ) {
+        super();
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag: Tag = null, forceList: boolean = false): Promise<any> {
+        tag = tag || await dom.getTagForScope(scope);
+        const elements = await dom.get(this.query, true, tag);
+        return this.first && !forceList ? elements[0] : elements;
+    }
+
+    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, true);
+        } 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, true);
+            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
+        );
+    }
+}