vsn 0.1.26 → 0.1.29

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;
+    }
+}

package/src/Scope.ts

@@ -1,218 +1,15 @@
-import {DataModel, Model} from "simple-ts-models";
-import {EventCallback, EventCallbackList, EventDispatcher, EventDispatcherCallback} from "simple-ts-event-dispatcher";
-import {Registry} from "./Registry";
-import {DOM} from "./DOM";
+import {EventDispatcher} from "./EventDispatcher";
+import {ScopeReference} from "./Scope/ScopeReference";
+import {QueryReference} from "./Scope/QueryReference";
+import {WrappedArray} from "./Scope/WrappedArray";
+import {ScopeData} from "./Scope/ScopeData";
+import {DynamicScopeData} from "./Scope/DynamicScopeData";
 
-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;
-    }
-}
-
-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);
-    }
-}
-
-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';
-}
-
-export class WrappedArray<T> extends Array<T> {
-    private _listeners: EventCallbackList;
-    private _lastKey: number;
-    public readonly $wrapped: boolean = true;
-
-    constructor(...items: T[]) {
-        super(...items);
-        Object.setPrototypeOf(this, WrappedArray.prototype);
-        this._lastKey = 0;
-        this._listeners = {};
-    }
-
-    push(...items: T[]): number {
-        const num: number = super.push(...items);
-
-        this.trigger('push', ...items);
-        this.trigger('change', {
-            'added': items
-        });
-        for (const item of items) {
-            this.trigger('add', item);
-        }
-        return num;
-    }
-
-    splice(start: number, deleteCount?: number): T[] {
-        const removed: T[] = super.splice(start, deleteCount);
-
-        this.trigger('change', {
-            'removed': removed
-        });
-        for (const item of removed) {
-            this.trigger('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);
-        }
-    }
-
-    bind(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.bind(event, fct, context, true);
-    }
-
-    unbind(event: string, key?: number): boolean {
-        if(!(event in this._listeners)) 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;
-    }
-
-    unbindWithContext(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;
-        }
-    }
-
-    trigger(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.unbind(event, cb.key);
-                i--;
-            }
-
-            cb.call(args);
-        }
-    }
-}
 
 export class Scope extends EventDispatcher {
     public wrapped: any;
-    protected data: DataModel;
-    protected types: {[key: string]: string;} = {};
+    protected data: ScopeData;
     protected children: Scope[];
-    protected _keys: string[];
     protected _parentScope: Scope;
 
     constructor(
@@ -222,8 +19,8 @@ export class Scope extends EventDispatcher {
         if (parent)
             this.parentScope = parent;
         this.children = [];
-        this.data = new DataModel({});
-        this._keys = [];
+        this.data = new DynamicScopeData({});
+        this.data.addRelay(this);
     }
 
     public get parentScope(): Scope {
@@ -283,54 +80,30 @@ export class Scope extends EventDispatcher {
     }
 
     set(key: string, value: any) {
-        if (this.data[key] === undefined)
-            this.data.createField(key);
-
-        if (typeof value === 'string') {
-            const valueType = this.getType(key);
-            const caster = Registry.instance.types.getSynchronous(valueType);
-            if (caster) {
-                value = caster(value);
-            }
-
-            if ([ScopeVariableType.Integer, ScopeVariableType.Float].indexOf(valueType) > -1 && isNaN(value)) {
-                value = null;
-            }
-        }
+        if (!this.data.hasProperty(key))
+            this.data.createProperty(key);
 
-        if (this.data[key] !== value) {
-            const previousValue = this.data[key];
-            this.data[key] = value;
-            const event = {
-                value: value,
-                previousValue: previousValue,
-                key: key
-            };
-
-            this.trigger(`change:${key}`, event);
-            this.trigger('change', key, event);
-        }
-
-        if (this._keys.indexOf(key) === -1)
-            this._keys.push(key);
+        this.data[key] = value;
     }
 
     get keys(): string[] {
-        return [...this._keys];
+        return this.data.keys;
     }
 
     has(key: string): boolean {
-        return this._keys.indexOf(key) > -1;
+        return this.data.hasProperty(key);
     }
 
     setType(key: string, type: string) {
-        this.types[key] = type;
+        const property = this.data.getProperty(key, true);
+        property.type = type;
         if (this.has(key))
             this.set(key, this.get(key));
     }
 
     getType(key: string): string {
-        return this.types[key] || ScopeVariableType.String;
+        const property = this.data.getProperty(key);
+        return property.type;
     }
 
     extend(data) {
@@ -340,7 +113,7 @@ export class Scope extends EventDispatcher {
     }
 
     clear() {
-        for (const key of this._keys) {
+        for (const key of this.data.keys) {
             if (['function', 'object'].indexOf(typeof this.get(key)) > -1) continue;
             this.set(key, null);
         }
@@ -352,8 +125,14 @@ export class Scope extends EventDispatcher {
     }
 
     public wrap(toWrap: any, triggerUpdates: boolean = false, updateFromWrapped: boolean = true) {
-        if (toWrap instanceof Model) {
+        if (toWrap instanceof ScopeData) {
+            if (this.data instanceof EventDispatcher) {
+                this.data.removeRelay(this);
+                this.data.deconstruct();
+            }
+            this.wrapped = toWrap;
             this.data = toWrap;
+            this.data.addRelay(this);
             return;
         }
 
@@ -386,8 +165,8 @@ export class Scope extends EventDispatcher {
                 if (!(this.wrapped[field] instanceof WrappedArray)) {
                     this.wrapped[field] = new WrappedArray(...toWrap[field]);
                 }
-                this.wrapped[field].bind('change', (...args) => {
-                    this.trigger(`change:${field}`, ...args);
+                this.wrapped[field].on('change', (...args) => {
+                    this.dispatch(`change:${field}`, ...args);
                 })
             }
 
@@ -418,14 +197,14 @@ export class Scope extends EventDispatcher {
             });
 
             if (triggerUpdates)
-                this.trigger(`change:${field}`);
+                this.dispatch(`change:${field}`);
         }
 
         this.wrapped.get = this.get.bind(this);
         this.wrapped.set = this.set.bind(this);
-        this.wrapped.bind = this.bind.bind(this);
+        this.wrapped.on = this.on.bind(this);
         this.wrapped.once = this.once.bind(this);
-        this.wrapped.unbind = this.unbind.bind(this);
+        this.wrapped.off = this.off.bind(this);
     }
 
     public unwrap(): void {