vsn 0.1.149 → 1.0.1

package/src/Types.ts

@@ -1,34 +0,0 @@
-import {Registry} from "./Registry";
-
-export class Types {
-    @Registry.type('any')
-    public static any(value: any): any {
-        return value as any;
-    }
-
-    @Registry.type('string')
-    public static string(value: string) {
-        return `${value}`;
-    }
-
-    @Registry.type('integer')
-    public static integer(value: string) {
-        return parseInt(value);
-    }
-
-    @Registry.type('float')
-    public static float(value: string) {
-        value = `${value}`.replace(/[^\d.]+/, '');
-        return parseFloat(value);
-    }
-
-    @Registry.type('boolean')
-    public static boolean(value: string) {
-        return [0, '0', false, 'false', ''].indexOf(value) === -1;
-    }
-
-    @Registry.type('date')
-    public static date(value: string) {
-        return new Date(Date.parse(value));
-    }
-}

package/src/Validators.ts

@@ -1,45 +0,0 @@
-import {Registry} from "./Registry";
-
-export class Validators {
-    public static readonly _emailRegex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
-
-    @Registry.validator('email')
-    public static email(value: any): string[] {
-        const errors: string[] = [];
-
-        if(value != null && !this._emailRegex.test(value))
-            errors.push('Please enter a valid email address');
-
-        return errors;
-    }
-
-    @Registry.validator('required')
-    public static required(value: any): string[] {
-        const errors: string[] = [];
-
-        if(value == null || value.length == 0)
-            errors.push('This field is required');
-
-        return errors;
-    }
-
-    @Registry.validator('positive')
-    public static positive(value: any): string[] {
-        const errors: string[] = [];
-
-        if(value != null && value < 0)
-            errors.push('Please enter a positive number');
-
-        return errors;
-    }
-
-    @Registry.validator('negative')
-    public static negative(value: any): string[] {
-        const errors: string[] = [];
-
-        if(value != null && value > 0)
-            errors.push('Please enter a negative number');
-
-        return errors;
-    }
-}

package/src/attributes/AddClassIf.ts

@@ -1,14 +0,0 @@
-import {If} from "./If";
-import {Registry} from "../Registry";
-
-@Registry.attribute('vsn-add-class-if')
-export class AddClassIf extends If {
-    async onChange() {
-        const result: boolean = await this.tree.evaluate(this.tag.scope, this.tag.dom, this.tag);
-        if (result) {
-            this.tag.element.classList.add(this.getAttributeBinding());
-        } else {
-            this.tag.element.classList.remove(this.getAttributeBinding());
-        }
-    }
-}

package/src/attributes/Bind.ts

