vasille 1.2.8 → 2.0.2

package/src/attribute.js

@@ -1,70 +0,0 @@
-// @flow
-import { Binding }    from "./bind.js";
-import { Callable }   from "./interfaces/idefinition.js";
-import { IValue }     from "./interfaces/ivalue.js";
-import type { INode } from "./node";
-import { propertify } from "./property.js";
-
-
-
-/**
- * Creates a attribute 1 to 1 bind
- * @param rt {INode} is the root component
- * @param ts {INode} is the this component
- * @param name {String} is attribute name
- * @param value {?any} is attribute value
- * @param func {?Callable} is attribute value calculation function
- * @returns {AttributeBinding} 1 to 1 bind of attribute
- */
-export function attributify (
-    rt : INode,
-    ts : INode,
-    name : string,
-    value : ?any     = null,
-    func : ?Callable = null
-) : AttributeBinding {
-    return new AttributeBinding(rt, ts, name, null, propertify(value, func));
-}
-
-/**
- * Represents a Attribute binding description
- * @extends Binding
- */
-export class AttributeBinding extends Binding {
-    /**
-     * Constructs a attribute binding description
-     * @param rt {INode} is root component
-     * @param ts {INode} is this component
-     * @param name {String} is the name of attribute
-     * @param func {?Function} is the function to bound
-     * @param values {Array<IValue>} is the array of values to bind to
-     */
-    constructor (
-        rt : INode,
-        ts : INode,
-        name : string,
-        func : ?Function,
-        ...values : Array<IValue<any>>
-    ) {
-        super(rt, ts, name, func, ...values);
-    }
-
-    /**
-     * Generates a function which updates the attribute value
-     * @param name {String} The name of attribute
-     * @returns {Function} a function which will update attribute value
-     */
-    bound (name : string) : Function {
-        return function (rt : any, ts : any, value : string) {
-
-            if (value) {
-                rt.$.app.$run.setAttribute(ts.$.el, name, value);
-            }
-            else {
-                rt.$.app.$run.removeAttribute(ts.$.el, name);
-            }
-
-            return value;
-        };
-    }
-}

package/src/bind.js

