vsn 0.1.68 → 0.1.69

package/src/AST/ScopeMemberNode.ts

@@ -6,8 +6,9 @@ import {DOMObject} from "../DOM/DOMObject";
 import {TreeNode} from "../AST";
 import {Node} from "./Node";
 import {ElementQueryNode} from "./ElementQueryNode";
+import {ScopeNodeAbstract} from "./ScopeNodeAbstract";
 
-export class ScopeMemberNode extends Node implements TreeNode {
+export class ScopeMemberNode extends ScopeNodeAbstract implements TreeNode {
     constructor(
         public readonly scope: TreeNode<Scope>,
         public readonly name: TreeNode<string>
@@ -50,6 +51,7 @@ export class ScopeMemberNode extends Node implements TreeNode {
                 throw Error(`Cannot access "${await this.name.evaluate(scope, dom, tag)}" of undefined.`);
             }
             const name = await this.name.evaluate(scope, dom, tag);
+            await this.applyModifiers(name, parent, dom, tag);
             const value: any = parent.get(name, false);
             values.push(value instanceof Scope && value.wrapped || value);
         }

package/src/AST/ScopeNodeAbstract.ts

@@ -0,0 +1,20 @@
+import {Node} from "./Node";
+import {TreeNode} from "../AST";
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {Registry} from "../Registry";
+
+export abstract class ScopeNodeAbstract extends Node implements TreeNode {
+    async applyModifiers(name: string, scope: Scope, dom: DOM, tag: Tag) {
+        let type: string;
+        for (const modifier of this.modifiers) {
+            if (Registry.instance.types.has(modifier)) {
+                type = modifier;
+                break;
+            }
+        }
+        if (type)
+            scope.setType(name, type);
+    }
+}

package/src/AST.ts

@@ -29,6 +29,7 @@ import {StringFormatNode} from "./AST/StringFormatNode";
 import {FunctionNode} from "./AST/FunctionNode";
 import {ClassNode} from "./AST/ClassNode";
 import {OnNode} from "./AST/OnNode";
+import {ModifierNode} from "./AST/ModifierNode";
 
 function lower(str: string): string {
     return str ? str.toLowerCase() : null;
@@ -117,6 +118,7 @@ export enum TokenType {
     XHR_POST,
     XHR_PUT,
     XHR_DELETE,
+    MODIFIER,
 }
 
 const TOKEN_PATTERNS: TokenPattern[] = [
@@ -363,6 +365,10 @@ const TOKEN_PATTERNS: TokenPattern[] = [
     {
         type: TokenType.EXCLAMATION_POINT,
         pattern: /^!/
+    },
+    {
+        type: TokenType.MODIFIER,
+        pattern: /^\|\S+/
     }
 ];
 
@@ -585,6 +591,8 @@ export class Tree {
                 tokens.shift()
             } else if (tokens[0].type === TokenType.EXCLAMATION_POINT) {
                 node = NotNode.parse(node, tokens[0], tokens);
+            } else if (tokens[0].type === TokenType.MODIFIER) {
+                node = ModifierNode.parse(node, tokens[0], tokens);
             } else {
                 let code: string = Tree.toCode(tokens, 10);
                 throw Error(`Syntax Error. Near ${code}`);

package/src/Scope.ts

@@ -32,14 +32,25 @@ export class Scope extends EventDispatcher {
     }
 
     public set parentScope(scope: Scope) {
-        this._parentScope = scope;
-        scope.addChild(this);
+        if (scope) {
+            this._parentScope = scope;
+            scope.addChild(this);
+        } else if (this._parentScope){
+            this._parentScope.removeChild(this);
+            this._parentScope = null;
+        }
     }
 
     public addChild(scope: Scope) {
         this.children.push(scope);
     }
 
+    public removeChild(scope: Scope) {
+        const index = this.children.indexOf(scope);
+        if (index > -1)
+            this.children.splice(index, 1);
+    }
+
     getReference(path: string, createIfNotFound: boolean = true): ScopeReference {
         const scopePath: string[] = path.split('.');
         let key: string = scopePath[0];
@@ -127,6 +138,19 @@ export class Scope extends EventDispatcher {
         this.parentScope = null;
     }
 
+    collectGarbage(force: boolean = false) {
+        for (const child of this.children) {
+            child.collectGarbage(force);
+        }
+        if (force)
+            this.cleanup();
+    }
+
+    deconstruct() {
+        super.deconstruct();
+        this.collectGarbage(true);
+    }
+
     public wrap(toWrap: any, triggerUpdates: boolean = false, updateFromWrapped: boolean = true) {
         if (toWrap instanceof ScopeData) {
             if (this._data instanceof EventDispatcher) {
@@ -235,10 +259,15 @@ export class FunctionScope extends Scope {
     }
 
     set(key: string, value: any) {
-        if (this.parentScope.has(key) || ['$', '@'].indexOf(key[0]) > -1) {
+        if (this.parentScope && (this.parentScope.has(key) || ['$', '@'].indexOf(key[0]) > -1)) {
             this.parentScope.set(key, value);
         } else {
             super.set(key, value);
         }
     }
+
+    collectGarbage(force: boolean = true) {
+        super.collectGarbage(true);
+        this.cleanup();
+    }
 }