@@ -1,144 +0,0 @@
-import {Scope} from "../Scope";
-import {Attribute} from "../Attribute";
-import {Tree} from "../AST";
-import {Registry} from "../Registry";
-import {ScopeReference} from "../Scope/ScopeReference";
-
-@Registry.attribute('vsn-bind')
-export class Bind extends Attribute {
-    public static readonly canDefer: boolean = false;
-    protected key?: string;
-    protected property?: string;
-    protected direction: string = 'both';
-    protected boundScope?: Scope;
-    protected formatter: (v: string) => string = (v) => v;
-
-    public async compile() {
-        const tree: Tree = new Tree(this.getAttributeValue());
-        await tree.prepare(this.tag.scope, this.tag.dom, this.tag);
-
-        await super.compile();
-    }
-
-    public async setup() {
-        this.property = this.getAttributeBinding(this.property);
-        const mods = this.getAttributeModifiers();
-        if (mods.length) {
-            if (mods.indexOf('from') > -1) {
-                this.direction = 'from';
-            } else if (mods.indexOf('to') > -1) {
-                this.direction = 'to';
-            }
-        }
-        await super.setup();
-    }
-
-    public async connect() {
-        let scopeKey: string = this.getAttributeValue();
-        let ref: ScopeReference;
-        try {
-            ref = this.tag.scope.getReference(scopeKey);
-        } catch (e) {
-            console.error('error', e);
-            return;
-        }
-
-        this.key = await ref.getKey();
-        this.boundScope = await ref.getScope();
-        if (!!this.valueFromElement)
-            this.updateFrom();
-
-        if (this.doUpdateTo) {
-            this.updateTo();
-            this.boundScope.on(`change:${this.key}`, this.updateTo, this);
-        }
-        await super.connect();
-    }
-
-    public async disconnect() {
-        this.boundScope.offWithContext(`change:${this.key}`, this);
-        await super.disconnect();
-    }
-
-    public async evaluate() {
-        const elementValue = this.valueFromElement;
-        if (!!elementValue)
-            this.updateFrom();
-        this.updateTo();
-        await super.evaluate();
-    }
-
-    public set value(v: any) {
-        if (this.boundScope) {
-            this.boundScope.set(this.key, v);
-        }
-    }
-
-    public get value(): any {
-        if (!this.boundScope) return null;
-        return this.boundScope.get(this.key, false);
-    }
-
-    get valueFromElement(): string {
-        let value;
-
-        if (this.property) {
-            value = this.tag.getElementAttribute(this.property);
-        } else {
-            value = this.tag.value;
-        }
-        return value;
-    }
-
-    public mutate(mutation: MutationRecord) {
-        super.mutate(mutation);
-        if (!this.doUpdateFrom) return;
-
-        // Element innerText binding
-        if (!this.property && [
-            'characterData',
-            'childList'
-        ].indexOf(mutation.type) > -1)
-            this.updateFrom();
-        // Input value binding
-        else if (!this.property && mutation.type == 'attributes' && mutation.attributeName === 'value')
-            this.updateFrom();
-        // Attribute binding
-        else if (mutation.type === 'attributes' && mutation.attributeName == this.property)
-            this.updateFrom();
-    }
-
-    public get doUpdateFrom(): boolean {
-        return ['both', 'to'].indexOf(this.direction) > -1;
-    }
-
-    updateFrom() {
-        if (!this.doUpdateFrom) return;
-        let valueFromElement = this.valueFromElement;
-        valueFromElement = typeof valueFromElement === 'string' && valueFromElement.trim() || valueFromElement;
-        let valueFromScope = this.value;
-        valueFromScope = typeof valueFromScope === 'string' && valueFromScope.trim() || valueFromScope;
-        valueFromScope = this.formatter(valueFromScope); // Apply format for comparison
-
-        if (!valueFromScope || valueFromElement != valueFromScope)
-            this.value = valueFromElement;
-    }
-
-    public get doUpdateTo(): boolean {
-        return ['both', 'from'].indexOf(this.direction) > -1;
-    }
-
-    updateTo() {
-        if (!this.doUpdateTo) return;
-        const value = this.formatter(this.value);
-        if (this.property) {
-            this.tag.setElementAttribute(this.property, value);
-        } else {
-            this.tag.value = value;
-        }
-    }
-
-    setFormatter(formatter) {
-        this.formatter = formatter;
-    }
-}

package/src/attributes/ComponentAttribute.ts

@@ -1,23 +0,0 @@
-import {Registry} from "../Registry";
-import {TemplateAttribute} from "./TemplateAttribute";
-import {Component} from "../Component";
-
-@Registry.attribute('vsn-component')
-export class ComponentAttribute extends TemplateAttribute {
-    public static readonly scoped: boolean = true;
-
-    public async extract() {
-        const name = this.getAttributeBinding();
-        if (!Registry.instance.tags.has(name)) {
-            await super.extract();
-            const clsName = this.getAttributeValue();
-            let cls;
-            if (clsName) {
-                cls = await Registry.instance.components.get(clsName);
-            }
-            if (!cls)
-                cls = class extends Component {};
-            Registry.instance.tags.register(name, cls);
-        }
-    }
-}

package/src/attributes/ControllerAttribute.ts

