vsn 0.1.124 → 0.1.125

package/src/AST/DispatchEventNode.ts

@@ -5,12 +5,14 @@ import {Token, TokenType, Tree, TreeNode} from "../AST";
 import {Node} from "./Node";
 import {ObjectNode} from "./ObjectNode";
 import {ScopeData} from "../Scope/ScopeData";
+import {ElementQueryNode} from "./ElementQueryNode";
 
 export class DispatchEventNode extends Node implements TreeNode {
     constructor(
         public readonly name: string,
         public readonly data: ObjectNode | null,
-        public readonly bubbles: boolean = false
+        public readonly bubbles: boolean = false,
+        public readonly elementRef: ElementQueryNode | null,
     ) {
         super();
     }
@@ -23,28 +25,34 @@ export class DispatchEventNode extends Node implements TreeNode {
     }
 
     public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        let detail = this.data ? await this.data.evaluate(scope, dom, tag) : {};
+        let detail = this.data ? (await this.data.evaluate(scope, dom, tag)).objectify : {};
         if (detail instanceof Scope)
             detail = detail.data.getData();
         else if (detail instanceof ScopeData)
             detail = detail.getData();
 
-        detail['source'] = tag.element;
+        let targets: Tag[] = [tag];
+        if (this.elementRef) {
+            targets = await this.elementRef.evaluate(scope, dom, tag, true);
+        }
 
-        tag.element.dispatchEvent(new CustomEvent(this.name, {
-            bubbles: this.bubbles,
-            detail: detail
-        }));
+        for (const target of targets) {
+            detail['source'] = target.element;
+            target.element.dispatchEvent(new CustomEvent(this.name, {
+                bubbles: this.bubbles,
+                detail: detail
+            }));
+        }
     }
 
     public static parse(lastNode, token, tokens: Token[]) {
         const name = tokens.shift();
         let data: ObjectNode = null;
-        if (tokens.length && tokens[0].type === TokenType.L_PAREN) {
-            const containedTokens = Tree.getNextStatementTokens(tokens, true, true, false);
+        if (tokens.length && tokens[0].type === TokenType.L_BRACE) {
+            const containedTokens = Tree.getNextStatementTokens(tokens, false, false, true);
             data = Tree.processTokens(containedTokens).statements[0] as ObjectNode;
         }
-
-        return new DispatchEventNode(name.value, data, name.full.startsWith('!!!'));
+        const elementRef = lastNode instanceof ElementQueryNode ? lastNode : null;
+        return new DispatchEventNode(name.value, data, name.full.startsWith('!!!'), elementRef);
     }
 }

package/src/AST/ScopeMemberNode.ts

@@ -7,6 +7,8 @@ import {TreeNode} from "../AST";
 import {Node} from "./Node";
 import {ElementQueryNode} from "./ElementQueryNode";
 import {ScopeNodeAbstract} from "./ScopeNodeAbstract";
