vsn 0.1.26 → 0.1.29

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,8 +1,8 @@
-import {EventDispatcher} from "simple-ts-event-dispatcher";
 import {Scope} from "./Scope";
 import {Tag} from "./Tag";
+import {ScopeData} from "./Scope/ScopeData";
 
-export abstract class Controller extends EventDispatcher {
+export abstract class Controller extends ScopeData {
     protected _scope: Scope;
     protected _tag: Tag;
     protected _element: HTMLElement;
@@ -24,4 +24,12 @@ export abstract class Controller extends EventDispatcher {
         this._tag = tag;
         this._element = element;
     }
+
+    public get(key: string): any {
+        return this._scope?.get(key);
+    }
+
+    public set(key: string, value: any): void {
+        this._scope?.set(key, value);
+    }
 }

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,134 @@
+
+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 readonly _relays: EventDispatcher[] = [];
+    private _lastKey: number;
+
+    constructor() {
+        this._lastKey = 0;
+        this._listeners = {};
+        EventDispatcher.sources.push(this);
+    }
+
+    deconstruct() {
+        this.dispatch('deconstruct', this);
+        EventDispatcher.sources.splice(EventDispatcher.sources.indexOf(this), 1);
+        for (const k in this._listeners) {
+            delete this._listeners[k];
+        }
+    }
+
+    addRelay(relay: EventDispatcher) {
+        this._relays.push(relay);
+    }
+
+    removeRelay(relay: EventDispatcher) {
+        if (this._relays.indexOf(relay) > -1)
+            this._relays.splice(this._relays.indexOf(relay), 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) {
+            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);
+            }
+        }
+
+        for (const relay of this._relays) {
+            relay.dispatch(event, ...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,85 @@
+export interface IMessageHash {
+    [key: string]: string[] | null | undefined;
+}
+
+export 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;
+    }
+
+    get isEmpty(): boolean {
+        return this.length === 0;
+    }
+}

package/src/Model/Field.ts

@@ -0,0 +1,20 @@
+import {IPropertyConfig, Property} from "../Scope/properties/Property";
+import {Registry} from "../Registry";
+
+export interface IFieldConfig extends IPropertyConfig {
+    validators?: string[];
+}
+
+export class Field extends Property {
+    config: IFieldConfig;
+
+    validate() {
+        const errors = [];
+        for(const validatorName of this.config.validators || []) {
+            const validator = Registry.instance.validators.getSynchronous(validatorName);
+            errors.concat(validator(this.value));
+        }
+
+        return errors;
+    }
+}

package/src/Model.ts

@@ -0,0 +1,43 @@
+import {MessageList} from "./MessageList";
+import {ScopeData} from "./Scope/ScopeData";
+import {IScopeData} from "./Scope/ScopeDataAbstract";
+
+
+export class Model extends ScopeData {
+    _errors!: MessageList;
+    _hasErrors: boolean;
+
+    constructor(data: IScopeData | null | undefined = null) {
+        super();
+
+        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 property of this.getProperties()) {
+            const errors = this['__'+property].validate();
+            if(errors.length > 0) {
+                this._errors.add(property, errors, true);
+                this._hasErrors = true;
+            }
+        }
+        return this._errors;
+    }
+
+    hasErrors(): boolean {
+        this.validate();
+        return this._hasErrors;
+    }
+
+    get errors(): MessageList {
+        return this._errors;
+    }
+}

package/src/Registry.ts

@@ -1,6 +1,6 @@
-import {EventDispatcher} from "simple-ts-event-dispatcher";
-import {IDeferred, IPromise, Promise as SimplePromise} from "simple-ts-promise";
 import {VisionHelper} from "./helpers/VisionHelper";