@@ -1,285 +0,0 @@
-// @flow
-import { notOverwritten, typeError, wrongBinding } from "./interfaces/errors";
-import { IBind }                                   from "./interfaces/ibind.js";
-import { checkType }                               from "./interfaces/idefinition";
-import { IValue }                                  from "./interfaces/ivalue.js";
-import type { INode }                              from "./node";
-import { Reference }                               from "./value.js";
-
-
-
-/**
- * Bind some values to one expression
- * @implements IBind
- */
-export class Expression extends IBind {
-    /**
-     * The array of value which will trigger recalculation
-     * @type {Array<IValue<*>>}
-     */
-    values : Array<IValue<any>>;
-
-    /**
-     * Cache the values of expression variables
-     * @type {Array<*>}
-     * @version 1.1
-     */
-    valuesCache : Array<any> = [];
-
-    /**
-     * The function which will be executed on recalculation
-     * @type {Function}
-     */
-    func : Function;
-
-    /**
-     * Expression will link different handler for each value of list
-     * @type {Array<Function>}
-     * @version 1.1
-     */
-    linkedFunc : Array<Function> = [];
-
-    /**
-     * The current linking state
-     * @type {boolean}
-     */
-    linked : boolean;
-
-    /**
-     * The buffer to keep the last calculated value
-     * @type {Reference<*>}
-     */
-    sync : Reference<any> = new Reference(null);
-
-    /**
-     * Creates a function bounded to N value
-     * @param func {Function} The function to bound
-     * @param values {Array<IValue<*>>} Values to bound to
-     * @param link {Boolean} If true links immediately
-     */
-    constructor (
-        func : Function,
-        values : Array<IValue<any>>,
-        link : boolean = true
-    ) {
-        super();
-        let handler = (i : ?number) => {
-            if (i != null) {
-                this.valuesCache[i] = this.values[i].$;
-            }
-            let value = func.apply(this, this.valuesCache);
-
-            if (this.type) {
-                if (!checkType(value, this.type)) {
-                    throw typeError("expression returns wrong incompatible value");
-                }
-            }
-
-            this.sync.$ = value;
-        };
-
-        let i = 0;
-        for (let value of values) {
-            this.valuesCache.push(value.$);
-            this.linkedFunc.push(handler.bind(this, Number(i++)));
-        }
-
-        this.values = values;
-        this.func = handler;
-        this.linked = false;
-
-        if (link) {
-            this.link();
-        }
-        else {
-            handler(null);
-        }
-
-        this.seal();
-    }
-
-    /**
-     * Gets the last calculated value
-     * @return {*} The last calculated value
-     */
-    get $ () : any {
-        return this.sync.$;
-    }
-
-    /**
-     * Sets the last calculated value in manual mode
-     * @param value {*} New value for last calculated value
-     * @return {Expression<*>} A pointer to this
-     */
-    set $ (value : any) : this {
-        this.sync.$ = value;
-        return this;
-    }
-
-    /**
-     * Sets a user handler on value change
-     * @param handler {Function} User defined handler
-     * @return {this} A pointer to this
-     */
-    on (handler : Function) : this {
-        this.sync.on(handler);
-        return this;
-    }
-
-    /**
-     * Unsets a user handler from value change
-     * @param handler {Function} User installed handler
-     * @return {this} A pointer to this
-     */
-    off (handler : Function) : this {
-        this.sync.off(handler);
-        return this;
-    }
-
-    /**
-     * Binds function to each value
-     * @returns {this} A pointer to this
-     */
-    link () : this {
-        if (!this.linked) {
-            for (let i = 0; i < this.values.length; i++) {
-                this.values[i].on(this.linkedFunc[i]);
-                this.valuesCache[i] = this.values[i].$;
-            }
-            this.func(null);
-            this.linked = true;
-        }
-        return this;
-    }
-
-    /**
-     * Unbind function from each value
-     * @returns {this} A pointer to this
-     */
-    unlink () : this {
-        if (this.linked) {
-            for (let i = 0; i < this.values.length; i++) {
-                this.values[i].off(this.linkedFunc[i]);
-            }
-            this.linked = false;
-        }
-        return this;
-    }
-
-    /**
-     * Clear bindings on destroy
-     */
-    $destroy () : void {
-        this.unlink();
-        this.values.splice(0);
-        this.valuesCache.splice(0);
-        this.linkedFunc.splice(0);
-        this.func = null;
-    }
-}
-
-/**
- * Describe a common binding logic
- * @implements IValue
- */
-export class Binding extends IValue<any> {
-    binding : IValue<any>;
-    func : Function;
-    owner : boolean;
-
-    /**
-     * Constructs a common binding logic
-     * @param rt {INode} Root component
-     * @param ts {INode} This component
-     * @param name {String} Name of property/attribute
-     * @param func {?Function} A function to run on value change
-     * @param values {Array<IValue>} values array to bind
-     */
-    constructor (
-        rt : INode,
-        ts : INode,
-        name : string,
-        func : ?Function,
-        ...values : Array<IValue<any>>
-    ) {
-        super();
-
-        this.func = this.bound(name).bind(null, rt, ts);
-
-        if (!func && values.length === 1) {
-            this.binding = values[0];
-            this.owner = false;
-        }
-        else if (func && values.length) {
-            this.binding = new Expression(func, values);
-            this.owner = true;
-        }
-        else {
-            throw wrongBinding("Binding request a value as minimum");
-        }
-
-        this.binding.on(this.func);
-        this.func(this.binding.$);
-
-        this.seal();
-    }
-
-    /**
-     * Is a virtual function to get the specific bind function
-     * @param name {String} The name of attribute/property
-     * @returns {Function} A function to update attribute/property value
-     * @throws Always trows and must be overloaded in child class
-     */
-    bound (name : string) : Function {
-        throw notOverwritten();
-    };
-
-    /**
-     * Gets the binding value
-     * @return {*} The binding value
-     */
-    get $ () : any {
-        return this.binding.$;
-    }
-
-    /**
-     * Sets the binding value
-     * @param any {*} The new binding value
-     * @return {this} A pointer to this
-     */
-    set $ (any : any) : this {
-        this.binding.$ = any;
-        return this;
-    }
-
-    /**
-     * Adds a user handler to the binding value change event
-     * @param func {Function} User defined handler
-     * @return {Binding} A pointer to this
-     */
-    on (func : Function) : this {
-        this.binding.on(func);
-        return this;
-    }
-
-    /**
-     * Removes a user handler from binding value change event
-     * @param func {Function} User installed handler
-     * @return {Binding} A pointer to this
-     */
-    off (func : Function) : this {
-        this.binding.off(func);
-        return this;
-    }
-
-    /**
-     * Just clear bindings
-     */
-    $destroy () {
-        this.binding.off(this.func);
-
-        if (this.owner) {
-            this.binding.$destroy();
-        }
-    }
-}