+import {ObjectAccessor} from "../Scope/ObjectAccessor";
+import {ScopeAbstract} from "../Scope/ScopeAbstract";
 
 export class ScopeMemberNode extends ScopeNodeAbstract implements TreeNode {
     constructor(
@@ -45,6 +47,8 @@ export class ScopeMemberNode extends ScopeNodeAbstract implements TreeNode {
         for (let parent of scopes) {
             if (parent instanceof DOMObject)
                 parent = parent.scope;
+            else if (parent && !(parent instanceof ScopeAbstract))
+                parent = new ObjectAccessor(parent);
 
             if (!parent) {
                 throw Error(`Cannot access "${await this.name.evaluate(scope, dom, tag)}" of undefined.`);

package/src/Scope/ObjectAccessor.ts

@@ -0,0 +1,21 @@
+import {ScopeAbstract} from "./ScopeAbstract";
+
+export class ObjectAccessor extends ScopeAbstract {
+    public readonly data: any;
+
+    constructor(data: any) {
+        super();
+        this.data = data;
+    }
+
+    public get(field: string, fallback = null): any {
+        const value = this.data[field];
+        if (typeof value === 'object')
+            return new ObjectAccessor(value);
+        return value === undefined ? fallback : value;
+    }
+
+    public set(field: string, value: any): void {
+        this.data[field] = value;
+    }
+}

package/src/Scope/ScopeAbstract.ts

@@ -0,0 +1,11 @@
+import {EventDispatcher} from "../EventDispatcher";
+
+export interface IScope {
+    get(field: string, fallback?: any): any;
+    set(field: string, value: any): void;
+}
+
+export abstract class ScopeAbstract extends EventDispatcher implements IScope {
+    public abstract get(field: string, fallback?: any): any;
+    public abstract set(field: string, value: any): void;
+}

package/src/Scope.ts

@@ -5,9 +5,10 @@ import {WrappedArray} from "./Scope/WrappedArray";
 import {ScopeData} from "./Scope/ScopeData";
 import {DynamicScopeData} from "./Scope/DynamicScopeData";
 import {DOM} from "./DOM";
+import {ScopeAbstract} from "./Scope/ScopeAbstract";
 
 
-export class Scope extends EventDispatcher {
+export class Scope extends ScopeAbstract {
     public wrapped: any;
     protected _data: ScopeData;
     protected children: Scope[];
@@ -29,6 +30,18 @@ export class Scope extends EventDispatcher {
         return this._data;
     }
 
+    public get objectify(): any {
+        const obj = {};
+        for (const key of this.keys) {
+            const value = this.get(key);
+            if (value instanceof Scope)
+                obj[key] = value.objectify;
+            else
+                obj[key] = value;
+        }
+        return obj;
+    }
+
     public get parentScope(): Scope {
         if (this._parentScope)
             return this._parentScope;

package/src/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = '0.1.124';
+export const VERSION = '0.1.125';
 

package/src/vsn.ts

@@ -4,7 +4,6 @@ import {Registry} from "./Registry";
 import {Configuration} from "./Configuration";
 import {VisionHelper} from "./helpers/VisionHelper";
 import {Tree} from "./AST";
-import {Query} from "./Query";
 import {EventDispatcher} from "./EventDispatcher";
 import {DynamicScopeData} from "./Scope/DynamicScopeData";
 import {Controller} from "./Controller";
@@ -46,7 +45,7 @@ export class Vision extends EventDispatcher {
             window['Registry'] = Registry;
             window['vision'] = window['vsn'] = this;
             window['Tree'] = Tree;
-            window['$'] = Query;
+            window['$'] = this.exec.bind(this);
             VisionHelper.window.dispatchEvent(new Event('vsn'));
         }
     }

package/test/AST/ClassNode.spec.ts

@@ -2,6 +2,7 @@ import {DOM} from "../../src/DOM";
 import {ClassNode} from "../../src/AST/ClassNode";
 import {Registry} from "../../src/Registry";
 import {TagList} from "../../src/Tag/TagList";
+import {Tag} from "../../src/vsn";
 
 
 describe('ClassNode', () => {
@@ -16,6 +17,7 @@ describe('ClassNode', () => {
             }
             </script>
             <div class="simple"><input /></div>
+            <input id="not-nested" />
         `;
         const dom = new DOM(document);
         await dom.ready;
@@ -25,6 +27,26 @@ describe('ClassNode', () => {
         expect(ClassNode.classes['.simple input']).toBeInstanceOf(ClassNode);
     });
 
+    it("properly build classes on newly added elements in the dom", async () => {
+        document.body.innerHTML = `
+            <script type="text/vsn" vsn-script>
+            class .added-html { 
+                func construct() {}
+            }
+            </script>
+            <div id="container"></div>
+        `;
+        const dom = new DOM(document);
+        await dom.ready;
+        await Registry.instance.classes.get('.added-html');
+        const newHtml: string = `<div class="added-html" id="added"></div>`;
+        dom.root.scope.set('newHtml', newHtml);
+        await dom.exec('#container.@html = newHtml');
+        const addedTag = await dom.exec('#added');
+        expect(addedTag).toBeInstanceOf(Tag);
+        expect(ClassNode.preppedTags['.added-html'].indexOf(addedTag)).toBeGreaterThan(-1);
+    });
+
     it("properly define a simple class", async () => {
         document.body.innerHTML = `
             <script type="text/vsn" vsn-script>