vasille 1.2.8 → 2.0.2

package/src/property.js

@@ -1,36 +0,0 @@
-// @flow
-import { Callable }  from "./interfaces/idefinition.js";
-import { IValue }    from "./interfaces/ivalue.js";
-import { Reference } from "./value.js";
-
-
-
-/**
- * Constructs a property field value
- * @param value {?any} is the initial value of field
- * @param func {?Callable} is the function to calc filed value
- * @return {IValue} Given value or new generated
- */
-export function propertify (
-    value : ?any     = null,
-    func : ?Callable = null
-) : IValue<any> {
-    if (func) {
-        let v = func.func();
-
-        if (v instanceof IValue) {
-            return v;
-        }
-        else {
-            return new Reference(v);
-        }
-    }
-    else {
-        if (value instanceof IValue) {
-            return value;
-        }
-        else {
-            return new Reference(value);
-        }
-    }
-}

package/src/style.js

@@ -1,65 +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";
-
-
-
-/**
- * Constructs a style attribute value
- * @param rt {INode} The root node
- * @param ts {INode} The this node
- * @param name {String} The style attribute name
- * @param value {String | IValue | null} A value for attribute
- * @param func {?Callable} A getter of attribute value
- * @return {StyleBinding} A ready style binding
- */
-export function stylify (
-    rt : INode,
-    ts : INode,
-    name : string,
-    value : ?string | ?IValue<string> = null,
-    func : ?Callable                  = null
-) : StyleBinding {
-    return new StyleBinding(rt, ts, name, null, propertify(value, func));
-}
-
-/**
- * Describes a style attribute binding
- * @extends Binding
- */
-export class StyleBinding extends Binding {
-    /**
-     * Constructs a style binding attribute
-     * @param rt {INode} is root component
-     * @param ts {INode} is this component
-     * @param name {string} is the name of style property
-     * @param func {function} is the function to calc style value
-     * @param values is the value to be synced
-     */
-    constructor (
-        rt : INode,
-        ts : INode,
-        name : string,
-        func : ?Function,
-        ...values : Array<IValue<string>>
-    ) {
-        super(rt, ts, name, func, ...values);
-    }
-
-    /**
-     * Generates a function to update style property value
-     * @param name {string}
-     * @returns {Function} a function to update style property
-     */
-    bound (name : string) : Function {
-        return function (rt : any, ts : any, value : string) {
-            if (rt.$) {
-                rt.$.app.$run.setStyle(ts.$.el, name, value);
-            }
-            return value;
-        };
-    }
-}

package/src/value.js

@@ -1,201 +0,0 @@
-// @flow
-import { typeError }               from "./interfaces/errors";
-import { checkType, isSubclassOf } from "./interfaces/idefinition";
-import { IValue }                  from "./interfaces/ivalue.js";
-
-
-
-/**
- * Declares a notifiable value
- * @implements IValue
- */
-export class Reference<T> extends IValue<T> {
-    /**
-     * The encapsulated value
-     * @type {*}
-     */
-    value : T;
-
-    /**
-     * Array of handlers
-     * @type {Set<Function>}
-     */
-    onchange : Set<Function>;
-
-    /**
-     * Constructs a notifiable value
-     * @param value {any} is initial value
-     */
-    constructor (value : T) {
-        super();
-        this.value = value;
-        this.onchange = new Set<Function>();
-        this.seal();
-    }
-
-    /**
-     * Gets the notifiable value as js value
-     * @returns {any} contained value
-     */
-    get $ () : T {
-        return this.value;
-    }
-
-    /**
-     * Sets the value and notify listeners
-     * @param value {any} is the new value
-     * @returns {Reference} a pointer to this
-     */
-    set $ (value : T) : this {
-        if (this.value !== value) {
-            if (this.type && !checkType(value, this.type)) {
-                throw typeError("Unable to set reference value");
-            }
-
-            this.value = value;
-
-            for (let handler of this.onchange) {
-                handler(value);
-            }
-        }
-
-        return this;
-    }
-
-    /**
-     * Adds a new handler for value change
-     * @param handler {function} is a user-defined event handler
-     * @returns {Reference} a pointer to this
-     */
-    on (handler : Function) : this {
-        this.onchange.add(handler);
-        return this;
-    }
-
-    /**
-     * Removes a new handler for value change
-     * @param handler {function} is a existing user-defined handler
-     * @returns {Reference} a pointer to this
-     */
-    off (handler : Function) : this {
-        this.onchange.delete(handler);
-        return this;
-    }
-
-    /**
-     * Runs GC
-     */
-    $destroy () {
-        super.$destroy();
-        this.onchange.clear();
-    }
-}
-
-/**
- * Declares a notifiable bind to a value
- * @extends IValue
- */
-export class Pointer<T> extends IValue<IValue<T>> {
-    /**
-     * value of pointer
-     * @type {IValue<*>}
-     */
-    value : IValue<T>;
-
-    /**
-     * Collection of handlers
-     * @type {Set<Function>}
-     */
-    onchange : Set<Function>;
-
-    /**
-     * Constructs a notifiable bind to a value
-     * @param value {IValue} is initial value
-     */
-    constructor (value : IValue<T>) {
-        super();
-        this.onchange = new Set<Function>();
-        this.$ = value;
-        this.seal();
-    }
-
-    /**
-     * Gets the notifiable value as js value
-     * @returns {any} contained value
-     */
-    // $FlowFixMe
-    get $ () : T {
-        return this.value.$;
-    }
-
-    /**
-     * Sets the value and notify listeners
-     * @param value {IValue} is the new value
-     * @returns {IValue} a pointer to this
-     */
-    set $ (value : IValue<T>) : this {
-        if (this.value !== value) {
-            if (this.type) {
-                if (this.type !== value.type) {
-                    if (value.type === null && checkType(value.$, this.type)) {
-                        value.type = this.type;
-                    }
-                    else if (!isSubclassOf(this.type, value.type)) {
-                        throw typeError("reference type incompatible with pointer type");
-                    }
-                }
-            }
-
-            for (let handler of this.onchange) {
-                this.value.off(handler);
-            }
-
-            this.value = value;
-
-            for (let handler of this.onchange) {
-                this.value.on(handler);
-            }
-
-            if (this.value.$ !== value.$) {
-                for (let handler of this.onchange) {
-                    handler(this.value.$);
-                }
-            }
-        }
-
-        return this;
-    }
-
-    /**
-     * Adds a new handler for value change
-     * @param handler {function} is a user-defined event handler
-     * @returns {IValue} a pointer to this
-     */
-    on (handler : Function) : this {
-        this.onchange.add(handler);
-        this.value.on(handler);
-        return this;
-    }
-
-    /**
-     * Removes a new handler for value change
-     * @param handler {function} is a existing user-defined handler
-     * @returns {IValue} a pointer to this
-     */
-    off (handler : Function) : this {
-        if (this.onchange.has(handler)) {
-            this.value.off(handler);
-            this.onchange.delete(handler);
-        }
-        return this;
-    }
-
-    /**
-     * Removes all bounded functions
-     */
-    $destroy () {
-        for (let handler of this.onchange) {
-            this.value.off(handler);
-        }
-    }
-}