vsn 0.1.26 → 0.1.29

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