vsn 0.1.149 → 1.0.0

package/src/EventDispatcher.ts

@@ -1,234 +0,0 @@
-
-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;
-    }
-
-    deconstruct() {
-        const self = this as any;
-        self.fnc = null;
-        self.context = null;
-    }
-}
-
-export type EventDispatcherCallback = (...args: any[]) => any;
-
-
-export class EventDispatcher  {
-    private static sources: EventDispatcher[] = [];
-    public static readonly stream: EventDispatcher = new EventDispatcher();
-    private readonly _listeners: EventCallbackList;
-    private readonly _allListeners: EventCallback[] = [];
-    private readonly _relays: EventDispatcher[] = [];
-    private _lastKey: number;
-
-    constructor() {
-        this._lastKey = 0;
-        this._listeners = {};
-        EventDispatcher.sources.push(this);
-    }
-
-    deconstruct() {
-        this.dispatch('deconstruct', this);
-        const sourceIndex = EventDispatcher.sources.indexOf(this);
-        if (sourceIndex > -1) {
-            EventDispatcher.sources.splice(sourceIndex, 1);
-        }
-
-        for (const k in this._listeners) {
-            for (const cb of this._listeners[k]) {
-                cb.deconstruct();
-            }
-            delete this._listeners[k];
-        }
-
-        for (const cb of this._allListeners) {
-            cb.deconstruct();
-        }
-        (this as any)._listeners = {};
-        this._relays.length = 0;
-        this._allListeners.length = 0;
-
-        for (const source of EventDispatcher.sources) {
-            source.removeRelay(this);
-            source.noneWithContext(this);
-        }
-    }
-
-    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);
-    }
-
-    promise(event: string, ...args: any[]): Promise<any> {
-        return new Promise((resolve, reject) => {
-            this.once(event, (...args) => {
-                resolve(args);
-            }, null);
-        });
-    }
-
-    off(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;
-    }
-
-    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;
-        }
-    }
-
-    all(fct: EventDispatcherCallback, context?: any, once?: boolean): number {
-        once = once || false;
-        this._lastKey++;
-        this._allListeners.push(new EventCallback(fct, this._lastKey, once, context));
-        return this._lastKey;
-    }
-
-    none(key: number): boolean {
-        for(const cb of this._allListeners) {
-            if(key == cb.key) {
-                this._allListeners.splice(this._allListeners.indexOf(cb), 1);
-                return true;
-            }
-        }
-        return false;
-    }
-
-    noneWithContext(context: any): number {
-        const toRemoveAll: EventCallback[] = [];
-        let cnt = 0;
-
-        for (const cb of this._allListeners) {
-            if(context == cb.context) {
-                toRemoveAll.push(cb);
-            }
-        }
-
-        for (const k in this._listeners) {
-            const toRemove: EventCallback[] = [];
-
-            for (const cb of this._listeners[k]) {
-                if(context == cb.context) {
-                    toRemove.push(cb);
-                }
-            }
-
-            for (const cb of toRemove) {
-                this._listeners[k].splice(this._listeners[k].indexOf(cb), 1);
-                cnt++;
-            }
-        }
-
-        for (const cb of toRemoveAll) {
-            this._allListeners.splice(this._allListeners.indexOf(cb), 1);
-            cnt++;
-        }
-
-        return cnt;
-    }
-
-    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 cb of this._allListeners) {
-            if (cb.once) {
-                this.none(cb.key);
-            }
-            cb.call(args);
-        }
-
-        for (const relay of this._relays) {
-            relay.dispatch(event, ...args);
-        }
-
-        if (this === EventDispatcher.stream)
-            return;
-
-        let streamArgs = args;
-        if (args.length > 0 && args[0] !== this)
-            streamArgs = [this, ...args];
-        EventDispatcher.stream.dispatch(event, ...streamArgs);
-    }
-}

package/src/Formats.ts

@@ -1,33 +0,0 @@
-import {Registry} from "./Registry";
-import {Configuration} from "./Configuration";
-
-export class Formats {
-    protected static CurrencyFormatter: Intl.NumberFormat;
-
-    @Registry.format('currency')
-    public static currency(value: string | number) {
-        if (!Formats.CurrencyFormatter) {
-            const setup = () => {
-                const locale: string = Configuration.get('locale', 'en-US') as string;
-                const currency: string = Configuration.get('currency', 'USD') as string;
-                Formats.CurrencyFormatter = new Intl.NumberFormat(locale, {
-                  style: 'currency',
-                  currency: currency
-                });
-            };
-            Configuration.instance.on('change:locale', setup);
-            Configuration.instance.on('change:currency', setup);
-            setup();
-        }
-        value = `${value}`.replace(/[^0-9.]+/, '');
-        value = parseFloat(value);
-        if (isNaN(value))
-            return '';
-        return Formats.CurrencyFormatter.format(value);
-    }
-
-    @Registry.format('date')
-    public static date(value: Date | string | number) {
-        return value ? value.toLocaleString() : '';
-    }
-}