package/src/class.js

@@ -1,96 +0,0 @@
-// @flow
-import { Binding }    from "./bind.js";
-import { Callable }   from "./interfaces/idefinition.js";
-import { IValue }     from "./interfaces/ivalue.js";
-import type { INode } from "./node.js";
-import { propertify } from "./property.js";
-
-
-
-/**
- * Creates a class target 1 to 1 bind
- * @param rt {INode} is the root component
- * @param ts {INode} is the this component
- * @param name {String} is attribute name
- * @param value {?any} is attribute value
- * @param func {?Callable} is attribute value calculation function
- * @returns {AttributeBinding} 1 to 1 bind of attribute
- */
-export function classify (
-    rt : INode,
-    ts : INode,
-    name : string,
-    value : ?any     = null,
-    func : ?Callable = null
-) : ClassBinding {
-    return new ClassBinding(rt, ts, name, null, propertify(value, func));
-}
-
-/**
- * Represents a HTML class binding description
- * @extends Binding
- */
-export class ClassBinding extends Binding {
-    current : ? string | boolean = null;
-
-    /**
-     * Constructs a HTML class binding description
-     * @param rt {INode} is root component
-     * @param ts {INode} is this component
-     * @param name {String} is the name of attribute
-     * @param func {?Function} is the function to bound
-     * @param values {Array<IValue>} is the array of values to bind to
-     */
-    constructor (
-        rt : INode,
-        ts : INode,
-        name : string,
-        func : ?Function,
-        ...values : Array<IValue<any>>
-    ) {
-        super(rt, ts, name, func, ...values);
-
-        this.seal();
-    }
-
-    /**
-     * Generates a function which updates the html class value
-     * @param name {String} The name of attribute
-     * @returns {Function} a function which will update attribute value
-     */
-    bound (name : string) : Function {
-
-        function addClass (rt : INode, ts : INode, cl : string) {
-            rt.$.app.$run.addClass(ts.$.el, cl);
-        }
-
-        function removeClass (rt : INode, ts : INode, cl : string) {
-            rt.$.app.$run.removeClass(ts.$.el, cl);
-        }
-
-        return (rt : INode, ts : INode, value : string | boolean) => {
-            let current : ? string | boolean = this.current;
-
-            if (value !== current) {
-                if (typeof current === "string" && current !== "") {
-                    removeClass(rt, ts, current);
-                }
-                if (typeof value === "boolean") {
-                    if (value) {
-                        addClass(rt, ts, name);
-                    }
-                    else {
-                        removeClass(rt, ts, name);
-                    }
-                }
-                else if (typeof value === "string" && value !== "") {
-                    addClass(rt, ts, value);
-                }
-
-                this.current = value;
-            }
-
-            return value;
-        };
-    }
-}

package/src/executor.js

