vsn 0.1.24 → 0.1.28

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,53 @@
+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) {
+            scopes = await this.scope.evaluate(scope, dom, tag);
+        } 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));
+    }
+}