vsn 0.1.149 → 1.0.1

package/src/Scope/ScopeData.ts

@@ -1,20 +0,0 @@
-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;
-
-                const _property = _self['__'+name+'__'],
-                    propertyType = _property[0],
-                    config = _property[1] || {};
-
-                _self.createProperty(name, propertyType, config);
-            })(this, property);
-        }
-    }
-}

package/src/Scope/ScopeDataAbstract.ts

@@ -1,200 +0,0 @@
-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[];
-    __methods__: string[];
-    protected _lastData: any;
-
-    constructor() {
-        super();
-
-        // Objects may have __properties__ from prototype
-        if(!this['__properties__'])
-            this.__properties__ = [];
-
-        if(!this['__methods__'])
-            this.__methods__ = [];
-    }
-
-    deconstruct() {
-        super.deconstruct();
-        this._lastData = null;
-        for (const prop of Array.from(this.__properties__)) {
-            this.removeProperty(prop);
-        }
-        this.__properties__.length = 0;
-
-        for (const prop of Array.from(this.__methods__)) {
-            this.removeMethod(prop);
-        }
-        this.__methods__.length = 0;
-    }
-
-    createMethod(name: string, method: (...args: any[]) => any) {
-
-    }
-
-    createProperty(name: string, propertyType: any = Property, config?: IPropertyConfig): any {
-        if (this.hasProperty(name)) {
-            return this.getProperty(name);
-        }
-
-        config = config || {};
-        const instance = new propertyType(config.default, config);
-        const 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;
-    }
-
-    removeProperty(key: string) {
-        const index = this.__properties__.indexOf(key);
-        if (index > -1)
-            this.__properties__.splice(index, 1);
-
-        const prop = this['__'+key];
-        if (prop) {
-            prop.deconstruct();
-            delete this['__' + key];
-        }
-
-        delete this[key];
-    }
-
-    removeMethod(key: string) {
-        const index = this.__methods__.indexOf(key);
-        if (index > -1)
-            this.__methods__.splice(index, 1);
-
-        delete this['__' + key];
-        delete this[key];
-    }
-
-    hasProperty(name: string): boolean {
-        return this.__properties__.indexOf(name) !== -1;
-    }
-
-    get keys(): string[] {
-        return [...this.__properties__];
-    }
-
-    getKeys(...tags: string[]): string[] {
-        const keys = [];
-        for (const key of this.keys) {
-            const property = this.getProperty(key);
-            if (property.hasLabels(tags)) {
-                keys.push(key);
-            }
-        }
-        return keys;
-    }
-
-    setData(data: IScopeData) {
-        const properties = this.getProperties();
-        for (const key in data) {
-            if (properties.indexOf(key) > -1) {
-                this[key] = data[key];
-            }
-        }
-    }
-
-    getData(...tags: string[]): IScopeData {
-        const data: IScopeData = {};
-        propLoop: for (const key of this.getProperties()) {
-            const property = this['__'+key];
-            for (const tag of tags) {
-                if (!property.hasLabel(tag))
-                    continue propLoop;
-            }
-
-            if(this[key] == null || !property)
-                continue;
-
-            data[key] = property.clean();
-        }
-        return data;
-    }
-
-    public get(key: string) {
-        return this[key];
-    }
-
-    public set(key: string, value: any) {
-        this[key] = value;
-    }
-
-    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/ScopeObject.ts

@@ -1,3 +0,0 @@
-import {ScopeData} from "./ScopeData";
-
-export class ScopeObject extends ScopeData {}

package/src/Scope/ScopeReference.ts

@@ -1,30 +0,0 @@
-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

@@ -1,7 +0,0 @@
-
-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

