vsn 0.1.130 → 0.1.132

package/dist/vsn.min.js.LICENSE.txt

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsn",
-  "version": "0.1.130",
+  "version": "0.1.132",
   "description": "SEO Friendly Javascript/Typescript Framework",
   "keywords": [
     "framework",

package/src/AST/AssignmentNode.ts

@@ -117,6 +117,7 @@ export class AssignmentNode extends Node implements TreeNode {
                 left /= right;
                 break;
         }
+
         scope.set(key, left);
         return left;
     }

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]) {
@@ -107,7 +112,7 @@ export class ClassNode extends Node implements TreeNode {
         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);
@@ -120,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) {
@@ -131,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,8 +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) // Don't muddle up tag scope if we're in a class
-            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);
     }
 
@@ -35,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 = [];
     }
@@ -46,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/Attribute.ts

@@ -1,5 +1,4 @@
 import {Tag} from "./Tag";
-import {VisionHelper} from "./helpers/VisionHelper";
 import {EventDispatcher} from "./EventDispatcher";
 import {Modifiers} from "./Modifiers";
 

package/src/DOM/AbstractDOM.ts

@@ -177,6 +177,21 @@ export abstract class AbstractDOM extends EventDispatcher {
         }
     }
 
+    public getTagsFromParent(parent: Node, includeParent: boolean = true) {
+        const tags: Tag[] = [];
+        if (includeParent) {
+            if (parent[Tag.TaggedVariable]) {
+                tags.push(parent[Tag.TaggedVariable]);
+            }
+        }
+
+        for (const ele of Array.from(parent.childNodes)) {
+            tags.push(...this.getTagsFromParent(ele, true));
+        }
+
+        return tags;
+    }
+
     public async mutation(mutations: MutationRecord[]) {
         for (const mutation of mutations) {
             let tag: Tag = await this.getTagForElement(mutation.target as HTMLElement);
@@ -190,9 +205,9 @@ export abstract class AbstractDOM extends EventDispatcher {
             }
 
             for (const ele of Array.from(mutation.removedNodes)) {
-                const toRemove: Tag = await this.getTagForElement(ele as HTMLElement);
-                if (toRemove) {
-                    toRemove.deconstruct();
+                for (const tag of this.getTagsFromParent(ele)) {
+                    if (tag.hasAttribute('vsn-template')) continue;
+                    tag.deconstruct();
                 }
             }
         }

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

@@ -89,6 +89,10 @@ export class Tag extends DOMObject {
         return this._meta;
     }
 
+    public get state(): TagState {
+        return this._state;
+    }
+
     protected onAttributeStateChange(event) {
         if (event.previouseState === AttributeState.Deferred)  // @todo: what is this?
             this._nonDeferredAttributes.length = 0;
@@ -264,17 +268,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;
     }
@@ -288,7 +293,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) {
@@ -316,7 +321,7 @@ export class Tag extends DOMObject {
         if (!!this.parentTag)
             return this.parentTag.scope;
 
-        return null;
+        return DOM.instance.root.scope;
     }
 
     public get controller(): Controller {
@@ -802,6 +807,10 @@ export class Tag extends DOMObject {
             this._controller.deconstruct();
             this._controller = null;
         }
+        if (this.element) {
+            this.element[Tag.TaggedVariable] = null;
+            (this as any).element = null;
+        }
         super.deconstruct();
     }
 }

package/src/attributes/PersistAttribute.ts

@@ -0,0 +1,83 @@
+import {Registry} from "../Registry";
+import {Attribute} from "../Attribute";
+import {TagState} from "../Tag";
+
+
+export interface IPersistedValue {
+    attribute: string,
+    value: string
+}
+
+@Registry.attribute('vsn-persist')
+export class PersistAttribute extends Attribute {
+    public static readonly persistedValues: Map<string, Map<string, string | string[]>> = new Map<string, Map<string, string | string[]>>();
+    public static readonly canDefer: boolean = true;
+
+    protected valueKeys: string[] = [];
+
+    public async extract() {
+        this.valueKeys = this.getAttributeValue().split(' ').map((v: string) => v.trim()).filter((v: string) => v.length > 0);
+        await super.extract();
+    }
+
+    public async connect() {
+        const elementId = this.tag.element.id;
+
+        if (!elementId)
+            throw new Error('vsn-persist requires an id attribute on the element');
+
+        const persistedValues = PersistAttribute.getPersistedValueStore(elementId);
+        for (const key of this.valueKeys) {
+            if (persistedValues.has(key)) {
+                if (key === '@class') {
+                    const classes = persistedValues.get(key);
+                    this.tag.element.classList.remove(...Array.from(this.tag.element.classList));
+                    this.tag.element.classList.add(...classes);
+                } else if (key.startsWith('@')) {
+                    this.tag.element.setAttribute(key.substring(1), persistedValues.get(key) as string);
+                    if (this.tag.isInput) {
+                        this.tag.once('$built', () => {
+                            this.tag.element.dispatchEvent(new Event('input'));
+                        });
+                    }
+                } else {
+
+                }
+            }
+        }
+        await super.connect();
+    }
+
+    public mutate(mutation: MutationRecord) {
+        if (this.tag.state !== TagState.Built)
+            return;
+
+        this.updateFrom();
+    }
+
+    protected updateFrom() {
+        const elementId = this.tag.element.id;
+        const persistedValues = PersistAttribute.getPersistedValueStore(elementId);
+
+        for (const key of this.valueKeys) {
+            if (key === '@class') {
+                const classes = Array.from(this.tag.element.classList);
+                persistedValues.set(key, classes);
+            } else if (key.startsWith('@')) {
+                persistedValues.set(key, this.tag.element.getAttribute(key.substring(1)));
+                if (this.tag.isInput) {
+                    this.tag.dispatch('input');
+                }
+            } else {
+
+            }
+        }
+    }
+
+    public static getPersistedValueStore(elementId: string) {
+        if (!PersistAttribute.persistedValues.has(elementId))
+            PersistAttribute.persistedValues.set(elementId, new Map<string, string>());
+
+        return PersistAttribute.persistedValues.get(elementId);
+    }
+}

package/src/attributes/_imports.ts

@@ -16,6 +16,7 @@ export {ListItemModel} from "./ListItemModel";
 export {ModelAttribute} from "./ModelAttribute";
 export {Name} from "./Name";
 export {On} from "./On";
+export {PersistAttribute} from "./PersistAttribute";
 export {Referenced} from "./Referenced";
 export {RootAttribute} from "./RootAttribute";
 export {ScopeAttribute} from "./ScopeAttribute";

package/src/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = '0.1.130';
+export const VERSION = '0.1.132';
 

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 {