+import {EventDispatcher} from "./EventDispatcher";
+import {IDeferred, IPromise, SimplePromise} from "./SimplePromise";
 
 export function register(store: string, key: string = null, setup: () => void = null) {
     return function(target: any, _key: string = null) {
@@ -24,7 +24,7 @@ export class RegistryStore extends EventDispatcher {
 
     register(key: string, item: any) {
         this.store[key] = item;
-        this.trigger(`registered:${key}`, item);
+        this.dispatch(`registered:${key}`, item);
     }
 
     get(key: string): IPromise<any> {
@@ -57,6 +57,7 @@ export class Registry extends EventDispatcher {
     public readonly models: RegistryStore;
     public readonly templates: RegistryStore;
     public readonly types: RegistryStore;
+    public readonly validators: RegistryStore;
     public readonly formats: RegistryStore;
     public readonly attributes: RegistryStore;
 
@@ -68,6 +69,7 @@ export class Registry extends EventDispatcher {
         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'] || {});
     }
@@ -76,6 +78,10 @@ export class Registry extends EventDispatcher {
         return register('classes', key, setup);
     }
 
+    public static controller(key: string = null, setup = null) {
+        return register('classes', key, setup);
+    }
+
     public static model(key: string = null, setup = null) {
         return register('models', key, setup);
     }
@@ -88,6 +94,10 @@ export class Registry extends EventDispatcher {
         return register('types', key, setup);
     }
 
+    public static validator(key: string = null, setup = null) {
+        return register('validators', key, setup);
+    }
+
     public static format(key: string = null, setup = null) {
         return register('formats', key, setup);
     }

package/src/Scope/DynamicScopeData.ts

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

package/src/Scope/QueryReference.ts

@@ -0,0 +1,29 @@
+import {DOM} from "../DOM";
+import {Scope} from "../Scope";
+import {ScopeReference} from "./ScopeReference";
+
+
+export class QueryReference extends ScopeReference {
+    constructor(
+        public readonly path: string,
+        public readonly scope: Scope
+    ) {
+        super();
+    }
+
+    public async getScope() {
+        let parts: string[] = this.path.split('.');
+        parts = parts.splice(0, parts.length - 1);
+        const qResult = await DOM.instance.eval(parts.join('.'));
+        return qResult.length === 1 ? qResult[0].scope : qResult.map((dobj) => dobj.scope);
+    }
+
+    public async getKey() {
+        const parts: string[] = this.path.split('.');
+        return parts[parts.length - 1];
+    }
+
+    public async getValue() {
+        return await DOM.instance.eval(this.path);
+    }
+}

package/src/Scope/ScopeData.ts

@@ -0,0 +1,21 @@
+import {ScopeDataAbstract} from "./ScopeDataAbstract";
+
+export class ScopeData extends ScopeDataAbstract {
+    constructor() {
+        super();
+        const properties = this.__properties__.splice(0, this.__properties__.length);
+        for(const property of properties) {
+            (function(_self, name) {
+                if(!_self['__'+name+'__'])
+                    return;
+
+                _self.__properties__.push(name);
+                const _property = _self['__'+name+'__'],
+                    propertyType = _property[0],
+                    config = _property[1] || {};
+
+                _self.createProperty(name, propertyType, config);
+            })(this, property);
+        }
+    }
+}

package/src/Scope/ScopeDataAbstract.ts

@@ -0,0 +1,126 @@
+import {IPropertyConfig, Property} from "./properties/Property";
+import {EventDispatcher} from "../EventDispatcher";
+
+export interface IScopeData {
+    [key: string]: any;
+}
+
+export class ScopeDataAbstract extends EventDispatcher {
+    [key: string]: any;
+    __properties__: string[];
+    protected _lastData: any;
+
+    constructor() {
+        super();
+
+        // Objects may have __properties__ from prototype
+        if(!this['__properties__'])
+            this.__properties__ = [];
+    }
+
+    createProperty(name: string, propertyType = Property, config?: IPropertyConfig): Property {
+        config = config || {};
+        const instance = new propertyType(config.default, config),
+            propDesc = Object.getOwnPropertyDescriptor(this, name);
+        this['__'+name] = instance;
+
+        // property getter
+        const propertyGetter = function() {
+            return instance.value;
+        };
+        const getter = propDesc ? propDesc.get : propertyGetter,
+            propertySetter = function(newVal: any) {
+                instance.value = newVal;
+            },
+            setter = propDesc ? propDesc.set : propertySetter;
+
+        // Delete the original property
+        delete this[name];
+
+        // Create new property with getter and setter
+        Object.defineProperty(this, name, {
+            get: getter,
+            set: setter,
+            enumerable: true,
+            configurable: true
+        });
+
+        instance.on('change', (...args: any[]) => {
+            this.dispatch('change', name, ...args);
+            this.dispatch('change:' + name, ...args);
+        });
+        return instance;
+    }
+
+    hasProperty(name: string): boolean {
+        return this.__properties__.indexOf(name) !== -1;
+    }
+
+    get keys(): string[] {
+        return [...this.__properties__];
+    }
+
+    setData(data: IScopeData) {
+        const properties = this.getProperties();
+        for (const key in data) {
+            if (properties.indexOf(key) > -1) {
+                this[key] = data[key];
+            }
+        }
+    }
+
+    getData(): IScopeData {
+        const data: IScopeData = {};
+        for (const key of this.getProperties()) {
+            const property = this['__'+key];
+            if(this[key] == null || !property)
+                continue;
+
+            data[key] = property.getData();
+        }
+        return data;
+    }
+
+    getProperties(): string[] {
+        return this.__properties__;
+    }
+
+    getProperty(name: string, create: boolean = false): Property {
+        let property = this['__'+name];
+        if (create && !property) {
+            property = this.createProperty(name);
+        }
+        return property;
+    }
+
+    bindToProperties(event:string, properties:string[], callback: (...args: any[]) => any) {
+        for(const name of properties) {
+            const _property = this['__'+ name];
+            if(_property)
+                _property.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.getProperties()) {
+            if(nData[key] != oData[key])
+                return true;
+        }
+        return false;
+    }
+}

package/src/Scope/ScopeReference.ts

@@ -0,0 +1,30 @@
+import {Scope} from "../Scope";
+
+
+export class ScopeReference {
+    private _scope: Scope;
+    private _key: string;
+    private _value: any;
+
+    constructor(
+        scope: Scope = null,
+        key: string = null,
+        value: any = null
+    ) {
+        this._scope = scope;
+        this._key = key;
+        this._value = value;
+    }
+
+    public async getScope() {
+        return this._scope;
+    }
+
+    public async getKey() {
+        return this._key;
+    }
+
+    public async getValue() {
+        return this._value;
+    }
+}