package/src/MessageList.ts

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

@@ -1,44 +0,0 @@
-import {MessageList} from "./MessageList";
-import {ScopeData} from "./Scope/ScopeData";
-import {IScopeData} from "./Scope/ScopeDataAbstract";
-import {Registry} from "./Registry";
-
-@Registry.model('Model')
-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/Modifiers.ts

@@ -1,54 +0,0 @@
-
-export class Modifier {
-    public readonly name: string;
-    public readonly arguments: string[];
-
-    constructor(modifier: string) {
-        const [name, ...args] = modifier.split(',');
-        this.name = name;
-        this.arguments = args;
-    }
-
-    public getArguments(fallback: string[] = []): string[] {
-        return this.arguments.length ? this.arguments : fallback;
-    }
-}
-
-export class Modifiers {
-    protected modifiers: Map<string, Modifier> = new Map<string, Modifier>();
-
-    constructor(modifiers: string[] = []) {
-        for (const modifier of modifiers) {
-            this.add(modifier);
-        }
-    }
-
-    public add(modifier: string) {
-        const m = new Modifier(modifier);
-        this.modifiers.set(m.name, m);
-    }
-
-    public has(name: string): boolean {
-        return this.modifiers.has(name);
-    }
-
-    public get(name: string): Modifier {
-        return this.modifiers.get(name);
-    }
-
-    public get iter(): Modifier[] {
-        return Array.from(this.modifiers.values());
-    }
-
-    public get names(): string[] {
-        return this.iter.map(m => m.name);
-    }
-
-    public get length(): number {
-        return this.modifiers.size;
-    }
-
-    public static fromAttribute(attribute: string): Modifiers {
-        return new Modifiers(attribute.split('|').splice(1));
-    }
-}

package/src/Query.ts

@@ -1,17 +0,0 @@
-import {TagList} from "./Tag/TagList";
-import {VisionHelper} from "./helpers/VisionHelper";
-import {DOM} from "./DOM";
-import {WrappedWindow} from "./DOM/WrappedWindow";
-import {WrappedDocument} from "./DOM/WrappedDocument";
-import {DOMObject} from "./DOM/DOMObject";
-
-export async function Query(selector: string, dom: DOM = null): Promise<TagList | DOMObject> {
-    if (VisionHelper.document) {
-        dom = dom || DOM.instance;
-        const tagList = await dom.get(selector, true);
-        if (tagList.length == 1 || tagList.length == 1 && (tagList[0] instanceof WrappedWindow || tagList[0] instanceof WrappedDocument))
-            return tagList[0];
-        return tagList;
-    }
-    return new TagList();
-}

package/src/Registry.ts

