vasille 2.3.0 → 2.3.1

package/cdn/es2015.js

@@ -569,111 +569,6 @@ class ArrayModel extends Array {
 
 window.ArrayModel = ArrayModel;
 
-// ./lib/core/signal.js
-/**
- * Signal is an event generator
- * @class Signal
- */
-class Signal {
-    constructor() {
-        /**
-         * Handler of event
-         * @type {Set}
-         * @private
-         */
-        this.handlers = new Set;
-    }
-    /**
-     * Emit event
-     * @param a1 {*} argument
-     * @param a2 {*} argument
-     * @param a3 {*} argument
-     * @param a4 {*} argument
-     * @param a5 {*} argument
-     * @param a6 {*} argument
-     * @param a7 {*} argument
-     * @param a8 {*} argument
-     * @param a9 {*} argument
-     */
-    emit(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-        this.handlers.forEach(handler => {
-            try {
-                handler(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-            }
-            catch (e) {
-                console.error(`Vasille.js: Handler throw exception: `, e);
-            }
-        });
-    }
-    /**
-     * Subscribe to event
-     * @param func {function} handler
-     */
-    subscribe(func) {
-        this.handlers.add(func);
-    }
-    /**
-     * Unsubscribe from event
-     * @param func {function} handler
-     */
-    unsubscribe(func) {
-        this.handlers.delete(func);
-    }
-}
-
-window.Signal = Signal;
-
-// ./lib/core/slot.js
-/**
- * Component slot
- * @class Slot
- */
-class Slot {
-    /**
-     * Sets the runner
-     * @param func {function} the function to run
-     */
-    insert(func) {
-        this.runner = func;
-    }
-    /**
-     * @param a0 {Fragment} node to paste content
-     * @param a1 {*} 1st argument
-     * @param a2 {*} 2nd argument
-     * @param a3 {*} 3rd argument
-     * @param a4 {*} 4th argument
-     * @param a5 {*} 5th argument
-     * @param a6 {*} 6th argument
-     * @param a7 {*} 7th argument
-     * @param a8 {*} 8th argument
-     * @param a9 {*} 9th argument
-     */
-    release(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-        if (this.runner) {
-            this.runner(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        }
-    }
-    /**
-     * Predefine a handler for a slot
-     * @param func {function(node : Fragment)} Function to run if no handler specified
-     * @param a0 {Fragment} node to paste content
-     * @param a1 {*} 1st argument
-     * @param a2 {*} 2nd argument
-     * @param a3 {*} 3rd argument
-     * @param a4 {*} 4th argument
-     * @param a5 {*} 5th argument
-     * @param a6 {*} 6th argument
-     * @param a7 {*} 7th argument
-     * @param a8 {*} 8th argument
-     * @param a9 {*} 9th argument
-     */
-    predefine(func, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-        (this.runner || func)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
-    }
-}
-
-window.Slot = Slot;
-
 // ./lib/core/errors.js
 const reportIt = "Report it here: https://gitlab.com/vasille-js/vasille-js/-/issues";
 function notOverwritten() {
@@ -697,167 +592,6 @@ window.internalError = internalError;
 window.userError = userError;
 window.wrongBinding = wrongBinding;
 
-// ./lib/core/executor.js
-/**
- * Represents an executor unit interface
- * @class Executor
- */
-class Executor {
-    /**
-     * Adds a CSS class
-     * @param el {Element} element to manipulate
-     * @param cl {string} class to be added
-     */
-    addClass(el, cl) {
-        throw notOverwritten();
-    }
-    /**
-     * Removes a CSS class
-     * @param el {Element} element to manipulate
-     * @param cl {string} class to be removed
-     */
-    removeClass(el, cl) {
-        throw notOverwritten();
-    }
-    /**
-     * Sets a tag attribute
-     * @param el {Element} element to manipulate
-     * @param name {string} name of attribute
-     * @param value {string} value of attribute
-     */
-    setAttribute(el, name, value) {
-        throw notOverwritten();
-    }
-    /**
-     * Removes a tag attribute
-     * @param el {Element} element to manipulate
-     * @param name {string} name of attribute
-     */
-    removeAttribute(el, name) {
-        throw notOverwritten();
-    }
-    /**
-     * Sets a style attribute
-     * @param el {HTMLElement} element to manipulate
-     * @param prop {string} property name
-     * @param value {string} property value
-     */
-    setStyle(el, prop, value) {
-        throw notOverwritten();
-    }
-    /**
-     * Inserts a child before target
-     * @param target {Element} target element
-     * @param child {Node} element to insert before
-     */
-    insertBefore(target, child) {
-        throw notOverwritten();
-    }
-    /**
-     * Appends a child to element
-     * @param el {Element} element
-     * @param child {Node} child to be inserted
-     */
-    appendChild(el, child) {
-        throw notOverwritten();
-    }
-    /**
-     * Calls a call-back function
-     * @param cb {function} call-back function
-     */
-    callCallback(cb) {
-        throw notOverwritten();
-    }
-}
-/**
- * Executor which execute any commands immediately
- * @class InstantExecutor
- * @extends Executor
- */
-class InstantExecutor extends Executor {
-    addClass(el, cl) {
-        el.classList.add(cl);
-    }
-    removeClass(el, cl) {
-        el.classList.remove(cl);
-    }
-    setAttribute(el, name, value) {
-        el.setAttribute(name, value);
-    }
-    removeAttribute(el, name) {
-        el.removeAttribute(name);
-    }
-    setStyle(el, prop, value) {
-        el.style.setProperty(prop, value);
-    }
-    insertBefore(target, child) {
-        const parent = target.parentNode;
-        if (!parent) {
-            throw internalError('element don\'t have a parent node');
-        }
-        parent.insertBefore(child, target);
-    }
-    appendChild(el, child) {
-        el.appendChild(child);
-    }
-    callCallback(cb) {
-        cb();
-    }
-}
-/**
- * Executor which execute any commands over timeout
- * @class TimeoutExecutor
- * @extends InstantExecutor
- */
-class TimeoutExecutor extends InstantExecutor {
-    addClass(el, cl) {
-        setTimeout(() => {
-            super.addClass(el, cl);
-        }, 0);
-    }
-    removeClass(el, cl) {
-        setTimeout(() => {
-            super.removeClass(el, cl);
-        }, 0);
-    }
-    setAttribute(el, name, value) {
-        setTimeout(() => {
-            super.setAttribute(el, name, value);
-        }, 0);
-    }
-    removeAttribute(el, name) {
-        setTimeout(() => {
-            super.removeAttribute(el, name);
-        }, 0);
-    }
-    setStyle(el, prop, value) {
-        setTimeout(() => {
-            super.setStyle(el, prop, value);
-        }, 0);
-    }
-    insertBefore(target, child) {
-        setTimeout(() => {
-            super.insertBefore(target, child);
-        }, 0);
-    }
-    appendChild(el, child) {
-        setTimeout(() => {
-            super.appendChild(el, child);
-        }, 0);
-    }
-    callCallback(cb) {
-        setTimeout(cb, 0);
-    }
-}
-const instantExecutor = new InstantExecutor();
-const timeoutExecutor = new TimeoutExecutor();
-
-window.Executor = Executor;
-window.InstantExecutor = InstantExecutor;
-window.TimeoutExecutor = TimeoutExecutor;
-window.instantExecutor = instantExecutor;
-window.timeoutExecutor = timeoutExecutor;
-
 // ./lib/core/destroyable.js
 /**
  * Mark an object which can be destroyed
@@ -2413,90 +2147,6 @@ window.AppNode = AppNode;
 window.App = App;
 window.Portal = Portal;
 
-// ./lib/node/interceptor.js
-/**
- * Interceptor is designed to connect signals & methods of children elements
- * @class Interceptor
- * @extends Destroyable
- */
-class Interceptor extends Destroyable {
-    constructor() {
-        super(...arguments);
-        /**
-         * Set of signals
-         * @type Set
-         */
-        this.signals = new Set;
-        /**
-         * Set of handlers
-         * @type Set
-         */
-        this.handlers = new Set;
-    }
-    /**
-     * Connect a signal or a handler
-     * @param thing {Signal | function}
-     */
-    connect(thing) {
-        // interceptor will connect signals and handlers together
-        if (thing instanceof Signal) {
-            this.handlers.forEach(handler => {
-                thing.subscribe(handler);
-            });
-            this.signals.add(thing);
-        }
-        else {
-            this.signals.forEach(signal => {
-                signal.subscribe(thing);
-            });
-            this.handlers.add(thing);
-        }
-    }
-    /**
-     * Disconnect a handler from signals
-     * @param handler {function}
-     */
-    disconnect(handler) {
-        this.signals.forEach(signal => {
-            signal.unsubscribe(handler);
-        });
-    }
-    destroy() {
-        super.destroy();
-        this.signals.forEach(signal => {
-            this.handlers.forEach(handler => {
-                signal.unsubscribe(handler);
-            });
-        });
-    }
-}
-/**
- * Interceptor node to implement directly to vasille DOM
- * @class InterceptorNode
- * @extends Extension
- */
-class InterceptorNode extends Fragment {
-    constructor() {
-        super(...arguments);
-        /**
-         * Internal interceptor
-         * @type Interceptor
-         */
-        this.interceptor = new Interceptor;
-        /**
-         * The default slot of node
-         * @type Slot
-         */
-        this.slot = new Slot;
-    }
-    compose() {
-        this.slot.release(this, this.interceptor);
-    }
-}
-
-window.Interceptor = Interceptor;
-window.InterceptorNode = InterceptorNode;
-
 // ./lib/binding/attribute.js
 /**
  * Represents an Attribute binding description
@@ -2674,72 +2324,6 @@ class RepeatNode extends Fragment {
 window.RepeatNodePrivate = RepeatNodePrivate;
 window.RepeatNode = RepeatNode;
 
-// ./lib/views/repeater.js
-/**
- * Private part of repeater
- * @class RepeaterPrivate
- * @extends RepeatNodePrivate
- */
-class RepeaterPrivate extends RepeatNodePrivate {
-    constructor() {
-        super();
-        /**
-         * Current count of child nodes
-         */
-        this.currentCount = 0;
-        this.seal();
-    }
-}
-/**
- * The simplest repeat node interpretation, repeat children pack a several times
- * @class Repeater
- * @extends RepeatNode
- */
-class Repeater extends RepeatNode {
-    constructor($) {
-        super($ || new RepeaterPrivate);
-        /**
-         * The count of children
-         */
-        this.count = new Reference(0);
-        this.seal();
-    }
-    /**
-     * Changes the children count
-     */
-    changeCount(number) {
-        const $ = this.$;
-        if (number > $.currentCount) {
-            for (let i = $.currentCount; i < number; i++) {
-                this.createChild(i, i);
-            }
-        }
-        else {
-            for (let i = $.currentCount - 1; i >= number; i--) {
-                this.destroyChild(i, i);
-            }
-        }
-        $.currentCount = number;
-    }
-    created() {
-        const $ = this.$;
-        super.created();
-        $.updateHandler = this.changeCount.bind(this);
-        this.count.on($.updateHandler);
-    }
-    ready() {
-        this.changeCount(this.count.$);
-    }
-    destroy() {
-        const $ = this.$;
-        super.destroy();
-        this.count.off($.updateHandler);
-    }
-}
-
-window.RepeaterPrivate = RepeaterPrivate;
-window.Repeater = Repeater;
-
 // ./lib/views/base-view.js
 /**
  * Private part of BaseView
@@ -2878,284 +2462,8 @@ class SetView extends BaseView {
 
 window.SetView = SetView;
 
-// ./lib/functional/merge.js
-function merge(main, ...targets) {
-    function refactorClass(obj) {
-        if (Array.isArray(obj.class)) {
-            const out = {
-                $: []
-            };
-            obj.class.forEach(item => {
-                if (item instanceof IValue) {
-                    out.$.push(item);
-                }
-                else if (typeof item === 'string') {
-                    out[item] = true;
-                }
-                else if (typeof item === 'object') {
-                    Object.assign(out, item);
-                }
-            });
-            obj.class = out;
-        }
-    }
-    refactorClass(main);
-    targets.forEach(target => {
-        Reflect.ownKeys(target).forEach((prop) => {
-            if (!Reflect.has(main, prop)) {
-                main[prop] = target[prop];
-            }
-            else if (typeof main[prop] === 'object' && typeof target[prop] === 'object') {
-                if (prop === 'class') {
-                    refactorClass(target);
-                }
-                if (prop === '$' && Array.isArray(main[prop]) && Array.isArray(target[prop])) {
-                    main.$.push(...target.$);
-                }
-                else {
-                    merge(main[prop], target[prop]);
-                }
-            }
-        });
-    });
-}
-
-window.merge = merge;
-
-// ./lib/functional/stack.js
-function app(renderer) {
-    return (node, opts) => {
-        return new App(node, opts).runFunctional(renderer, opts);
-    };
-}
-function component(renderer) {
-    return (opts, callback) => {
-        const component = new Component(opts);
-        if (!(current instanceof Fragment))
-            throw userError('missing parent node', 'out-of-context');
-        let ret;
-        if (callback)
-            opts.slot = callback;
-        current.create(component, node => {
-            ret = node.runFunctional(renderer, opts);
-        });
-        return ret;
-    };
-}
-function fragment(renderer) {
-    return (opts, callback) => {
-        const frag = new Fragment(opts);
-        if (!(current instanceof Fragment))
-            throw userError('missing parent node', 'out-of-context');
-        if (callback)
-            opts.slot = callback;
-        current.create(frag);
-        return frag.runFunctional(renderer, opts);
-    };
-}
-function extension(renderer) {
-    return (opts, callback) => {
-        const ext = new Extension(opts);
-        if (!(current instanceof Fragment))
-            throw userError('missing parent node', 'out-of-context');
-        if (callback)
-            opts.slot = callback;
-        current.create(ext);
-        return ext.runFunctional(renderer, opts);
-    };
-}
-function tag(name, opts, callback) {
-    if (!(current instanceof Fragment))
-        throw userError('missing parent node', 'out-of-context');
-    return {
-        node: current.tag(name, opts, (node) => {
-            callback && node.runFunctional(callback);
-        })
-    };
-}
-function create(node, callback) {
-    if (!(current instanceof Fragment))
-        throw userError('missing current node', 'out-of-context');
-    current.create(node, (node, ...args) => {
-        callback && node.runFunctional(callback, ...args);
-    });
-    return node;
-}
-const vx = {
-    if(condition, callback) {
-        if (current instanceof Fragment) {
-            current.if(condition, node => node.runFunctional(callback));
-        }
-        else {
-            throw userError("wrong use of `v.if` function", "logic-error");
-        }
-    },
-    else(callback) {
-        if (current instanceof Fragment) {
-            current.else(node => node.runFunctional(callback));
-        }
-        else {
-            throw userError("wrong use of `v.else` function", "logic-error");
-        }
-    },
-    elif(condition, callback) {
-        if (current instanceof Fragment) {
-            current.elif(condition, node => node.runFunctional(callback));
-        }
-        else {
-            throw userError("wrong use of `v.elif` function", "logic-error");
-        }
-    },
-    for(model, callback) {
-        if (model instanceof ArrayModel) {
-            // for arrays T & K are the same type
-            create(new ArrayView({ model }), callback);
-        }
-        else if (model instanceof MapModel) {
-            create(new MapView({ model }), callback);
-        }
-        else if (model instanceof SetModel) {
-            // for sets T & K are the same type
-            create(new SetView({ model }), callback);
-        }
-        else if (model instanceof ObjectModel) {
-            // for objects K is always string
-            create(new ObjectView({ model }), callback);
-        }
-        else {
-            throw userError("wrong use of `v.for` function", 'wrong-model');
-        }
-    },
-    watch(model, callback) {
-        const opts = { model };
-        create(new Watch(opts), callback);
-    },
-    nextTick(callback) {
-        const node = current;
-        window.setTimeout(() => {
-            node.runFunctional(callback);
-        }, 0);
-    }
-};
-
-window.app = app;
-window.component = component;
-window.fragment = fragment;
-window.extension = extension;
-window.tag = tag;
-window.create = create;
-window.vx = vx;
-
-// ./lib/functional/models.js
-function arrayModel(arr = []) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new ArrayModel(arr)).proxy();
-}
-function mapModel(map = []) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new MapModel(map));
-}
-function setModel(arr = []) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new SetModel(arr));
-}
-function objectModel(obj = {}) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new ObjectModel(obj));
-}
-
-window.arrayModel = arrayModel;
-window.mapModel = mapModel;
-window.setModel = setModel;
-window.objectModel = objectModel;
-
 // ./lib/functional/options.js
 
 
 
-// ./lib/functional/reactivity.js
-function ref(value) {
-    const ref = current.ref(value);
-    return [ref, (value) => ref.$ = value];
-}
-function mirror(value) {
-    return current.mirror(value);
-}
-function forward(value) {
-    return current.forward(value);
-}
-function point(value) {
-    return current.point(value);
-}
-function expr(func, ...values) {
-    return current.expr(func, ...values);
-}
-function watch(func, ...values) {
-    current.watch(func, ...values);
-}
-function valueOf(value) {
-    return value.$;
-}
-function setValue(ref, value) {
-    if (ref instanceof Pointer && value instanceof IValue) {
-        ref.$$ = value;
-    }
-    else {
-        ref.$ = value instanceof IValue ? value.$ : value;
-    }
-}
-
-window.ref = ref;
-window.mirror = mirror;
-window.forward = forward;
-window.point = point;
-window.expr = expr;
-window.watch = watch;
-window.valueOf = valueOf;
-window.setValue = setValue;
-
-// ./lib/functional/components.js
-function text(text) {
-    if (!(current instanceof Fragment))
-        throw userError('missing parent node', 'out-of-context');
-    ;
-    current.text(text);
-}
-function debug(text) {
-    if (!(current instanceof Fragment))
-        throw userError('missing parent node', 'out-of-context');
-    current.debug(text);
-}
-function predefine(slot, predefined) {
-    return slot || predefined;
-}
-
-window.text = text;
-window.debug = debug;
-window.predefine = predefine;
-
-// ./lib/v/index.js
-
-const v = Object.assign(Object.assign({ ref(value) {
-        return current.ref(value);
-    }, expr: expr, of: valueOf, sv: setValue, alwaysFalse: new Reference(false), app,
-    component,
-    fragment,
-    extension,
-    text,
-    tag,
-    create }, vx), { merge,
-    destructor() {
-        return current.$destroy.bind(current);
-    },
-    runOnDestroy(callback) {
-        current.runOnDestroy(callback);
-    } });
-
-window.v = v;
-
 })();