vsn 0.1.26 → 0.1.27

package/src/Attribute.ts

@@ -1,6 +1,6 @@
 import {Tag} from "./Tag";
 import {VisionHelper} from "./helpers/VisionHelper";
-import {EventDispatcher} from "simple-ts-event-dispatcher";
+import {EventDispatcher} from "./EventDispatcher";
 
 export enum AttributeState {
     Instantiated,
@@ -83,7 +83,7 @@ export abstract class Attribute extends EventDispatcher {
     private setState(state: AttributeState) {
         const previousState = this._state;
         this._state = state;
-        this.trigger('state', {
+        this.dispatch('state', {
             state: state,
             previousState: previousState,
             attribute: this

package/src/Configuration.ts

@@ -1,5 +1,5 @@
-import {EventDispatcher} from "simple-ts-event-dispatcher";
 import {VisionHelper} from "./helpers/VisionHelper";
+import {EventDispatcher} from "./EventDispatcher";
 
 export type ConfigurationValue = string | number | boolean | null | undefined;
 
@@ -19,11 +19,11 @@ export class Configuration extends EventDispatcher {
     public set(key: string, value: ConfigurationValue) {
         const prev: ConfigurationValue = this.data[key];
         this.data[key] = value;
-        this.trigger(`change:${key}`, {
+        this.dispatch(`change:${key}`, {
             value: value,
             previous: prev
         });
-        this.trigger('change', {
+        this.dispatch('change', {
             key: key,
             value: value,
             previous: prev

package/src/Controller.ts

@@ -1,6 +1,6 @@
-import {EventDispatcher} from "simple-ts-event-dispatcher";
 import {Scope} from "./Scope";
 import {Tag} from "./Tag";
+import {EventDispatcher} from "./EventDispatcher";
 
 export abstract class Controller extends EventDispatcher {
     protected _scope: Scope;

package/src/DOM/DOMObject.ts

@@ -1,5 +1,5 @@
-import {EventDispatcher} from "simple-ts-event-dispatcher";
 import {Scope} from "../Scope";
+import {EventDispatcher} from "../EventDispatcher";
 
 export abstract class DOMObject extends EventDispatcher {
     protected _scope: Scope;

package/src/DOM.ts

@@ -1,6 +1,5 @@
 import {Tag} from "./Tag";
 import {ElementHelper} from "./helpers/ElementHelper";
-import {EventDispatcher} from "simple-ts-event-dispatcher";
 import {Configuration} from "./Configuration";
 import {Tree} from "./AST";
 import {TagList} from "./Tag/List";
@@ -9,6 +8,7 @@ import {VisionHelper} from "./helpers/VisionHelper";
 import {WrappedWindow} from "./DOM/WrappedWindow";
 import {WrappedDocument} from "./DOM/WrappedDocument";
 import {Scope} from "./Scope";
+import {EventDispatcher} from "./EventDispatcher";
 
 export class DOM extends EventDispatcher {
     protected static _instance: DOM;
@@ -37,7 +37,7 @@ export class DOM extends EventDispatcher {
             this.buildFrom(rootElement, true);
         }
         this.evaluate();
-        Configuration.instance.bind('change', this.evaluate.bind(this));
+        Configuration.instance.on('change', this.evaluate.bind(this));
     }
 
     public get root(): Tag {
@@ -232,7 +232,7 @@ export class DOM extends EventDispatcher {
             });
         if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'observeTags');
 
-        this.trigger('built');
+        this.dispatch('built');
     }
 
     async getTagsForElements(elements: Element[], create: boolean = false) {

package/src/EventDispatcher.ts

@@ -0,0 +1,117 @@
+
+export interface EventCallbackList {
+	[index: string]: EventCallback[];
+}
+
+
+export class EventCallback {
+    public calls: number;
+    constructor(
+        public readonly fnc: any,
+        public readonly key: number,
+        public readonly once: boolean,
+        public readonly context?: any,
+    ) {
+        this.calls = 0;
+    }
+
+    call(...args: any[]): boolean {
+        if(this.once && this.calls > 0)
+            return false;
+
+        this.fnc.apply(this.context, ...args);
+        this.calls += 1;
+        return true;
+    }
+}
+
+export type EventDispatcherCallback = (...args: any[]) => any;
+
+
+export class EventDispatcher  {
+    private static sources: EventDispatcher[] = [];
+    private readonly _listeners: EventCallbackList;
+    private _lastKey: number;
+
+    constructor() {
+        this._lastKey = 0;
+        this._listeners = {};
+        EventDispatcher.sources.push(this);
+    }
+
+    deconstructor() {
+        this.dispatch('deconstruct', this);
+        EventDispatcher.sources.splice(EventDispatcher.sources.indexOf(this), 1);
+    }
+
+    on(event: string, fct: EventDispatcherCallback, context?: any, once?: boolean): number {
+        once = once || false;
+        this._lastKey++;
+        this._listeners[event] = this._listeners[event] || [];
+        this._listeners[event].push(new EventCallback(fct, this._lastKey, once, context));
+        return this._lastKey;
+    }
+
+    once(event: string, fct: EventDispatcherCallback, context?: any): number {
+        return this.on(event, fct, context, true);
+    }
+
+    off(event: string, key?: number): boolean {
+        if(event in this._listeners === false) return false;
+        if(key) {
+            for(const cb of this._listeners[event]) {
+                if(key == cb.key) {
+                    this._listeners[event].splice(this._listeners[event].indexOf(cb), 1);
+                    return true;
+                }
+            }
+        } else {
+            this._listeners[event] = [];
+            return true;
+        }
+        return false;
+    }
+
+    offWithContext(event: string, context: any): number {
+        if(!(event in this._listeners)) return 0;
+        let toRemove: EventCallback[] = [],
+            cnt = 0;
+
+        for(const cb of this._listeners[event]) {
+            if(context == cb.context) {
+                toRemove.push(cb);
+            }
+        }
+
+        for(const cb of toRemove) {
+            this._listeners[event].splice(this._listeners[event].indexOf(cb), 1);
+            cnt++;
+        }
+        return cnt;
+    }
+
+    getListener(event: string, key: number): EventCallback | undefined {
+        for(const cb of this._listeners[event]) {
+            if(key == cb.key)
+                return cb;
+        }
+    }
+
+    dispatch(event: string, ...args: any[]): void {
+        if(!(event in this._listeners)) return;
+
+        for(let i = 0; i < this._listeners[event].length; i++) {
+            const cb: EventCallback = this._listeners[event][i];
+
+            // We need to unbind callbacks before they're called to prevent
+            // infinite loops if the event is somehow triggered within the
+            // callback
+            if(cb.once) {
+                this.off(event, cb.key);
+                i--;
+            }
+
+            cb.call(args);
+        }
+    }
+}

package/src/Formats.ts

@@ -15,8 +15,8 @@ export class Formats {
                   currency: currency
                 });
             };
-            Configuration.instance.bind('change:locale', setup);
-            Configuration.instance.bind('change:currency', setup);
+            Configuration.instance.on('change:locale', setup);
+            Configuration.instance.on('change:currency', setup);
             setup();
         }
         value = `${value}`.replace(/[^0-9.]+/, '');

package/src/MessageList.ts

@@ -0,0 +1,81 @@
+export interface IMessageHash {
+    [key: string]: string[] | null | undefined;
+}
+
+export default class MessageList {
+    [key: string]: any; // We're trying to mimic a basic object
+
+    private _cachedList: IMessageHash | undefined;
+
+    constructor(messages?: IMessageHash) {
+        this.reset();
+        if (messages)
+            this.merge(messages);
+    }
+
+    reset(): void {
+        // Reset the object
+        const keys: string[] = this.keys;
+
+        this._cachedList = undefined;
+
+        if (keys.length > 0) {
+            for (const field of keys) {
+                delete this[field];
+            }
+        }
+    }
+
+    add(field: string, errors: string[] | string, replace: boolean = false) {
+        this.merge({
+            [field]: typeof errors == 'string' ? [errors] : errors
+        }, replace);
+    }
+
+    merge(messages: IMessageHash | null | undefined, replace: boolean = false) {
+        if (!messages) return;
+
+        this._cachedList = undefined;
+
+        const keys: string[] = this.keys;
+        for (const field in messages) {
+            if (!messages.hasOwnProperty(field))
+                continue;
+            const message: string[] | null | undefined = messages[field];
+
+            if (message instanceof Array) {
+                if (!replace && keys.indexOf(field) > -1) {
+                    message.map((x) => {
+                        this[field].push(x);
+                    });
+                } else if (message.length > 0) {
+                    this[field] = message;
+                }
+            }
+        }
+    }
+
+    get list(): IMessageHash {
+        if (this._cachedList)
+            return this._cachedList;
+
+        const list: IMessageHash = {},
+            keys: string[] = this.keys;
+
+        for (const field of keys) {
+            list[field] = this[field];
+        }
+        this._cachedList = list;
+        return list;
+    }
+
+    get keys(): string[] {
+        const keys = Object.keys(this);
+        keys.splice(keys.indexOf('_cachedList'), 1);
+        return keys;
+    }
+
+    get length(): number {
+        return this.keys.length;
+    }
+}

package/src/Model/Collection.ts

@@ -0,0 +1,13 @@
+import {Model} from "../Model";
+import {ModelData} from "./ModelAbstract";
+
+export class Collection<T extends Model> extends Array<T> {
+    getData: () => ModelData[] = (): ModelData[] => {
+        // Returns an array of data from all of the models in the collection
+        const data: ModelData[] = [];
+        for(const item of this) {
+            data.push(item.getData())
+        }
+        return data;
+    };
+}

package/src/Model/DataModel.ts

@@ -0,0 +1,29 @@
+import {ModelAbstract, ModelData} from "./ModelAbstract";
+
+export class DataModel extends ModelAbstract {
+    constructor(data: ModelData | string[]) {
+        super();
+        if(data instanceof Array) {
+            this.__fields__ = data;
+            for (const field of data)
+                this.createField(field);
+        } else {
+            this.setData(data);
+        }
+    }
+
+    setData(data: ModelData) {
+        for(const field of Object.keys(data))
+            if(this.__fields__.indexOf(field) == -1) {
+                this.__fields__.push(field);
+                this.createField(field);
+            }
+        super.setData(data);
+    }
+
+    on(event: string, fct: (...args: any[]) => any, context?: any, once?: boolean): number {
+        if(event.indexOf('change:') == 0)
+            this.createField(event.substr(7));
+        return super.on(event, fct, context, once);
+    }
+}

package/src/Model/ModelAbstract.ts

@@ -0,0 +1,114 @@
+import {Field} from "./fields/Field";
+import {EventDispatcher} from "../EventDispatcher";
+
+export interface ModelData {
+    [key: string]: any;
+}
+
+export abstract class ModelAbstract extends EventDispatcher {
+    [key: string]: any;
+    __fields__: string[];
+    protected _lastData: any;
+
+    constructor() {
+        super();
+
+        // Models may have __fields__ from prototype
+        if(!this['__fields__'])
+            this.__fields__ = [];
+    }
+
+    createField(field: string, fieldType = Field, config?: any) {
+        config = config || {};
+        const instance = new fieldType(this, config.default, config),
+            propDesc = Object.getOwnPropertyDescriptor(this, field);
+        this['__'+field] = instance;
+
+        // property getter
+        const fieldGetter = function() {
+            return instance.value;
+        };
+        const getter = propDesc ? propDesc.get : fieldGetter,
+            fieldSetter = function(newVal: any) {
+                instance.value = newVal;
+            },
+            setter = propDesc ? propDesc.set : fieldSetter;
+
+        // Delete the original property
+        delete this[field];
+
+        // Create new property with getter and setter
+        Object.defineProperty(this, field, {
+            get: getter,
+            set: setter,
+            enumerable: true,
+            configurable: true
+        });
+
+        instance.on('change', (...args: any[]) => {
+            this.dispatch('change', field, ...args);
+            this.dispatch('change:' + field, ...args);
+        });
+        return instance;
+    }
+
+    setData(data: ModelData) {
+        const fields = this.getFields();
+        for (const key in data) {
+            if (fields.indexOf(key) > -1) {
+                this[key] = data[key];
+            }
+        }
+    }
+
+    getData(): ModelData {
+        const data: ModelData = {};
+        for (const key of this.getFields()) {
+            const field = this['__'+key];
+            if(this[key] == null || !field)
+                continue;
+
+            data[key] = field.getData();
+        }
+        return data;
+    }
+
+    getFields(): string[] {
+        return this.__fields__;
+    }
+
+    getField(field: string): Field {
+        return this['__'+field];
+    }
+
+    bindToFields(event:string, fields:string[], callback: (...args: any[]) => any) {
+        for(const field of fields) {
+            const _field = this['__'+ field];
+            if(_field)
+                _field.on(event, callback);
+
+        }
+    }
+
+    setLastData() {
+        this._lastData = this.getData();
+    }
+
+    /*
+     * Revert data to the last setData() call. Useful for forms that edit a
+     * list of items and then hit cancel rather than saving the list.
+     */
+    revert() {
+        this.setData(this._lastData);
+    }
+
+    isModified() {
+        const oData = this._lastData,
+            nData = this.getData();
+        for(const key of this.getFields()) {
+            if(nData[key] != oData[key])
+                return true;
+        }
+        return false;
+    }
+}

package/src/Model/fields/BooleanField.ts

@@ -0,0 +1,16 @@
+import { Field } from "./Field";
+
+export class BooleanField extends Field {
+    set value(data:any) {
+        const oldValue = this.value;
+        this._value = !!data;
+        this.dispatch('change', {
+            oldValue:oldValue,
+            value:data
+        });
+    }
+
+    get value() {
+        return this._value;
+    }
+}

package/src/Model/fields/EmailField.ts

@@ -0,0 +1,12 @@
+import { Field } from "./Field";
+
+export class EmailField extends Field {
+    _emailRegex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+
+    validate() {
+        super.validate();
+        if(this._value != null && !this._emailRegex.test(this._value))
+            this._errors.push('Please enter a valid email address');
+        return this._errors;
+    }
+}

package/src/Model/fields/Field.ts

@@ -0,0 +1,65 @@
+import {EventDispatcher} from "../../EventDispatcher";
+
+export function field(fieldType = Field, config: {} | null = {}) {
+    return function(target: any, key: string) {
+        if(target.__fields__ == undefined) {
+            target.__fields__ = [];
+        }
+
+        // Abstract models share __fields__
+        if(target.__fields__.indexOf(key) == -1)
+            target.__fields__.push(key);
+
+        const getter = function() {
+            return [fieldType, config];
+        };
+
+        Object.defineProperty(target, '__'+key+'__', {
+            get: getter,
+            set: v => {},
+            enumerable:false,
+            configurable: true
+        });
+    }
+}
+
+export class Field extends EventDispatcher {
+    model:any;
+    _value:any;
+    _errors:String[];
+    config:any;
+
+    constructor(model:any, value?:any, config?: Object) {
+        super();
+        this.model = model;
+        this.config = config;
+        this.value = value;
+        this._errors = [];
+    }
+
+    set value(v:any) {
+        const oldValue = this._value;
+        this._value = v;
+        this.dispatch('change', {
+            oldValue:oldValue,
+            value:v
+        });
+    }
+
+    get value() {
+        return this._value;
+    }
+
+    getData() {
+        return this.value;
+    }
+
+    validate() {
+        this._errors = [];
+
+        if(this.config['required'] == true && this._value == null)
+            this._errors.push('This field is required.');
+
+        return this._errors;
+    }
+}

package/src/Model/fields/FloatField.ts

@@ -0,0 +1,22 @@
+import { Field } from "./Field";
+
+export class FloatField extends Field {
+    set value(data:any) {
+        const oldValue = this.value;
+        if(typeof(data) == 'string')
+                data = parseFloat(data);
+
+        if(typeof(data) == "number" && this.config.toFixed)
+            data = parseFloat(data.toFixed(this.config.toFixed));
+
+        this._value = data;
+        this.dispatch('change', {
+            oldValue:oldValue,
+            value:data
+        });
+    }
+
+    get value() {
+        return this._value;
+    }
+}

package/src/Model/fields/PositiveNumberField.ts

@@ -0,0 +1,24 @@
+import { Field } from "./Field";
+
+export class PositiveIntegerField extends Field {
+    set value(data:any) {
+        const oldValue = this.value;
+        if(data == null) {
+            this._value = null;
+            return;
+        } else if(typeof(data) == 'string')
+                data = parseInt(data);
+
+        if(data <= 0)
+            data = 0;
+        this._value = data;
+        this.dispatch('change', {
+            oldValue:oldValue,
+            value:data
+        });
+    }
+
+    get value() {
+        return this._value;
+    }
+}

package/src/Model/fields/StringField.ts

@@ -0,0 +1,16 @@
+import { Field } from "./Field";
+
+export class StringField extends Field {
+    set value(data:any) {
+        var oldValue = this.value;
+        this._value = ''+data;
+        this.dispatch('change', {
+            oldValue:oldValue,
+            value:data
+        });
+    }
+
+    get value() {
+        return this._value;
+    }
+}

package/src/Model.ts

@@ -0,0 +1,57 @@
+
+import {ModelAbstract, ModelData} from "./Model/ModelAbstract";
+import MessageList from "./MessageList";
+
+
+export class Model extends ModelAbstract {
+    _errors!: MessageList;
+    _hasErrors: boolean;
+
+    constructor(data: ModelData | null | undefined = null) {
+        super();
+        const fields = this.__fields__.splice(0, this.__fields__.length);
+        for(const field of fields) {
+            (function(_self, field) {
+                if(!_self['__'+field+'__'])
+                    return;
+
+                _self.__fields__.push(field);
+                const _field = _self['__'+field+'__'],
+                    fieldType = _field[0],
+                    config = _field[1] || {};
+
+                _self.createField(field, fieldType, config);
+            })(this, field);
+        }
+
+        this._hasErrors = false;
+        if (data)
+            this.setData(data);
+        this._lastData = this.getData();
+        this._constructor();
+    }
+
+    _constructor() {}
+
+    validate(): MessageList {
+        this._hasErrors = false;
+        this._errors = new MessageList;
+        for(const field of this.getFields()) {
+            const errors = this['__'+field].validate();
+            if(errors.length > 0) {
+                this._errors.add(field, errors, true);
+                this._hasErrors = true;
+            }
+        }
+        return this._errors;
+    }
+
+    hasErrors(): boolean {
+        this.validate();
+        return this._hasErrors;
+    }
+
+    get errors(): MessageList {
+        return this._errors;
+    }
+}