vsn 0.1.23 → 0.1.27

package/src/attributes/Radio.ts

@@ -9,7 +9,7 @@ export class Radio extends Attribute {
     protected key?: string;
     protected boundScope?: Scope;
 
-    public async extract() {
+    public async setup() {
         let scopeKey: string = this.getAttributeValue() || this.tag.getRawAttributeValue('name');
         let ref: ScopeReference;
         try {
@@ -21,11 +21,25 @@ export class Radio extends Attribute {
 
         this.key = await ref.getKey();
         this.boundScope = await ref.getScope();
+        await super.setup();
+    }
+
+    public async extract() {
+        if (this.tag.checked)
+            await this.handleEvent(null);
+        await super.extract();
     }
 
     public async connect() {
-        this.boundScope.bind(`change:${this.key}`, this.checkSelected, this);
+        this.boundScope.on(`change:${this.key}`, this.checkSelected, this);
         this.tag.addEventHandler('change', this.getAttributeModifiers(), this.handleEvent.bind(this));
+        await this.checkSelected();
+        await super.connect();
+    }
+
+    public async evaluate() {
+        await this.checkSelected();
+        await super.evaluate();
     }
 
     async handleEvent(e) {
@@ -33,6 +47,7 @@ export class Radio extends Attribute {
     }
 
     async checkSelected() {
-        this.tag.checked = this.boundScope.get(this.key) === this.tag.value;
+        const scopeValue = this.boundScope.get(this.key);
+        this.tag.checked = `${scopeValue}` === this.tag.value;
     }
 }

package/src/attributes/RootAttribute.ts

@@ -9,5 +9,6 @@ export class RootAttribute extends Attribute {
 
     public async setup() {
         this.tag.scope.set('$mobile', VisionHelper.isMobile());
+        await super.setup();
     }
 }

package/src/attributes/ScopeChange.ts

@@ -12,12 +12,14 @@ export abstract class ScopeChange extends Attribute {
         const code: string = this.getAttributeValue();
         this.handler = new Tree(code);
         await this.handler.prepare(this.tag.scope, this.tag.dom, this.tag);
+        await super.compile();
     }
 
     public async connect() {
         const binding = this.getAttributeBinding();
         const ref: ScopeReference = this.tag.scope.getReference(binding, false);
-        (await ref.getScope()).bind(`change:${await ref.getKey()}`, this.handleEvent.bind(this));
+        (await ref.getScope()).on(`change:${await ref.getKey()}`, this.handleEvent.bind(this));
+        await super.connect();
     }
 
     async handleEvent(e) {

package/src/attributes/SetAttribute.ts

@@ -30,6 +30,7 @@ export class SetAttribute extends Attribute {
         }
         this.key = await ref.getKey();
         this.boundScope = await ref.getScope();
+        await super.setup();
     }
 
     public async extract() {

package/src/attributes/StandardAttribute.ts

@@ -13,14 +13,17 @@ export class StandardAttribute extends Attribute {
         if (StandardAttribute.magicAttributes.indexOf(this.key) === -1 && !this.tag.element.hasAttribute(this.attributeName)) {
             this.tag.element.setAttribute(this.attributeName, '');
         }
+        await super.setup();
     }
 
     public async extract() {
         this.updateFrom();
+        await super.extract();
     }
 
     public async connect() {
-        this.tag.scope.bind(`change:${this.key}`, this.updateTo.bind(this));
+        this.tag.scope.on(`change:${this.key}`, this.updateTo.bind(this));
+        await super.connect();
     }
 
     public mutate(mutation: MutationRecord) {

package/src/attributes/StyleAttribute.ts

@@ -28,7 +28,7 @@ export class StyleAttribute extends Attribute {
     }
 
     public async connect() {
-        this.styleScope.bind(`change`, this.handleEvent.bind(this));
+        this.styleScope.on(`change`, this.handleEvent.bind(this));
         await super.connect();
     }
 

package/src/attributes/TypeAttribute.ts

@@ -18,5 +18,6 @@ export class TypeAttribute extends Attribute {
         }
 
         (await ref.getScope()).setType(await ref.getKey(), type);
+        await super.extract();
     }
 }

package/src/{Vision.ts → vsn.ts}

@@ -1,7 +1,5 @@
 import {DOM} from "./DOM";
-import {EventDispatcher} from "simple-ts-event-dispatcher";
 import {WrappedArray} from "./Scope";
-import {DataModel} from "simple-ts-models";
 import {Registry} from "./Registry";
 import "./Types";
 import "./Formats";
@@ -9,6 +7,8 @@ import {Configuration} from "./Configuration";
 import {VisionHelper} from "./helpers/VisionHelper";
 import {Tree} from "./AST";
 import {Query} from "./Query";
+import {EventDispatcher} from "./EventDispatcher";
+import {DataModel} from "./Model/DataModel";
 
 export class Vision extends EventDispatcher {
     protected static _instance: Vision;
@@ -73,4 +73,6 @@ export * from './Attribute';
 export * from './AST';
 export {DOM} from './DOM';
 export {WrappedArray, Scope, ScopeReference} from './Scope';
+export {Controller} from './Controller';
+export {Tag} from './Tag';
 export const vision: Vision = Vision.instance;

package/test/AST.spec.ts

@@ -1,7 +1,8 @@
-import {Promise as SimplePromise, IDeferred} from 'simple-ts-promise';
+
 import {Scope, WrappedArray} from "../src/Scope";
 import {Tree} from "../src/AST";
 import {DOM} from "../src/DOM";
+import {IDeferred, SimplePromise} from "../src/SimplePromise";
 
 describe('Tree', () => {
     let scope: Scope = null,

package/test/DOM.spec.ts

@@ -1,4 +1,4 @@
-import "../src/Vision";
+import "../src/vsn";
 import {DOM} from "../src/DOM";
 import {Registry} from "../src/Registry";
 

package/test/MessageList.spec.ts

@@ -0,0 +1,101 @@
+import MessageList from "../src/MessageList";
+
+describe('MessageList', () => {
+    it("should reset properly", () => {
+        const list = new MessageList();
+        list.merge({
+            'foo': ['bar', 'baz']
+        });
+        console.info(list.keys);
+        expect(list.length).toBe(1);
+        expect(list['foo']).toEqual(['bar', 'baz']);
+
+        list.reset();
+
+        expect(list.length).toBe(0);
+        expect(list['foo']).toEqual(undefined);
+    });
+
+    it("should add messages", () => {
+        const list = new MessageList({
+            'foo': ['bar', 'baz']
+        });
+
+        // Add list
+        list.add('foo', ['biz', 'blarg']);
+        expect(list['foo']).toEqual(['bar', 'baz', 'biz', 'blarg']);
+
+        // Add single error and replace
+        list.add('foo', 'replaced', true);
+        expect(list['foo']).toEqual(['replaced']);
+    });
+
+    it("should merge messages", () => {
+        const list = new MessageList();
+        list.merge({
+            'foo': ['bar', 'baz'],
+            'test': ['test 1', 'test 2']
+        });
+
+        list.merge({
+            'foo': ['merged 1', 'merged 2'],
+            'test': ['test 3', 'test 4'],
+            'new': ['new 1', 'new 2']
+        });
+
+        expect(list['foo']).toEqual(['bar', 'baz', 'merged 1', 'merged 2']);
+        expect(list['test']).toEqual(['test 1', 'test 2', 'test 3', 'test 4']);
+        expect(list['new']).toEqual(['new 1', 'new 2']);
+    });
+
+    it("should replace messages", () => {
+        const list = new MessageList();
+        list.merge({
+            'foo': ['bar', 'baz'],
+            'test': ['test 1', 'test 2']
+        });
+
+        list.merge({
+            'foo': ['merged 1', 'merged 2'],
+            'test': ['test 3', 'test 4'],
+            'new': ['new 1', 'new 2']
+        }, true);
+
+        expect(list['foo']).toEqual(['merged 1', 'merged 2']);
+        expect(list['test']).toEqual(['test 3', 'test 4']);
+        expect(list['new']).toEqual(['new 1', 'new 2']);
+    });
+
+    it("should return a list", () => {
+        const list = new MessageList(),
+            items = {
+                'foo': ['bar', 'baz'],
+                'test': ['test 1', 'test 2']
+            };
+        list.merge(items);
+        expect(list.list).toEqual(items);
+    });
+
+    it("should ignore empty additions", () => {
+        const list = new MessageList();
+        list.merge({});
+        list.merge(null);
+        expect(list.length).toEqual(0);
+
+        list.merge({
+            'empty': [],
+            'null': null
+        });
+        expect(list.length).toEqual(0);
+    });
+
+    it("should cache list getter result", () => {
+        const messageList = new MessageList({
+            'foo': ['bar', 'baz']
+        }),
+            list = messageList.list;
+        expect(list).toBe(messageList.list);
+        messageList.add('bar', 'baz');
+        expect(list).not.toBe(messageList.list);
+    });
+});

package/test/Model/DataModel.spec.ts

@@ -0,0 +1,141 @@
+import {DataModel} from "../../src/Model/DataModel";
+
+
+describe('Model', () => {
+    it("Should trigger a change event when any field is changed", () => {
+        const m = new DataModel(['foo']);
+        let value = null,
+            field = null;
+
+        m.on('change', (_field, values) => {
+            field = _field;
+            value = values.value;
+        });
+
+        m.foo = 'testing';
+
+        expect<string | null>(field).toBe('foo');
+        expect(value).toBe(m.foo);
+    });
+
+    it("Should create the given fields from an object", () => {
+        const m = new DataModel({
+            field_1: 1,
+            field_2: 'yes',
+            field_3: true
+        });
+        expect(m.getFields().length).toBe(3);
+
+        m.setData({field_4: 4, field_5: 5});
+        expect(m.getFields().length).toBe(5);
+        const data = m.getData();
+        expect(data['field_1']).toBe(1);
+        expect(data['field_2']).toBe('yes');
+        expect(data['field_3']).toBe(true);
+        expect(data['field_4']).toBe(4);
+        expect(data['field_5']).toBe(5);
+    });
+
+    it("Should create the given fields from an array", () => {
+        const m = new DataModel([
+            'field_1',
+            'field_2',
+            'field_3'
+        ]);
+        expect(m.getFields().length).toBe(3);
+    });
+
+    it("Should trigger a change event when a field is changed", () => {
+        const m = new DataModel({
+                field_1: 1,
+                field_2: 'yes',
+                field_3: true
+            });
+
+        let oldValue = null,
+            oldValueCheck = null,
+            value = null;
+
+        m.bindToFields('change', [
+            'field_2',
+            'field_1'
+        ], (values) => {
+            oldValue = values.oldValue;
+            value = values.value;
+        });
+
+        // Test to make sure field_1 change event is being called
+        oldValueCheck = m.field_1;
+        m.field_1 = 2;
+        expect(value).toBe(m.field_1);
+        expect(oldValue).toBe(oldValueCheck);
+
+        // Test to make sure field_2 change event is being called
+        oldValueCheck = m.field_2;
+        m.field_2 = 'no';
+        expect(value).toBe(m.field_2);
+        expect(oldValue).toBe(oldValueCheck);
+
+        // Test to make sure fields that aren't being listened to aren't
+        // triggering the event
+        oldValueCheck = m.foo;
+        m.foo = false;
+        expect(value).not.toBe(m.foo);
+        expect(oldValue).not.toBe(oldValueCheck);
+    });
+
+    it("Should trigger a change:field event when any field is changed", () => {
+        const m = new DataModel(['field_1']);
+        let value = null;
+
+        m.on('change:field_1', (values) => {
+            value = values.value;
+        });
+
+        m.field_1 = 'testing';
+
+        expect(value).toBe(m.field_1);
+    });
+
+    it("should save last data and return true with is modfied if something is modified", () => {
+        const m = new DataModel({
+            field_1: 1,
+            field_2: 'foo'
+        });
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.field_1 = 2;
+        m.field_2 = null;
+        expect(m.isModified()).toBe(true);
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.field_2 = 'bar';
+        expect(m.isModified()).toBe(true);
+    });
+
+    it("should revert to last data correctly", () => {
+        const m = new DataModel({
+            field_1: 1,
+            field_2: 'bar'
+        });
+        m.setLastData();
+        expect(m.isModified()).toBe(false);
+        m.field_1 = 2;
+        m.field_2 = null;
+        expect(m.isModified()).toBe(true);
+        m.revert();
+        expect(m.isModified()).toBe(false);
+        expect(m.field_1).toBe(1);
+        expect(m.field_2).toBe('bar');
+    });
+
+    it("should return the field object", () => {
+        const m = new DataModel({
+            field_1: 1,
+            field_2: 'string field!'
+        }),
+            field = m.getField('field_2');
+        expect(field.value).toBe('string field!');
+
+    });
+});