vsn 0.1.44 → 0.1.47

package/src/DOM.ts

@@ -3,8 +3,6 @@ import {ElementHelper} from "./helpers/ElementHelper";
 import {Configuration} from "./Configuration";
 import {Tree} from "./AST";
 import {TagList} from "./Tag/List";
-import {benchmarkEnd, benchmarkStart} from "./Bencmark";
-import {VisionHelper} from "./helpers/VisionHelper";
 import {WrappedWindow} from "./DOM/WrappedWindow";
 import {WrappedDocument} from "./DOM/WrappedDocument";
 import {Scope} from "./Scope";
@@ -50,6 +48,8 @@ export class DOM extends EventDispatcher {
                 return new TagList(this.window);
             case 'document':
                 return new TagList(this.document);
+            case 'body':
+                return new TagList(this.root);
             default:
                 const nodes = this.querySelectorAll(selector, tag);
                 return await this.getTagsForElements(Array.from(nodes) as Element[], create);
@@ -119,6 +119,13 @@ export class DOM extends EventDispatcher {
             if (tag) {
                 tag.mutate(mutation);
             }
+
+            for (const ele of Array.from(mutation.removedNodes)) {
+                const toRemove: Tag = await this.getTagForElement(ele as HTMLElement);
+                if (toRemove) {
+                    toRemove.deconstruct();
+                }
+            }
         }
     }
 
@@ -139,7 +146,6 @@ export class DOM extends EventDispatcher {
         const toBuild: HTMLElement[] = [];
         const toSkip: HTMLElement[] = [];
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM','findElements');
         if (ele && ele.querySelectorAll) {
             for (const element of (Array.from(ele.querySelectorAll(`*`)) as HTMLElement[])) { // Don't build items more than once
                 if (!ElementHelper.hasVisionAttribute(element)) continue;
@@ -152,9 +158,7 @@ export class DOM extends EventDispatcher {
                 toBuild.push(element);
             }
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'findElements');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'buildTags');
         for (const element of toBuild) {
             if (allElements.indexOf(element) > -1) continue;
             const tag: Tag = new Tag(element, this);
@@ -162,23 +166,17 @@ export class DOM extends EventDispatcher {
             newTags.push(tag);
             allElements.push(element as HTMLElement);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'buildTags');
 
         if (isRoot)
             this._root = await this.getTagForElement(document.body);
 
         // Configure, setup & execute attributes
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM','buildTagAttributes');
         for (const tag of newTags)
             await tag.buildAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM','buildTagAttributes');
 
-        if (VisionHelper.inDevelopment) benchmarkStart('DOM', 'compileAttributes');
         for (const tag of newTags)
             await tag.compileAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM','compileAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'buildTree');
         for (const tag of newTags) {
             if (tag === this.root)
                 continue;
@@ -198,39 +196,27 @@ export class DOM extends EventDispatcher {
             if (!foundParent)
                 console.error('Could not find parent for ', tag);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'buildTree');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'setupAttributes');
         for (const tag of newTags)
             await tag.setupAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'setupAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'extractAttributes');
         for (const tag of newTags)
             await tag.extractAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'extractAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'connectAttributes');
         for (const tag of newTags)
             await tag.connectAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'connectAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'finalizeTags');
         for (const tag of newTags) {
             await tag.finalize();
             this.queued.splice(this.queued.indexOf(tag.element), 1);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'finalizeTags');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'observeTags');
-        for (const tag of newTags)
-            this.observer.observe(tag.element, {
+        newTags.forEach(tag => this.observer.observe(tag.element, {
                 attributes: true,
                 characterData: true,
                 childList: true,
                 subtree: true
-            });
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'observeTags');
+            }));
 
         this.dispatch('built');
     }

package/src/Registry.ts

@@ -1,4 +1,3 @@
-import {VisionHelper} from "./helpers/VisionHelper";
 import {EventDispatcher} from "./EventDispatcher";
 import {IDeferred, IPromise, SimplePromise} from "./SimplePromise";
 
