vsn 0.1.149 → 1.0.1

package/test/MessageList.spec.ts

@@ -1,101 +0,0 @@
-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/Scope/DynamicScopeData.spec.ts

@@ -1,141 +0,0 @@
-import {DynamicScopeData} from "../../src/Scope/DynamicScopeData";
-
-
-describe('DynamicScopeData', () => {
-    it("Should trigger a change event when any field is changed", () => {
-        const m = new DynamicScopeData(['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 DynamicScopeData({
-            field_1: 1,
-            field_2: 'yes',
-            field_3: true
-        });
-        expect(m.getProperties().length).toBe(3);
-
-        m.setData({field_4: 4, field_5: 5});
-        expect(m.getProperties().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 DynamicScopeData([
-            'field_1',
-            'field_2',
-            'field_3'
-        ]);
-        expect(m.getProperties().length).toBe(3);
-    });
-
-    it("Should trigger a change event when a field is changed", () => {
-        const m = new DynamicScopeData({
-                field_1: 1,
-                field_2: 'yes',
-                field_3: true
-            });
-
-        let oldValue = null,
-            oldValueCheck = null,
-            value = null;
-
-        m.bindToProperties('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 DynamicScopeData(['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 DynamicScopeData({
-            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 DynamicScopeData({
-            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 DynamicScopeData({
-            field_1: 1,
-            field_2: 'string field!'
-        }),
-            field = m.getProperty('field_2');
-        expect(field.value).toBe('string field!');
-
-    });
-});

package/test/Scope/ScopeData.spec.ts

@@ -1,58 +0,0 @@
-import {ScopeData} from "../../src/Scope/ScopeData";
-import {Property} from "../../src/Scope/properties/Property";
-
-
-describe('ScopeData', () => {
-    it("should set tags correctly", async () => {
-        const data = new ScopeData();
-        data.createProperty('test', Property, {
-            labels: ['test']
-        });
-
-        data.createProperty('test_int', Property, {
-            labels: ['test']
-        });
-
-        data.createProperty('not_test', Property, {
-            labels: ['not_test']
-        });
-
-        data['test'] = 'test';
-        data['test_int'] = 1;
-        data['not_test'] = 'not_test';
-
-        const taggedTestData = data.getData('test');
-        expect(taggedTestData).toEqual({
-            test: 'test',
-            test_int: 1
-        });
-
-        const taggedNotTestData = data.getData('not_test');
-        expect(taggedNotTestData).toEqual({
-            not_test: 'not_test'
-        });
-
-        const allData = data.getData();
-        expect(allData).toEqual({
-            test: 'test',
-            test_int: 1,
-            not_test: 'not_test'
-        });
-
-        const notTestProp = data.getProperty('not_test');
-        notTestProp.addLabel('test');
-        const taggedNotTestData2 = data.getData('test');
-        expect(taggedNotTestData2).toEqual({
-            test: 'test',
-            test_int: 1,
-            not_test: 'not_test'
-        });
-
-        notTestProp.removeLabel('test');
-        const taggedNotTestData3 = data.getData('test');
-        expect(taggedNotTestData3).toEqual({
-            test: 'test',
-            test_int: 1
-        });
-    });
-});

package/test/Scope/WrappedArray.spec.ts

@@ -1,11 +0,0 @@
-import {WrappedArray} from "../../src/Scope/WrappedArray";
-
-describe('WrappedArray', () => {
-    it("Should return a wrapped array when filtered", () => {
-        const a = new WrappedArray<number>(1, 2, 3, 4, 5);
-        const even = a.filter(x => x % 2 === 0);
-        const odd = a.filter(x => x % 2 !== 0);
-        expect(even.length).toBe(2);
-        expect(odd.length).toBe(3);
-    });
-});

package/test/Scope/properties/ArrayProperty.spec.ts

@@ -1,23 +0,0 @@
-import {ScopeData} from "../../../src/Scope/ScopeData";
-import {ArrayProperty} from "../../../src/Scope/properties/_imports";
-import {WrappedArray} from "../../../src/vsn";
-
-describe('ArrayProperty', () => {
-    it("should do array things.", () => {
-        const d = new ScopeData();
-        d.createProperty('test', ArrayProperty);
-        d['test'] = [1, 2, 3];
-        expect(d['test'] instanceof WrappedArray).toBe(true);
-        expect(d['test'].indexOf(1)).toBe(0);
-        expect(d['test'].indexOf(2)).toBe(1);
-        expect(d['test'].indexOf(3)).toBe(2);
-        expect(d['test'].indexOf(4)).toBe(-1);
-        let calls = 0;
-        d.on('change:test', () => {
-            calls++;
-        });
-        d['test'].push(4);
-        expect(calls).toBeGreaterThanOrEqual(1); // push fires more than one event
-        expect(d['test'].indexOf(4)).toBe(3);
-    });
-});

package/test/Scope.spec.ts

@@ -1,69 +0,0 @@
-import {Scope} from "../src/Scope";
-import {WrappedArray} from "../src/Scope/WrappedArray";
-
-class Test {
-    public testing: string = 'test';
-
-    constructor() {
-    }
-
-    test(): boolean {
-        return this.testing === 'test';
-    }
-}
-
-describe('Scope', () => {
-    it("should wrap objects correctly", async () => {
-        const scope = new Scope();
-        const obj = new Test();
-        scope.wrap(obj);
-
-        expect(obj.test()).toBe(true);
-        scope.set('testing', 'yes');
-        expect(obj.test()).toBe(false);
-        obj.testing = 'test';
-        expect(scope.get('testing')).toBe('test');
-        expect(scope.get('test').call(scope.wrapped)).toBe(true);
-    });
-});
-
-describe('WrappedArray', () => {
-    it("should behave like an array", async () => {
-        const a = new WrappedArray();
-        let removes: number = 0;
-        a.on('remove', (e) => {
-             removes += 1;
-        });
-        a.push(1);
-        a.push(2);
-        a.push(3);
-        a.splice(1, 2);
-        expect(removes).toBe(2);
-        expect(a.length).toBe(1);
-    });
-
-    it("should trigger change events", async () => {
-        const a = new WrappedArray();
-        let changes: number = 0;
-        a.on('change', (e) => {
-             changes += 1;
-        });
-        a.push(1);
-        a.push(2);
-        a.push(3);
-        a.setLength(0);
-        expect(changes).toBe(6);
-        expect(a.length).toBe(0);
-    });
-
-    it("should set types correctly", async () => {
-        const scope = new Scope();
-        scope.setType('test', 'integer');
-        scope.set('test', '1');
-        expect(scope.get('test')).toBe(1);
-
-        scope.setType('testing', 'string');
-        scope.set('testing', 2);
-        expect(scope.get('testing')).toBe('2');
-    });
-});

package/test/Tag/TagList.spec.ts

@@ -1,21 +0,0 @@
-import {DOM} from "../../src/DOM";
-import {Query} from "../../src/Query";
-import {TagList} from "../../src/Tag/TagList";
-import {DOMObject} from "../../src/DOM/DOMObject";
-
-describe('TagList', () => {
-    it("should be able to fail properly", (done) => {
-        document.body.innerHTML = `
-            <p class="testing test">Test 1</p>
-            <div class="testing test">Test 2</div>
-            <p class="test">Test 3</p>
-            <p class="testing">Test 4</p>
-        `;
-        const dom = new DOM(document.body);
-        dom.once('built', async () => {
-            let tags: TagList | DOMObject = await Query('p.test', dom) as TagList;
-            expect(tags.length).toBe(2);
-            done();
-        });
-    });
-});

package/test/Tag.spec.ts

@@ -1,4 +0,0 @@
-
-describe('Tag', () => {
-
-});

package/test/attributes/Bind.spec.ts

@@ -1,174 +0,0 @@
-import "../../src/Types";
-import "../../src/attributes/_imports";
-import {DOM} from "../../src/DOM";
-
-
-describe('Bind', () => {
-    it("vsn-bind to work with inner text", (done) => {
-        document.body.innerHTML = `
-            <span id="test" vsn-name="test" vsn-bind="test.value">testing</span>
-        `;
-        const dom = new DOM(document.body);
-        dom.once('built', async () => {
-            const tag = await dom.getTagForElement(document.getElementById('test'));
-            expect(tag).toBeTruthy();
-            expect(tag.getParsedAttributeValue('vsn-name', 1)).toBe('test');
-            expect(tag.scope.get('value')).toBe('testing');
-            done();
-        });
-    });
-
-    it("vsn-bind to work with inner text with @text", (done) => {
-        document.body.innerHTML = `
-            <span id="test" test="testing" vsn-bind="@test"></span>
-        `;
-        const dom = new DOM(document.body);
-        dom.once('built', async () => {
-            const tag = await dom.getTagForElement(document.getElementById('test'));
-            expect(tag).toBeTruthy();
-            expect(tag.scope.get('@test')).toBe('testing');
-            done();
-        });
-    });
-
-    it("vsn-bind order of execution to be left to right and top to bottom", (done) => {
-        document.body.innerHTML = `
-            <span id="test" vsn-name="test" vsn-bind:id="test.id" vsn-bind="test.id">testing</span>
-            <span id="test2" vsn-bind="test.id">arg</span>
-        `;
-
-        const dom = new DOM(document.body);
-        dom.once('built', async () => {
-            const test = document.getElementById('arg');
-            const tag = await dom.getTagForElement(test);
-            const test2 = document.getElementById('test2');
-            expect(tag).toBeTruthy();
-            expect(tag.scope.get('id')).toBe('arg');
-            expect(test.innerText).toBe('arg');
-            expect(test2.innerText).toBe('arg');
-            done();
-        });
-    });
-
-    it("vsn-bind attribute changes trigger updating scope with new value", (done) => {
-        document.body.innerHTML = `
-            <span id="test" vsn-name="test" vsn-bind:id="test.id"></span>
-        `;
-
-        const dom = new DOM(document.body);
-        dom.once('built', async () => {
-            const test = document.getElementById('test');
-            const tag = await dom.getTagForElement(test);
-
-            tag.scope.on('change:id', () => {
-                expect(test.getAttribute('id')).toBe('new-id');
-                expect(tag.scope.get('id')).toBe('new-id');
-                done();
-            });
-
-            test.setAttribute('id', 'new-id');
-        });
-    });
-
-    it("vsn-bind innerHTML changes trigger updating scope with new value", (done) => {
-        document.body.innerHTML = `
-            <span id="test" vsn-name="test" vsn-bind="test.val">testing</span>
-        `;
-
-        const dom = new DOM(document.body, false);
-        dom.once('built', async () => {
-            const test = document.getElementById('test');
-            const tag = await dom.getTagForElement(test);
-            expect(tag.scope.get('val')).toBe('testing');
-
-            tag.scope.get('test').on('change:val', () => {
-                expect(tag.scope.get('val')).toBe('new-val');
-                done();
-            });
-
-            test.innerHTML = 'new-val';
-        });
-        dom.buildFrom(document.body, true);
-    });
-
-    it("vsn-bind input value changes trigger updating scope with new value", (done) => {
-        document.body.innerHTML = `
-            <input id="test" value="testing" vsn-name="test" vsn-bind="test.val"/>
-        `;
-
-        const dom = new DOM(document.body, false);
-        dom.once('built', async () => {
-            const test = document.getElementById('test');
-            const tag = await dom.getTagForElement(test);
-            expect(tag.scope.get('val')).toBe('testing');
-
-            tag.scope.get('test').on('change:val', () => {
-                expect(tag.scope.get('val')).toBe('new-val');
-                done();
-            });
-
-            test.setAttribute('value', 'new-val');
-            (test as any).value = 'new-val';
-            test.dispatchEvent(new Event('focus'));
-            test.dispatchEvent(new KeyboardEvent('keyup', {key: 'w'}));
-        });
-
-        dom.buildFrom(document.body, true);
-    });
-
-    it("vsn-bind element innerHTML should change when scope value is changed", (done) => {
-        document.body.innerHTML = `
-            <span id="test" vsn-name="test" vsn-bind="test.val">testing</span>
-        `;
-
-        const dom = new DOM(document.body, false);
-        dom.once('built', async () => {
-            const test = document.getElementById('test');
-            const tag = await dom.getTagForElement(test);
-            expect(tag.scope.get('val')).toBe('testing');
-
-             tag.scope.get('test').on('change:val', () => {
-                expect(test.innerHTML).toBe('new-val');
-                done();
-            });
-
-            tag.scope.get('test').set('val', 'new-val');
-        });
-        dom.buildFrom(document.body, true);
-    });
-
-    it("vsn-bind input value should change when scope value is changed", (done) => {
-        document.body.innerHTML = `
-            <input id="test" value="testing" vsn-name="test" vsn-bind="test.val" />
-        `;
-
-        const dom = new DOM(document.body);
-        dom.once('built', async () => {
-            const test = document.getElementById('test');
-            const tag = await dom.getTagForElement(test);
-            expect(tag.scope.get('val')).toBe('testing');
-
-            tag.on('mutate', () => {
-                expect(test.getAttribute('value')).toBe('new-val');
-                done();
-            });
-
-            tag.scope.set('val', 'new-val');
-        });
-    });
-
-    it("vsn-bind should work with currency formatter", (done) => {
-        document.body.innerHTML = `
-            <span id="test" vsn-name="test" vsn-bind="test.value" vsn-format="currency" vsn-type:test.value="float">1.5</span>
-        `;
-        const dom = new DOM(document.body);
-        dom.once('built', async () => {
-            const tag = await dom.getTagForElement(document.getElementById('test'));
-            expect(tag).toBeTruthy();
-            expect(tag.getParsedAttributeValue('vsn-name', 1)).toBe('test');
-            expect(tag.scope.get('value')).toBe(1.5);
-            expect(tag.element.innerText).toBe('$1.50');
-            done();
-        });
-    });
-});