@@ -1,165 +0,0 @@
-// @flow
-import { notOverwritten } from "./interfaces/errors";
-
-
-
-/**
- * Represents an executor unit interface
- */
-export class Executor {
-
-    /**
-     * Adds a CSS class
-     * @param el {HTMLElement} HTML element
-     * @param cl {string}
-     */
-    addClass (el : HTMLElement, cl : string) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Removes a CSS class
-     * @param el {HTMLElement} HTML element
-     * @param cl {string}
-     */
-    removeClass (el : HTMLElement, cl : string) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Sets a tag attribute
-     * @param el {HTMLElement} HTML element
-     * @param name {string}
-     * @param value {string}
-     */
-    setAttribute (el : HTMLElement, name : string, value : string) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Removes a tag attribute
-     * @param el {HTMLElement} HTML element
-     * @param name {string}
-     */
-    removeAttribute (el : HTMLElement, name : string) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Sets a style attribute
-     * @param el {HTMLElement} HTML element
-     * @param prop {string}
-     * @param value {string}
-     */
-    setStyle (el : HTMLElement, prop : string, value : string) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Inserts a child
-     * @param el {HTMLElement} HTML element
-     * @param child {HTMLElement | Text | Comment} Child to insert
-     * @param before {HTMLElement | Text | Comment} Child used as position locator
-     */
-    insertBefore (el : HTMLElement, child : HTMLElement | Text | Comment, before : HTMLElement | Text | Comment) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Appends a child
-     * @param el {HTMLElement} HTML element
-     * @param child {HTMLElement | Text | Comment} Child to append
-     */
-    appendChild (el : HTMLElement, child : HTMLElement | Text | Comment) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Calls a call-back function
-     * @param cb {Function} call-back function
-     */
-    callCallback (cb : Function) {
-        throw notOverwritten();
-    }
-}
-
-export class InstantExecutor extends Executor {
-
-    /**
-     * Adds a CSS class
-     * @param el {HTMLElement} HTML element
-     * @param cl {string}
-     */
-    addClass (el : HTMLElement, cl : string) {
-        if (el) {
-            el.classList.add(cl);
-        }
-    }
-
-    /**
-     * Removes a CSS class
-     * @param el {HTMLElement} HTML element
-     * @param cl {string}
-     */
-    removeClass (el : HTMLElement, cl : string) {
-        if (el) {
-            el.classList.remove(cl);
-        }
-    }
-
-    /**
-     * Sets a tag attribute
-     * @param el {HTMLElement} HTML element
-     * @param name {string}
-     * @param value {string}
-     */
-    setAttribute (el : HTMLElement, name : string, value : string) {
-        el.setAttribute(name, value);
-    }
-
-    /**
-     * Removes a tag attribute
-     * @param el {HTMLElement} HTML element
-     * @param name {string}
-     */
-    removeAttribute (el : HTMLElement, name : string) {
-        el.removeAttribute(name);
-    }
-
-    /**
-     * Sets a style attribute
-     * @param el {HTMLElement} HTML element
-     * @param prop {string}
-     * @param value {string}
-     */
-    setStyle (el : HTMLElement, prop : string, value : string) {
-        el.style.setProperty(prop, value);
-    }
-
-    /**
-     * Inserts a child
-     * @param el {HTMLElement} HTML element
-     * @param child {HTMLElement | Text | Comment} Child to insert
-     * @param before {HTMLElement | Text | Comment} Child used as position locator
-     */
-    insertBefore (el : HTMLElement, child : HTMLElement | Text | Comment, before : HTMLElement | Text | Comment) {
-        el.insertBefore(child, before);
-    }
-
-    /**
-     * Appends a child
-     * @param el {HTMLElement} HTML element
-     * @param child {HTMLElement | Text | Comment} Child to append
-     */
-    appendChild (el : HTMLElement, child : HTMLElement | Text | Comment) {
-        el.appendChild(child);
-    }
-
-    /**
-     * Calls a call-back function
-     * @param cb {Function} call-back function
-     */
-    callCallback (cb : Function) {
-        cb();
-    }
-}

package/src/index.js

@@ -1,20 +0,0 @@
-import { Expression }                                      from "./bind.js";
-import { Destroyable }                                     from "./interfaces/destroyable.js";
-import { IBind }                                           from "./interfaces/ibind.js";
-import { IValue }                                          from "./interfaces/ivalue.js";
-import { ArrayModel, MapModel, ObjectModel, SetModel }     from "./models.js";
-import { App, INode, Extension, Tag, TextNode, Component } from "./node.js";
-import { Pointer, Reference }                              from "./value.js";
-import { ArrayView, MapView, ObjectView, SetView }         from "./views.js";
-
-
-
-export {
-    Expression,
-    Destroyable,
-    IBind, IValue,
-    ArrayModel, MapModel, ObjectModel, SetModel,
-    App, INode, Tag, Extension, TextNode, Component,
-    Pointer, Reference,
-    ArrayView, MapView, ObjectView, SetView
-};