@@ -1,50 +0,0 @@
-import {Scope} from "../Scope";
-import {Attribute} from "../Attribute";
-import {Registry} from "../Registry";
-import {Controller} from "../Controller";
-import {Service} from "../Service";
-
-@Registry.attribute('vsn-controller')
-export class ControllerAttribute extends Attribute {
-    public static readonly canDefer: boolean = false;
-    public static readonly scoped: boolean = true;
-    public readonly registryName: string = 'controllers'
-    protected attributeKey: string;
-    protected className: string;
-    protected defaultClassName: string;
-
-    public async setup() {
-        this.attributeKey = this.getAttributeBinding();
-        this.className = this.getAttributeValue(this.defaultClassName);
-        const cls = await Registry.instance[this.registryName].get(this.className);
-
-        if (this.attributeKey) {
-            let clsScope: Scope;
-            // Singleton?
-            if (cls['instance'] instanceof cls) {
-                clsScope = cls['instance'].scope;
-                if (cls['instance'] instanceof Service) {
-                    this.tag.dom.root.scope.addChild(clsScope);
-                    this.tag.dom.root.scope.set(this.attributeKey, clsScope);
-                }
-            } else {
-                clsScope = new Scope(this.tag.scope);
-                const obj = new cls();
-                if (obj instanceof Controller) {
-                    obj.init(this.tag.scope, this.tag, this.tag.element);
-                }
-                clsScope.wrap(obj);
-            }
-
-            this.tag.scope.set(this.attributeKey, clsScope);
-        } else {
-            this.instantiateClass(cls);
-        }
-        await super.setup();
-    }
-
-    protected instantiateClass(cls): any {
-        this.tag.wrap(cls);
-        return this.tag.scope;
-    }
-}

package/src/attributes/DisableIf.ts

@@ -1,16 +0,0 @@
-import {If} from "./If";
-import {Registry} from "../Registry";
-
-@Registry.attribute('vsn-disable-if')
-export class DisableIf extends If {
-    public static readonly canDefer: boolean = false;
-
-    async onChange() {
-        const result: boolean = await this.tree.evaluate(this.tag.scope, this.tag.dom, this.tag);
-        if (result) {
-            this.tag.element.setAttribute('disabled', 'disabled');
-        } else {
-            this.tag.element.removeAttribute('disabled')
-        }
-    }
-}

package/src/attributes/Exec.ts

@@ -1,32 +0,0 @@
-import {Attribute} from "../Attribute";
-import {Tree} from "../AST";
-import {Registry} from "../Registry";
-
-@Registry.attribute('vsn-exec')
-export class Exec extends Attribute {
-    public static readonly canDefer: boolean = false;
-    protected tree: Tree;
-
-    public get code() {
-        return this.getAttributeValue();
-    }
-
-    public async compile() {
-        this.tree = new Tree(this.code);
-        await this.tree.prepare(this.tag.scope, this.tag.dom, this.tag);
-        await super.compile();
-    }
-
-    public async extract() {
-        if (this.hasModifier('defer')) {
-            this.tag.dom.once('built', () => this.execute());
-        } else {
-            await this.execute();
-        }
-        await super.extract();
-    }
-
-    public async execute() {
-        await this.tree.evaluate(this.tag.scope, this.tag.dom, this.tag);
-    }
-}

package/src/attributes/Format.ts

@@ -1,18 +0,0 @@
-import {Attribute} from "../Attribute";
-import {Registry} from "../Registry";
-import {Bind} from "./Bind";
-
-@Registry.attribute('vsn-format')
-export class Format extends Attribute {
-    public static readonly canDefer: boolean = false;
-
-    public async extract() {
-        const value = this.getAttributeValue(null);
-        const attribute = this.getAttributeBinding(null);
-        const formatter = await Registry.instance.formats.get(value);
-        const bindingKey = attribute ? `vsn-bind:${attribute}` : 'vsn-bind';
-        const binding: Bind = await this.tag.getAttribute<Bind>(bindingKey);
-        binding.setFormatter(formatter);
-        await super.extract();
-    }
-}

package/src/attributes/If.ts

@@ -1,40 +0,0 @@
-import {Attribute} from "../Attribute";
-import {Tree} from "../AST";
-import {Registry} from "../Registry";
-
-@Registry.attribute('vsn-if')
-export class If extends Attribute {
-    public static readonly canDefer: boolean = false;
-    protected tree: Tree;
-
-    public async compile() {
-        const statement: string = this.getAttributeValue();
-        this.tree = new Tree(statement);
-        await this.tree.prepare(this.tag.scope, this.tag.dom, this.tag);
-        await super.compile();
-    }
-
-    public async extract() {
-        await this.evaluate();
-        await super.extract();
-    }
-
-    public async connect() {
-        await this.tree.bindToScopeChanges(this.tag.scope, this.onChange.bind(this), this.tag.dom, this.tag);
-        await super.connect();
-    }
-
-    public async evaluate() {
-        await this.onChange();
-        await super.evaluate();
-    }
-
-    async onChange() {
-        const result: boolean = await this.tree.evaluate(this.tag.scope, this.tag.dom, this.tag);
-        if (result) {
-            this.tag.show();
-        } else {
-            this.tag.hide();
-        }
-    }
-}