@@ -53,6 +52,7 @@ export class RegistryStore extends EventDispatcher {
 
 export class Registry extends EventDispatcher {
     protected static _instance: Registry;
+    public readonly components: RegistryStore;
     public readonly classes: RegistryStore;
     public readonly models: RegistryStore;
     public readonly templates: RegistryStore;
@@ -63,15 +63,18 @@ export class Registry extends EventDispatcher {
 
     constructor() {
         super();
+        this.components = new RegistryStore();
+        this.classes = new RegistryStore();
+        this.models = new RegistryStore();
+        this.templates = new RegistryStore();
+        this.types = new RegistryStore();
+        this.validators = new RegistryStore();
+        this.formats = new RegistryStore();
+        this.attributes = new RegistryStore();
+    }
 
-        const w = VisionHelper.window || {};
-        this.classes = new RegistryStore(w['$classes'] || {});
-        this.models = new RegistryStore(w['$models'] || {});
-        this.templates = new RegistryStore(w['$templates'] || {});
-        this.types = new RegistryStore(w['$types'] || {});
-        this.validators = new RegistryStore(w['$validators'] || {});
-        this.formats = new RegistryStore(w['$formats'] || {});
-        this.attributes = new RegistryStore(w['$attributes'] || {});
+    public static component(key: string = null, setup = null) {
+        return register('components', key, setup);
     }
 
     public static class(key: string = null, setup = null) {

package/src/Scope/ScopeDataAbstract.ts

@@ -65,7 +65,7 @@ export class ScopeDataAbstract extends EventDispatcher {
         const keys = [];
         for (const key of this.keys) {
             const property = this.getProperty(key);
-            if (property.hasTags(tags)) {
+            if (property.hasLabels(tags)) {
                 keys.push(key);
             }
         }
@@ -86,7 +86,7 @@ export class ScopeDataAbstract extends EventDispatcher {
         propLoop: for (const key of this.getProperties()) {
             const property = this['__'+key];
             for (const tag of tags) {
-                if (!property.hasTag(tag))
+                if (!property.hasLabel(tag))
                     continue propLoop;
             }
 

package/src/Scope/properties/Property.ts

@@ -30,7 +30,7 @@ export interface IPropertyConfig {
     type?: string;
     default?: any;
     validators?: TValidator[];
-    tags?: string[];
+    labels?: string[];
 }
 
 export class Property<T = any> extends EventDispatcher {
@@ -41,8 +41,8 @@ export class Property<T = any> extends EventDispatcher {
     constructor(value?: T, config?: IPropertyConfig) {
         super();
         this.config = config;
-        if (!this.config.tags)
-            this.config.tags = [];
+        if (!this.config.labels)
+            this.config.labels = [];
         if (!this.config.validators)
             this.config.validators = [];
         this.type = config.type || 'any';
@@ -109,43 +109,32 @@ export class Property<T = any> extends EventDispatcher {
             this.config.validators.push(validator);
     }
 
-    removeValidator(validator: TValidator | string) {
-        if (typeof validator == 'string') {
-            validator = this.getValidator(validator);
-        }
-
-        const index = this.config.validators.indexOf(validator);
-        if (index != -1)
-            this.config.validators.splice(index, 1);
-    }
-
-
-    addTag(tag: string) {
-        if(this.config.tags == undefined) {
-            this.config.tags = [];
+    addLabel(label: string) {
+        if(this.config.labels == undefined) {
+            this.config.labels = [];
         }
-        if(this.config.tags.indexOf(tag) == -1) {
-            this.config.tags.push(tag);
+        if(this.config.labels.indexOf(label) == -1) {
+            this.config.labels.push(label);
         }
     }
 
-    removeTag(tag: string) {
-        if(this.config.tags == undefined) {
+    removeLabel(label: string) {
+        if(this.config.labels == undefined) {
             return;
         }
-        const index = this.config.tags.indexOf(tag);
+        const index = this.config.labels.indexOf(label);
         if(index != -1) {
-            this.config.tags.splice(index, 1);
+            this.config.labels.splice(index, 1);
         }
     }
 
-    hasTag(tag: string) {
-        return this.config.tags.indexOf(tag) !== -1;
+    hasLabel(label: string) {
+        return this.config.labels.indexOf(label) !== -1;
     }
 
-    hasTags(tags: string[]) {
-        for(const tag of tags) {
-            if(!this.hasTag(tag)) {
+    hasLabels(labels: string[]) {
+        for(const label of labels) {
+            if(!this.hasLabel(label)) {
                 return false;
             }
         }

package/src/Scope/properties/_imports.ts

@@ -1,2 +1,2 @@
-export {Property, property} from './Property';
+export {Property, property, IPropertyConfig} from './Property';
 export {ArrayProperty} from './ArrayProperty';

package/src/Tag.ts

@@ -32,6 +32,13 @@ export class Tag extends DOMObject {
     protected _children: Tag[] = [];
     protected _controller: Controller;
 
+    public static readonly magicAttributes: string[] = [
+        '@text',
+        '@html',
+        '@class',
+        '@value'
+    ];
+
     protected inputTags: string[] = [
         'input',
         'select',
@@ -72,12 +79,7 @@ export class Tag extends DOMObject {
         if (this._nonDeferredAttributes.length > 0)
             return this._nonDeferredAttributes;
 
-        const attrs: Attribute[] = [];
-        for (const attribute of this.attributes) {
-            if (attribute.state === AttributeState.Deferred)
-                continue;
-            attrs.push(attribute);
-        }
+        const attrs: Attribute[] = this.attributes.filter(attr => attr.state !== AttributeState.Deferred);
         this._nonDeferredAttributes = attrs;
         return attrs;
     }
@@ -119,9 +121,7 @@ export class Tag extends DOMObject {
     }
 
     mutate(mutation: MutationRecord): void {
-        for (const attr of this.attributes) {
-            attr.mutate(mutation);
-        }
+        this.attributes.map(attr => attr.mutate(mutation));
         this.dispatch('mutate', mutation);
     }
 
@@ -336,6 +336,45 @@ export class Tag extends DOMObject {
                 return attr as any as T;
     }
 
+    public isMagicAttribute(key: string): boolean {
+        return Tag.magicAttributes.indexOf(key) > -1;
+    }
+
+    public setElementAttribute(key: string, value: any) {
+        if (this.isMagicAttribute(key)) {
+            if (key === '@text')
+                this.element.innerText = value;
+            else if (key === '@html') {
+                this.element.innerHTML = value;
+                DOM.instance.buildFrom(this.element);
+            } else if (key === '@value')
+                this.value = value;
+            else if (key === '@class' && value) {
+                this.element.classList.remove(...Array.from(this.element.classList));
+                const classes: string[] = value instanceof Array ? value : [value];
+                if (classes.length)
+                    this.element.classList.add(...classes);
+            }
+        } else {
+            this.element.setAttribute(key, value);
+        }
+    }
+
+    public getElementAttribute(key: string): any {
+        if (this.isMagicAttribute(key)) {
+            if (key === '@text')
+                return this.element.innerText;
+            else if (key === '@html')
+                return this.element.innerHTML;
+            else if (key === '@value')
+                return this.value;
+            else if (key === '@class') {
+                return Array.from(this.element.classList);
+            }
+        }
+        return this.element.getAttribute(key);
+    }
+
     public getRawAttributeValue(key: string, fallback: any = null) {
         return this.rawAttributes[key] ? this.rawAttributes[key] : fallback;
     }
@@ -579,4 +618,12 @@ export class Tag extends DOMObject {
             await this.setupAttribute(attr);
         this.deferredAttributes.length = 0;
     }
+
+    deconstruct() {
+        this.attributes.forEach(attr => attr.deconstruct());
+        this.attributes.length = 0;
+        this._children.forEach(child => child.deconstruct());
+        this._children.length = 0;
+        super.deconstruct();
+    }
 }

package/src/attributes/AddClassIf.ts

@@ -11,4 +11,4 @@ export class AddClassIf extends If {
             this.tag.element.classList.remove(this.getAttributeBinding());
         }
     }
-}
+}

package/src/attributes/Bind.ts

@@ -81,7 +81,7 @@ export class Bind extends Attribute {
     get valueFromElement(): string {
         let value;
         if (this.property) {
-            value = this.tag.element.getAttribute(this.property);
+            value = this.tag.getElementAttribute(this.property);
         } else {
             value = this.tag.value;
         }
@@ -131,7 +131,7 @@ export class Bind extends Attribute {
         if (!this.doUpdateTo) return;
         const value = this.formatter(this.value);
         if (this.property) {
-            this.tag.element.setAttribute(this.property, value);
+            this.tag.setElementAttribute(this.property, value);
         } else {
             this.tag.value = value;
         }

package/src/attributes/StandardAttribute.ts

@@ -2,15 +2,9 @@ import {Attribute} from "../Attribute";
 
 export class StandardAttribute extends Attribute {
     public static readonly canDefer: boolean = false;
-    protected static readonly magicAttributes: string[] = [
-        '@text',
-        '@html',
-        '@class',
-        '@value'
-    ];
 
     public async setup() {
-        if (StandardAttribute.magicAttributes.indexOf(this.key) === -1 && !this.tag.element.hasAttribute(this.attributeName)) {
+        if (!this.tag.isMagicAttribute(this.key) && !this.tag.element.hasAttribute(this.attributeName)) {
             this.tag.element.setAttribute(this.attributeName, '');
         }
         await super.setup();
@@ -51,7 +45,7 @@ export class StandardAttribute extends Attribute {
 
     public updateTo() {
         if (this.needsToBeSynced)
-            this.value = this.tag.scope.get(`@${this.attributeName}`);
+            this.value = this.tag.scope.get(this.key);
     }
 
     public updateFrom() {
@@ -64,32 +58,10 @@ export class StandardAttribute extends Attribute {
     }
 
     public set value(value: any) {
-        if (this.key === '@text')
-            this.tag.element.innerText = value;
-        else if (this.key === '@html')
-            this.tag.element.innerHTML = value;
-        else if (this.key === '@value')
-            this.tag.value = value;
-        else if (this.key === '@class' && value) {
-            this.tag.element.classList.remove(...Array.from(this.tag.element.classList));
-            const classes: string[] = value instanceof Array ? value : [value];
-            if (classes.length)
-                this.tag.element.classList.add(...classes);
-        }
-        else
-            this.tag.element.setAttribute(this.attributeName, value);
+        this.tag.setElementAttribute(this.tag.isMagicAttribute(this.key) ? this.key : this.attributeName, value);
     }
 
     public get value(): any {
-        if (this.key === '@text')
-            return this.tag.element.innerText;
-        else if (this.key === '@html')
-            return this.tag.element.innerHTML;
-        else if (this.key === '@value')
-            return this.tag.value;
-        else if (this.key === '@class') {
-            return Array.from(this.tag.element.classList);
-        } else
-            return this.tag.element.getAttribute(this.attributeName);
+        return this.tag.getElementAttribute(this.tag.isMagicAttribute(this.key) ? this.key : this.attributeName);
     }
 }

package/src/attributes/_imports.ts

@@ -1,7 +1,5 @@
 export {AddClassIf} from "./AddClassIf";
 export {Bind} from "./Bind";
-export {ClickRemoveClass} from "./ClickRemoveClass";
-export {ClickToggleClass} from "./ClickToggleClass";
 export {ControllerAttribute} from "./ControllerAttribute";
 export {DisableIf} from "./DisableIf";
 export {Exec} from "./Exec";

package/src/helpers/VisionHelper.ts

@@ -47,4 +47,17 @@ export class VisionHelper {
             setTimeout(callback, timeout);
         }
     }
+
+    public static get wasmSupport(): boolean {
+        try {
+            if (typeof WebAssembly === "object"
+                && typeof WebAssembly.instantiate === "function") {
+                const module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
+                if (module instanceof WebAssembly.Module)
+                    return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
+            }
+        } catch (e) {
+        }
+        return false;
+    }
 }

package/test/AST/ArithmeticAssignmentNode.spec.ts

@@ -1,5 +1,3 @@
-import {SimplePromise} from "../../src/SimplePromise";
-import {DOM} from "../../src/DOM";
 import {Tree} from "../../src/AST";
 import {Scope} from "../../src/Scope";
 

package/test/AST/StringFormatNode.spec.ts

@@ -0,0 +1,12 @@
+import {Tree} from "../../src/AST";
+import {Scope} from "../../src/Scope";
+
+
+describe('StringFormatNode', () => {
+    it("should format simple format strings", async () => {
+        const tree = new Tree("`Hello ${name}`");
+        const scope = new Scope();
+        scope.set("name", "World");
+        expect(await tree.evaluate(scope, null, null)).toBe("Hello World");
+    });
+});

package/test/AST/WASM.spec.ts

@@ -0,0 +1,63 @@
+import {compile, EOpCode, EValueType, run} from "../../src/AST/WASM";
+import {VisionHelper} from "../../src/helpers/VisionHelper";
+import {FunctionSection} from "../../src/AST/WASM/Function";
+
+describe('WASM', () => {
+    it("should support wasm", async () => {
+        expect(VisionHelper.wasmSupport).toBe(true);
+    });
+
+    it("should allow a simple addition function to be made", async () => {
+        const main = new FunctionSection("main");
+        main.addParam(EValueType.i32);
+        main.addParam(EValueType.i32);
+        main.addResult(EValueType.i32);
+        main.addCode([
+            0x00, // local declare count
+            EOpCode.get_local,
+            0x00, // local var 0
+            EOpCode.get_local,
+            0x01, // local var 1
+            EOpCode.i32_add,
+            EOpCode.end
+        ]);
+        expect(await run(main, 10, 15)).toBe(25);
+    });
+
+    it("should allow a simple subtraction function to be made", async () => {
+        const main = new FunctionSection("main");
+        main.addParam(EValueType.i32);
+        main.addParam(EValueType.i32);
+        main.addResult(EValueType.i32);
+        main.addCode([
+            0x00, // local declare count
+            EOpCode.get_local,
+            0x00, // local var 0
+            EOpCode.get_local,
+            0x01, // local var 1
+            EOpCode.i32_sub,
+            EOpCode.end
+        ]);
+        expect(await run(main, 10, 15)).toBe(-5);
+    });
+
+    it("should allow a simple function to be made", async () => {
+        const main = new FunctionSection("main");
+        main.addParam(EValueType.i32);
+        main.addParam(EValueType.i32);
+        main.addResult(EValueType.i32);
+        main.addCode([
+            0x00, // local declare count
+            EOpCode.get_local,
+            0x00, // local var 0
+            EOpCode.get_local,
+            0x01, // local var 1
+            EOpCode.i32_sub,
+            EOpCode.get_local,
+            0x00, // local var 0
+            EOpCode.i32_mul,
+            EOpCode.end
+        ]);
+        expect(await run(main, 100, 15)).toBe(8500);
+    });
+});

package/test/AST/XHRNode.spec.ts

@@ -0,0 +1,10 @@
+import {Tree} from "../../src/AST";
+import {Scope} from "../../src/Scope";
+
+
+describe('XHRNode', () => {
+    it("should parse and stuff", async () => {
+        const tree = new Tree(`{asd:123} >> '/test'`);
+        const scope = new Scope();
+    });
+});

package/test/Scope/ScopeData.spec.ts

@@ -6,15 +6,15 @@ describe('ScopeData', () => {
     it("should set tags correctly", async () => {
         const data = new ScopeData();
         data.createProperty('test', Property, {
-            tags: ['test']
+            labels: ['test']
         });
 
         data.createProperty('test_int', Property, {
-            tags: ['test']
+            labels: ['test']
         });
 
         data.createProperty('not_test', Property, {
-            tags: ['not_test']
+            labels: ['not_test']
         });
 
         data['test'] = 'test';
@@ -40,7 +40,7 @@ describe('ScopeData', () => {
         });
 
         const notTestProp = data.getProperty('not_test');
-        notTestProp.addTag('test');
+        notTestProp.addLabel('test');
         const taggedNotTestData2 = data.getData('test');
         expect(taggedNotTestData2).toEqual({
             test: 'test',
@@ -48,7 +48,7 @@ describe('ScopeData', () => {
             not_test: 'not_test'
         });
 
-        notTestProp.removeTag('test');
+        notTestProp.removeLabel('test');
         const taggedNotTestData3 = data.getData('test');
         expect(taggedNotTestData3).toEqual({
             test: 'test',

package/types/vsn-component.d.ts

@@ -0,0 +1,5 @@
+
+declare module "*.vsn" {
+  const content: string;
+  export default content;
+}

package/dist/attributes/ClickRemoveClass.d.ts

@@ -1,8 +0,0 @@
-import { Attribute } from "../Attribute";
-export declare class ClickRemoveClass extends Attribute {
-    protected cssClass: string;
-    protected target: string;
-    setup(): Promise<void>;
-    connect(): Promise<void>;
-    onClick(e: any): void;
-}