@@ -1,141 +0,0 @@
-import {EventDispatcher} from "./EventDispatcher";
-import {ClassNode} from "./AST/ClassNode";
-
-export function register(store: string, key: string = null, setup: () => void = null) {
-    return function(target: any, _key: string = null) {
-        key = key || target.prototype.constructor.name;
-        if (_key !== null)
-            target = target[_key];
-        Registry.instance[store].register(key, target);
-        if (setup)
-            setup();
-    }
-}
-
-export class RegistryStore<T = any> extends EventDispatcher {
-    private timeouts = {};
-    private readonly store: {[key: string]: T};
-
-    constructor(defaults = null) {
-        super();
-        this.store = defaults || {};
-    }
-
-    register(key: string, item: any) {
-        this.store[key] = item;
-        this.dispatch('register', key, item);
-        this.dispatch(`registered:${key}`, item);
-    }
-
-    get(key: string): Promise<any> {
-        return new Promise((resolve, reject) => {
-            if (!!this.store[key]) {
-            resolve(this.store[key]);
-        } else {
-            console.warn(`Waiting for ${key} to be registered.`);
-            this.timeouts[key] = setTimeout(() => {
-                console.warn(`RegistryStore.get timed out after 5 seconds trying to find ${key}. Make sure the item is registered.`);
-            }, 5000);
-            this.once(`registered:${key}`, (cls) => {
-                clearTimeout(this.timeouts[key]);
-                resolve(cls);
-            })
-        }
-        });
-    }
-
-    getSynchronous(key: string) {
-        return this.store[key];
-    }
-
-    has(key: string) {
-        return !!this.store[key];
-    }
-
-    get keys(): string[] {
-        return Object.keys(this.store);
-    }
-}
-
-export class Registry extends EventDispatcher {
-    protected static _instance: Registry;
-    public readonly tags: RegistryStore;
-    public readonly components: RegistryStore;
-    public readonly functions: RegistryStore;
-    public readonly controllers: RegistryStore;
-    public readonly classes: RegistryStore;
-    public readonly models: RegistryStore;
-    public readonly templates: RegistryStore;
-    public readonly services: RegistryStore;
-    public readonly types: RegistryStore;
-    public readonly validators: RegistryStore;
-    public readonly formats: RegistryStore;
-    public readonly attributes: RegistryStore;
-
-    constructor() {
-        super();
-        this.tags = new RegistryStore();
-        this.components = new RegistryStore();
-        this.functions = new RegistryStore();
-        this.controllers = new RegistryStore();
-        this.classes = new RegistryStore();
-        this.models = new RegistryStore();
-        this.templates = new RegistryStore<HTMLTemplateElement>();
-        this.services = new RegistryStore();
-        this.types = new RegistryStore();
-        this.validators = new RegistryStore();
-        this.formats = new RegistryStore();
-        this.attributes = new RegistryStore();
-    }
-
-    public static component(key: string = null, setup = null) {
-        return register('components', key, setup);
-    }
-
-    public static function(key: string = null, setup = null) {
-        return register('functions', key, setup);
-    }
-
-    public static class(cls: ClassNode) {
-        Registry.instance.classes.register(cls.fullSelector, cls);
-    }
-
-    public static controller(key: string = null, setup = null) {
-        return register('controllers', key, setup);
-    }
-
-    public static model(key: string = null, setup = null) {
-        return register('models', key, setup);
-    }
-
-    public static template(key: string = null, setup = null) {
-        return register('templates', key, setup);
-    }
-
-    public static service(key: string = null, setup = null) {
-        return register('services', key, setup);
-    }
-
-    public static type(key: string = null, setup = null) {
-        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);
-    }
-
-    public static attribute(attributeName: string = null, setup = null) {
-        return register('attributes', attributeName, setup);
-    }
-
-    public static get instance() {
-        if (!Registry._instance)
-            Registry._instance = new Registry();
-
-        return Registry._instance;
-    }
-}

package/src/Scope/DynamicScopeData.ts

@@ -1,27 +0,0 @@
-import {IScopeData, ScopeDataAbstract} from "./ScopeDataAbstract";
-
-export class DynamicScopeData extends ScopeDataAbstract {
-    constructor(data: IScopeData | string[]) {
-        super();
-        if(data instanceof Array) {
-            for (const field of data)
-                this.createProperty(field);
-        } else {
-            this.setData(data);
-        }
-    }
-
-    setData(data: IScopeData) {
-        for(const field of Object.keys(data))
-            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.createProperty(event.substr(7));
-        return super.on(event, fct, context, once);
-    }
-}

package/src/Scope/ObjectAccessor.ts

@@ -1,21 +0,0 @@
-import {ScopeAbstract} from "./ScopeAbstract";
-
-export class ObjectAccessor extends ScopeAbstract {
-    public readonly data: any;
-
-    constructor(data: any) {
-        super();
-        this.data = data;
-    }
-
-    public get(field: string, fallback = null): any {
-        const value = this.data[field];
-        if (typeof value === 'object')
-            return new ObjectAccessor(value);
-        return value === undefined ? fallback : value;
-    }
-
-    public set(field: string, value: any): void {
-        this.data[field] = value;
-    }
-}

package/src/Scope/QueryReference.ts

@@ -1,29 +0,0 @@
-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.exec(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.exec(this.path);
-    }
-}

package/src/Scope/ScopeAbstract.ts

@@ -1,11 +0,0 @@
-import {EventDispatcher} from "../EventDispatcher";
-
-export interface IScope {
-    get(field: string, fallback?: any): any;
-    set(field: string, value: any): void;
-}
-
-export abstract class ScopeAbstract extends EventDispatcher implements IScope {
-    public abstract get(field: string, fallback?: any): any;
-    public abstract set(field: string, value: any): void;
-}