package/src/attributes/JSONAttribute.ts

@@ -1,40 +0,0 @@
-import {Registry} from "../Registry";
-import {Attribute} from "../Attribute";
-import {Scope} from "../Scope";
-import {ScopeReference} from "../Scope/ScopeReference";
-
-@Registry.attribute('vsn-json')
-export class JSONAttribute extends Attribute {
-    public static readonly canDefer: boolean = false;
-
-    public async extract() {
-        let scopeKey: string = this.getAttributeBinding();
-        let ref: ScopeReference;
-        try {
-            ref = this.tag.scope.getReference(scopeKey);
-        } catch (e) {
-            console.error('error', e);
-            return;
-        }
-
-        const key = await ref.getKey();
-        const scope = await ref.getScope();
-
-        let json;
-        if (this.tag.element.tagName.toLowerCase() === 'script') {
-            json = this.tag.element.innerText;
-        } else {
-            json = unescape(this.getAttributeValue());
-        }
-        const data = JSON.parse(json);
-
-        if (data && typeof data === 'object' && data.constructor === Object) {
-            const newScope = new Scope(scope);
-            newScope.wrap(data);
-            scope.set(key, newScope);
-        } else {
-            scope.set(key, data);
-        }
-        await super.extract();
-    }
-}

package/src/attributes/KeyAbstract.ts

@@ -1,28 +0,0 @@
-import {On} from "./On";
-
-export abstract class KeyAbstract extends On {
-    protected specificKey: string = null;
-
-    public async compile() {
-        this.specificKey = this.getAttributeBinding();
-        await super.compile();
-    }
-
-    public async connect() {
-        this.tag.addEventHandler('keydown', this.modifiers, this.handleEvent, this);
-        await super.connect();
-    }
-
-    public async handleEvent(e) {
-        let triggerEvent: boolean = false;
-
-        if ([undefined, null, ''].indexOf(this.specificKey) === -1) {
-            if (e.key.toLowerCase() === this.specificKey || e.code.toLowerCase() === this.specificKey)
-                triggerEvent = true;
-        } else
-            triggerEvent = true;
-
-        if (triggerEvent)
-            await super.handleEvent(e);
-    }
-}

package/src/attributes/KeyDown.ts

@@ -1,10 +0,0 @@
-import {KeyAbstract} from "./KeyAbstract";
-import {Registry} from "../Registry";
-
-@Registry.attribute('vsn-key-down')
-export class KeyDown extends KeyAbstract {
-    public async connect() {
-        this.tag.addEventHandler('keydown', this.modifiers, this.handleEvent, this);
-        await super.connect();
-    }
-}

package/src/attributes/KeyUp.ts

@@ -1,10 +0,0 @@
-import {KeyAbstract} from "./KeyAbstract";
-import {Registry} from "../Registry";
-
-@Registry.attribute('vsn-key-up')
-export class KeyUp extends KeyAbstract {
-    public async connect() {
-        this.tag.addEventHandler('keyup', this.modifiers, this.handleEvent, this);
-        await super.connect();
-    }
-}

package/src/attributes/LazyAttribute.ts

@@ -1,30 +0,0 @@
-import {Registry} from "../Registry";
-import {On} from "./On";
-import {Modifiers} from "../Modifiers";
-
-@Registry.attribute('vsn-lazy')
-export class LazyAttribute extends On {
-    private loaded: boolean = false;
-    private eleTop: number;
-
-    public async setup() {
-        await super.setup();
-        this.eleTop = this.tag.element.getBoundingClientRect().top;
-    }
-
-    public async connect() {
-        if (!this.modifiers.has('active'))
-            this.modifiers.add('passive');
-
-        this.tag.addEventHandler('scroll', this.modifiers, this.handleEvent, this);
-        await this.handleEvent();
-    }
-
-    async handleEvent(e?: Event) {
-        if (!this.loaded && window.scrollY + window.outerHeight >= this.eleTop) {
-            this.loaded = true;
-            await super.handleEvent(e);
-            this.tag.removeEventHandler('scroll', this.handleEvent, this);
-        }
-    }
-}