vsn 0.1.27 → 0.1.30

package/src/Controller.ts

@@ -1,8 +1,8 @@
 import {Scope} from "./Scope";
 import {Tag} from "./Tag";
-import {EventDispatcher} from "./EventDispatcher";
+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/EventDispatcher.ts

@@ -31,6 +31,7 @@ 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() {
@@ -39,9 +40,21 @@ export class EventDispatcher  {
         EventDispatcher.sources.push(this);
     }
 
-    deconstructor() {
+    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 {
@@ -98,20 +111,24 @@ export class EventDispatcher  {
     }
 
     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];
+        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--;
+                }
 
-            // 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);
             }
+        }
 
-            cb.call(args);
+        for (const relay of this._relays) {
+            relay.dispatch(event, ...args);
         }
     }
 }

package/src/MessageList.ts

@@ -2,7 +2,7 @@ export interface IMessageHash {
     [key: string]: string[] | null | undefined;
 }
 
-export default class MessageList {
+export class MessageList {
     [key: string]: any; // We're trying to mimic a basic object
 
     private _cachedList: IMessageHash | undefined;
@@ -78,4 +78,8 @@ export default class MessageList {
     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

@@ -1,28 +1,14 @@
+import {MessageList} from "./MessageList";
+import {ScopeData} from "./Scope/ScopeData";
+import {IScopeData} from "./Scope/ScopeDataAbstract";
 
-import {ModelAbstract, ModelData} from "./Model/ModelAbstract";
-import MessageList from "./MessageList";
 
-
-export class Model extends ModelAbstract {
+export class Model extends ScopeData {
     _errors!: MessageList;
     _hasErrors: boolean;
 
-    constructor(data: ModelData | null | undefined = null) {
+    constructor(data: IScopeData | 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)
@@ -36,10 +22,10 @@ export class Model extends ModelAbstract {
     validate(): MessageList {
         this._hasErrors = false;
         this._errors = new MessageList;
-        for(const field of this.getFields()) {
-            const errors = this['__'+field].validate();
+        for(const property of this.getProperties()) {
+            const errors = this['__'+property].validate();
             if(errors.length > 0) {
-                this._errors.add(field, errors, true);
+                this._errors.add(property, errors, true);
                 this._hasErrors = true;
             }
         }

package/src/Registry.ts

@@ -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/{Model/DataModel.ts → Scope/DynamicScopeData.ts}

@@ -1,29 +1,27 @@
-import {ModelAbstract, ModelData} from "./ModelAbstract";
+import {IScopeData, ScopeDataAbstract} from "./ScopeDataAbstract";
 
-export class DataModel extends ModelAbstract {
-    constructor(data: ModelData | string[]) {
+export class DynamicScopeData extends ScopeDataAbstract {
+    constructor(data: IScopeData | string[]) {
         super();
         if(data instanceof Array) {
-            this.__fields__ = data;
             for (const field of data)
-                this.createField(field);
+                this.createProperty(field);
         } else {
             this.setData(data);
         }
     }
 
-    setData(data: ModelData) {
+    setData(data: IScopeData) {
         for(const field of Object.keys(data))
-            if(this.__fields__.indexOf(field) == -1) {
-                this.__fields__.push(field);
-                this.createField(field);
+            if(!this.hasProperty(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.createField(event.substr(7));
+            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,127 @@
+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;
+        this.__properties__.push(name);
+
+        // 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;
+    }
+}

package/src/Scope/ScopedVariableType.ts

@@ -0,0 +1,7 @@
+
+export class ScopeVariableType {
+    public static readonly Integer: string = 'integer';
+    public static readonly Float: string = 'float';
+    public static readonly Boolean: string = 'boolean';
+    public static readonly String: string = 'string';
+}

package/src/Scope/WrappedArray.ts

@@ -0,0 +1,88 @@
+import {EventDispatcher, EventDispatcherCallback} from "../EventDispatcher";
+
+export class WrappedArray<T> extends Array<T> {
+    private dispatcher: EventDispatcher;
+    public readonly $wrapped: boolean = true;
+
+    constructor(...items: T[]) {
+        super(...items);
+        Object.setPrototypeOf(this, WrappedArray.prototype);
+        this.dispatcher = new EventDispatcher();
+    }
+
+    dispatch(event: string, ...args: any[]) {
+        this.dispatcher.dispatch(event, ...args);
+    }
+
+    on(event: string, callback: EventDispatcherCallback) {
+        this.dispatcher.on(event, callback);
+    }
+
+    off(event: string, key?: number) {
+        this.dispatcher.off(event, key);
+    }
+
+    once(event: string, callback: EventDispatcherCallback) {
+        this.dispatcher.once(event, callback);
+    }
+
+    push(...items: T[]): number {
+        const num: number = super.push(...items);
+
+        this.dispatch('push', ...items);
+        this.dispatch('change', {
+            'added': items
+        });
+        for (const item of items) {
+            this.dispatch('add', item);
+        }
+        return num;
+    }
+
+    splice(start: number, deleteCount?: number): T[] {
+        const removed: T[] = super.splice(start, deleteCount);
+
+        this.dispatch('change', {
+            'removed': removed
+        });
+        for (const item of removed) {
+            this.dispatch('remove', item);
+        }
+
+        return removed;
+    }
+
+    get(key: string) {
+        const keys: string[] = [
+            'length'
+        ];
+        return keys.indexOf(key) > -1 ? this[key] : undefined;
+    }
+
+    get length(): number {
+        let c: number = 0;
+        for (const item of this) {
+            c += 1;
+        }
+        return c;
+    }
+
+    set length(num: number) {
+        this.setLength(num);
+    }
+
+    setLength(num: number) {
+        let c: number = 0;
+        const toRemove: T[] = [];
+        for (const item of this) {
+            c += 1;
+            if (c >= num) {
+                toRemove.push(item);
+            }
+        }
+
+        for (const item of toRemove) {
+            this.splice(this.indexOf(item), 1);
+        }
+    }
+}

package/src/Scope/properties/Property.ts

@@ -0,0 +1,79 @@
+import {EventDispatcher} from "../../EventDispatcher";
+import {Registry} from "../../Registry";
+
+export function property(propertyType = Property, config: {} | null = {}) {
+    return function(target: any, key: string) {
+        if(target.__properties__ == undefined) {
+            target.__properties__ = [];
+        }
+
+        // Abstract/extended classes share __properties__
+        if(target.__properties__.indexOf(key) == -1)
+            target.__properties__.push(key);
+
+        const getter = function() {
+            return [propertyType, config];
+        };
+
+        Object.defineProperty(target, '__'+key+'__', {
+            get: getter,
+            set: v => {},
+            enumerable:false,
+            configurable: true
+        });
+    }
+}
+
+export interface IPropertyConfig {
+    type?: string;
+    default?: any;
+}
+
+export class Property extends EventDispatcher {
+    _type: string = 'any';
+    _value: any;
+    config: IPropertyConfig;
+
+    constructor(value?:any, config?: IPropertyConfig) {
+        super();
+        this.config = config;
+        this.type = config.type || 'any';
+
+        this.value = value;
+    }
+
+    castType(value) {
+        const caster = Registry.instance.types.getSynchronous(this.type);
+        return caster(value);
+    }
+
+    set value(v:any) {
+        const oldValue = this._value;
+        this._value = this.castType(v);
+        if (this._value !== oldValue) {
+            this.dispatch('change', {
+                oldValue:oldValue,
+                value:v
+            });
+        }
+    }
+
+    get value() {
+        return this._value;
+    }
+
+    getData() {
+        return this.value;
+    }
+
+    set type(type: string) {
+        if (this._type != type) {
+            this._type = type;
+            this.value = this.value; // Need to reset value to have it cast to the new type
+        }
+    }
+
+    get type(): string {
+        return this._type;
+    }
+}