vsn 0.1.131 → 0.1.133

package/src/AST/ClassNode.ts

@@ -14,6 +14,7 @@ export class ClassNode extends Node implements TreeNode {
     public static readonly classParents: {[name: string]: string[]} = {};
     public static readonly classChildren: {[name: string]: string[]} = {}; // List of child class selectors for a given class selector
     public static readonly preppedTags: {[name: string]: Tag[]} = {};
+    public static readonly preppingElements: {[name: string]: HTMLElement[]} = {};
 
     protected requiresPrep: boolean = true;
     public readonly classScope: Scope = new Scope();
@@ -59,6 +60,7 @@ export class ClassNode extends Node implements TreeNode {
             ClassNode.classes[this._fullSelector] = this;
             ClassNode.classChildren[this._fullSelector] = [];
             ClassNode.preppedTags[this._fullSelector] = [];
+            ClassNode.preppingElements[this._fullSelector] = []
 
             if (ClassNode.classParents[this.selector] === undefined)
                 ClassNode.classParents[this.selector] = [];
@@ -79,8 +81,11 @@ export class ClassNode extends Node implements TreeNode {
 
     public async findClassElements(dom: DOM, tag: Tag = null) {
         const tags: Tag[] = [];
-        for (const element of Array.from(dom.querySelectorAll(this.selector, tag))) {
+        for (const element of Array.from(dom.querySelectorAll(this.fullSelector, tag))) {
+            if (ClassNode.preppingElements[this._fullSelector].indexOf(element as HTMLElement) > -1) continue;
+            ClassNode.preppingElements[this._fullSelector].push(element as HTMLElement);
             tags.push(await ClassNode.addElementClass(this._fullSelector, element as HTMLElement, dom, element[Tag.TaggedVariable] || null));
+            ClassNode.preppingElements[this._fullSelector].splice(ClassNode.preppingElements[this._fullSelector].indexOf(element as HTMLElement), 1);
         }
 
         for (const childSelector of ClassNode.classChildren[this._fullSelector]) {
@@ -102,14 +107,12 @@ export class ClassNode extends Node implements TreeNode {
             hasConstruct = this.classScope.has('construct');
 
         tag.createScope(true);
-        // Create object scope
-        tag.scope.set('this', new Scope(tag.scope));
         const meta = this.updateMeta();
         meta['PrepForSelector'] = this.fullSelector;
         await this.block.prepare(tag.scope, dom, tag, meta);
         if (hasConstruct) {
             const fncCls: FunctionNode = this.classScope.get('construct') as FunctionNode;
-            const fnc = await fncCls.getFunction(tag.scope, dom, tag, false);
+            const fnc = await fncCls.getFunction(tag.scope, dom, tag, true);
             await fnc();
         }
         tag.dispatch(`${this.fullSelector}.construct`, tag.element.id);
@@ -122,7 +125,7 @@ export class ClassNode extends Node implements TreeNode {
 
         if (hasDeconstruct) {
             const fncCls: FunctionNode = this.classScope.get('deconstruct') as FunctionNode;
-            const fnc = await fncCls.getFunction(tag.scope, dom, tag, false);
+            const fnc = await fncCls.getFunction(tag.scope, dom, tag, true);
             await fnc();
         }
         for (const key of this.classScope.keys) {
@@ -133,7 +136,7 @@ export class ClassNode extends Node implements TreeNode {
         }
         tag.dispatch(`${this.fullSelector}.deconstruct`);
         ClassNode.preppedTags[this.fullSelector].splice(ClassNode.preppedTags[this.fullSelector].indexOf(tag), 1);
-        await ClassNode.removePreparedClassFromElement(tag.element, this.fullSelector);
+        ClassNode.removePreparedClassFromElement(tag.element, this.fullSelector);
     }
 
     public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {

package/src/AST/FunctionNode.ts

@@ -24,14 +24,15 @@ export class FunctionNode extends Node implements TreeNode {
     }
 
     public async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta?: any): Promise<void> {
-        if (meta?.ClassNode) {
-            // Set on object instance
-            if (tag && tag.scope.has('this')) {
-                tag.scope.get('this').set(this.name, this);
-            }
-        } else {
-            scope.set(this.name, this);
-        }
+        // if (meta?.ClassNode) {
+        //     // Set on object instance
+        //     if (tag && tag.scope.has('this')) {
+        //         tag.scope.get('this').set(this.name, this);
+        //     }
+        // } else {
+        //     scope.set(this.name, this);
+        // }
+        scope.set(this.name, this);
         await super.prepare(scope, dom, tag, meta);
     }
 
@@ -41,7 +42,7 @@ export class FunctionNode extends Node implements TreeNode {
 
     public async collectGarbage() {
         for (const f of this.garbage) {
-            f.collectGarbage();
+            f.deconstruct();
         }
         this.garbage = [];
     }
@@ -52,6 +53,7 @@ export class FunctionNode extends Node implements TreeNode {
             let functionScope;
             if (createFunctionScope && !(scope instanceof FunctionScope)) {
                 functionScope = new FunctionScope(scope);
+                functionScope.set('this', scope);
                 self.garbage.push(functionScope);
             } else {
                 functionScope = scope;

package/src/AST/IndexNode.ts

@@ -11,7 +11,6 @@ export class IndexNode extends Node implements TreeNode {
         public readonly indexTwo: Node = null
     ) {
         super();
-        console.log('index node', object, index, indexTwo);
     }
 
     protected _getChildNodes(): Node[] {

package/src/DOM/AbstractDOM.ts

@@ -206,6 +206,7 @@ export abstract class AbstractDOM extends EventDispatcher {
 
             for (const ele of Array.from(mutation.removedNodes)) {
                 for (const tag of this.getTagsFromParent(ele)) {
+                    if (tag.hasAttribute('vsn-template')) continue;
                     tag.deconstruct();
                 }
             }
@@ -247,7 +248,7 @@ export abstract class AbstractDOM extends EventDispatcher {
         return discovered;
     }
 
-    async buildTag<T = Tag>(element: HTMLElement, returnExisting: boolean = false, cls: any = Tag): Promise<T> {
+    async buildTag<T extends Tag>(element: HTMLElement, returnExisting: boolean = false, cls: any = Tag): Promise<T> {
         if (element[Tag.TaggedVariable]) return returnExisting ? element[Tag.TaggedVariable] : null;
         if (element.tagName.toLowerCase() === 'slot')
             cls = SlotTag;
@@ -256,9 +257,16 @@ export abstract class AbstractDOM extends EventDispatcher {
 
         const tag: T = new cls(element, this);
         this.tags.push(tag as any);
+        tag.once('deconstruct', this.removeTag, this);
         return tag;
     }
 
+    protected removeTag(tag: Tag) {
+        const index = this.tags.indexOf(tag);
+        if (index > -1)
+            this.tags.splice(index, 1);
+    }
+
     async setupTags(tags: Tag[]) {
          // Configure, setup & execute attributes
         for (const tag of tags)

package/src/DOM/DOMObject.ts

@@ -60,6 +60,9 @@ export abstract class DOMObject extends EventDispatcher {
     public deconstruct() {
         if (this._uniqueScope)
             this.scope?.deconstruct();
+        this.onEventHandlers = {};
+        this.slot = null;
+        this.delegates.length = 0;
         super.deconstruct();
     }
 }

package/src/Tag.ts

@@ -257,10 +257,13 @@ export class Tag extends DOMObject {
 
     public addChild(tag: Tag) {
         this._children.push(tag);
+        tag.once('deconstruct', this.removeChild, this);
     }
 
     public removeChild(tag: Tag) {
-        this._children.splice(this._children.indexOf(tag), 1);
+        const index = this._children.indexOf(tag);
+        if (index > -1)
+            this._children.splice(index, 1);
     }
 
     public get children(): Tag[] {
@@ -268,17 +271,18 @@ export class Tag extends DOMObject {
     }
 
     public findParentTag() {
-        let parentElement: HTMLElement = DOM.getParentElement(this.element);
         let foundParent = false;
-        while (parentElement) {
-            if (parentElement[Tag.TaggedVariable]) {
-                foundParent = true;
-                this.parentTag = parentElement[Tag.TaggedVariable];
-                break;
+        if (this.element) {
+            let parentElement: HTMLElement = DOM.getParentElement(this.element);
+            while (parentElement) {
+                if (parentElement[Tag.TaggedVariable]) {
+                    foundParent = true;
+                    this.parentTag = parentElement[Tag.TaggedVariable];
+                    break;
+                }
+                parentElement = DOM.getParentElement(parentElement);
             }
-            parentElement = DOM.getParentElement(parentElement);
         }
-
         if (!foundParent && DOM.instance.root !== this)
             return DOM.instance.root;
     }
@@ -292,7 +296,7 @@ export class Tag extends DOMObject {
     }
 
     public set parentTag(tag: Tag) {
-        if (this.element === document.body)
+        if (this.element === document.body || tag.element === document.body)
             return;
 
         if (this._parentTag && this._parentTag !== tag) {
@@ -320,7 +324,7 @@ export class Tag extends DOMObject {
         if (!!this.parentTag)
             return this.parentTag.scope;
 
-        return null;
+        return DOM.instance.root.scope;
     }
 
     public get controller(): Controller {
@@ -806,6 +810,11 @@ export class Tag extends DOMObject {
             this._controller.deconstruct();
             this._controller = null;
         }
+        if (this.element) {
+            this.element[Tag.TaggedVariable] = null;
+            (this as any).element = null;
+        }
+        this._parentTag = null;
         super.deconstruct();
     }
 }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = '0.1.131';
+export const VERSION = '0.1.133';
 

package/test/AST/ClassNode.spec.ts

@@ -52,13 +52,13 @@ describe('ClassNode', () => {
             <script type="text/vsn" vsn-script>
             class .simple-construct { 
                 func construct() {
-                    a|integer = "15";
-                    log('####### construct', a);
+                    this.a|integer = "15";
+                    log('####### construct', this.a);
                 }
                 
                 func test() {
-                    a += 1;
-                    log('####### testing', a);
+                    this.a += 1;
+                    log('####### testing', this.a);
                 }
             }
             </script>
@@ -82,7 +82,7 @@ describe('ClassNode', () => {
             <script type="text/vsn" vsn-script>
             class .testing { 
                 func construct() {
-                    a|integer = 0;
+                    this.a|integer = 0;
                 }
                 
                 class .test {