@@ -1,134 +0,0 @@
-import {EventDispatcher, EventDispatcherCallback} from "../EventDispatcher";
-
-export class WrappedArray<T> extends Array<T> {
-    public readonly 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, ctx?: any) {
-        this.dispatcher.on(event, callback, ctx);
-    }
-
-    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;
-    }
-
-    remove(item: T): boolean {
-        const index: number = this.indexOf(item);
-        if (index === -1) {
-            return false;
-        }
-        this.splice(index, 1);
-        return true;
-    }
-
-    pop(): T {
-        const item: T = super.pop();
-        this.dispatch('pop', item);
-        this.dispatch('change', {
-            'removed': [item]
-        });
-        this.dispatch('remove', item);
-        return item;
-    }
-
-    shift(): T {
-        const item: T = super.shift();
-        this.dispatch('shift', item);
-        this.dispatch('change', {
-            'removed': [item]
-        });
-        this.dispatch('remove', item);
-        return item;
-    }
-
-    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;
-    }
-
-    concat(...items: any[]): T[] {
-        const concat: T[] = super.concat(...items);
-
-        this.dispatch('change', {
-            'added': concat
-        });
-        for (const item of concat) {
-            this.dispatch('add', item);
-        }
-        return concat;
-    }
-
-    filter(callback: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[] {
-        const filtered: T[] = super.filter(callback, thisArg);
-        return new WrappedArray(...filtered);
-    }
-
-    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/ArrayProperty.ts

@@ -1,46 +0,0 @@
-import {IPropertyConfig, Property} from "./Property";
-import {WrappedArray} from "../WrappedArray";
-
-export class ArrayProperty<T = any> extends Property<WrappedArray<T>> {
-    _value: WrappedArray<T>;
-    allKey: number;
-
-    constructor(value?: any, config?: IPropertyConfig) {
-        super(new WrappedArray<any>(), config);
-        this.allKey = this._value.dispatcher.all(this.relayEvent.bind(this), this);
-        if (value !== undefined) {
-            this.value = value;
-        }
-    }
-
-    deconstruct() {
-        this._value.dispatcher.none(this.allKey);
-        super.deconstruct();
-    }
-
-    relayEvent(event, ...args) {
-        this.dispatch('change', ...args);
-    }
-
-    set value(v: any) {
-        if (!(v instanceof Array))
-            v = [v];
-
-        if (this._value instanceof WrappedArray) {
-            this._value.splice(0, this._value.length);
-
-            for (let i = 0; i < v.length; i++)
-                this._value.push(v[i]);
-        } else if (v instanceof WrappedArray) {
-            this._value = v;
-        }
-    }
-
-    get value() {
-        return this._value;
-    }
-
-    clean() {
-        return Array.from(this._value);
-    }
-}

package/src/Scope/properties/FloatProperty.ts

@@ -1,5 +0,0 @@
-import {Property} from "./Property";
-
-export class FloatProperty extends Property {
-    _type: string = 'float';
-}

package/src/Scope/properties/IntegerProperty.ts

@@ -1,5 +0,0 @@
-import {Property} from "./Property";
-
-export class IntegerProperty extends Property {
-    _type: string = 'integer';
-}

package/src/Scope/properties/Property.ts

@@ -1,173 +0,0 @@
-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 function method(config: {} | null = {}) {
-    return function(target: any, key: string) {
-        if(target.__methods__ == undefined) {
-            target.__methods__ = [];
-        }
-
-        // Abstract/extended classes share __properties__
-        if(target.__methods__.indexOf(key) == -1)
-            target.__methods__.push(key);
-
-        const getter = function() {
-            return config;
-        };
-
-        Object.defineProperty(target, '__'+key+'__', {
-            get: getter,
-            set: v => {},
-            enumerable:false,
-            configurable: true
-        });
-    }
-}
-
-export type TValidator = (value: any) => string[];
-
-export interface IPropertyConfig {
-    type?: string;
-    default?: any;
-    validators?: TValidator[];
-    labels?: string[];
-}
-
-export class Property<T = any> extends EventDispatcher {
-    _type: string = 'any';
-    _value: T;
-    config: IPropertyConfig;
-
-    constructor(value?: T, config?: IPropertyConfig) {
-        super();
-        this.config = config;
-        if (!this.config.labels)
-            this.config.labels = [];
-        if (!this.config.validators)
-            this.config.validators = [];
-        this.type = config.type || 'any';
-        this.value = value;
-    }
-
-    deconstruct() {
-        super.deconstruct();
-        delete this._type;
-        delete this._value;
-        this.config = {};
-    }
-
-    castType(value) {
-        const caster = Registry.instance.types.getSynchronous(this.type);
-        return caster ? caster(value) : 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;
-    }
-
-    clean() {
-        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;
-    }
-
-    validate() {
-        const errors = [];
-        for(const validator of this.config.validators || []) {
-            errors.concat(validator(this.value));
-        }
-
-        return errors;
-    }
-
-    getValidator(id: string) {
-        const validator = Registry.instance.validators.getSynchronous(id) as TValidator;
-        if (!validator)
-            throw new Error(`Invalid validator ${id}`);
-        return validator;
-    }
-
-    addValidator(validator: TValidator | string) {
-        if (typeof validator == 'string') {
-            validator = this.getValidator(validator);
-        }
-
-        if (this.config.validators.indexOf(validator) == -1)
-            this.config.validators.push(validator);
-    }
-
-    addLabel(label: string) {
-        if(this.config.labels == undefined) {
-            this.config.labels = [];
-        }
-        if(this.config.labels.indexOf(label) == -1) {
-            this.config.labels.push(label);
-        }
-    }
-
-    removeLabel(label: string) {
-        if(this.config.labels == undefined) {
-            return;
-        }
-        const index = this.config.labels.indexOf(label);
-        if(index != -1) {
-            this.config.labels.splice(index, 1);
-        }
-    }
-
-    hasLabel(label: string) {
-        return this.config.labels.indexOf(label) !== -1;
-    }
-
-    hasLabels(labels: string[]) {
-        for(const label of labels) {
-            if(!this.hasLabel(label)) {
-                return false;
-            }
-        }
-        return true;
-    }
-}

package/src/Scope/properties/_imports.ts

@@ -1,4 +0,0 @@
-export {Property, property, IPropertyConfig} from './Property';
-export {ArrayProperty} from './ArrayProperty';
-export {IntegerProperty} from './IntegerProperty';
-export {FloatProperty} from './FloatProperty';