vasille 2.2.2 → 2.3.2

package/types/node/node.d.ts

@@ -1,7 +1,7 @@
 import { Reactive, ReactivePrivate } from "../core/core";
 import { IValue } from "../core/ivalue";
 import type { AppNode } from "./app";
-import { Options, TagOptions } from "../functional/options";
+import { FragmentOptions, TagOptions } from "../functional/options";
 import { AcceptedTagsMap } from "../spec/react";
 /**
  * Represents a Vasille.js node
@@ -45,7 +45,7 @@ export declare class FragmentPrivate extends ReactivePrivate {
  * This class is symbolic
  * @extends Reactive
  */
-export declare class Fragment<T extends Options = Options> extends Reactive {
+export declare class Fragment<T extends FragmentOptions = FragmentOptions> extends Reactive {
     /**
      * Private part
      * @protected
@@ -74,7 +74,7 @@ export declare class Fragment<T extends Options = Options> extends Reactive {
      * @param data {*} additional data
      */
     preinit(app: AppNode, parent: Fragment, data?: unknown): void;
-    init(): void;
+    init(): T['return'];
     protected compose(input: T): void;
     /** To be overloaded: ready event handler */
     ready(): void;
@@ -119,7 +119,7 @@ export declare class Fragment<T extends Options = Options> extends Reactive {
      * @param node {Fragment} vasille element to insert
      * @param callback {function($ : *)}
      */
-    create<T extends Fragment>(node: T, callback?: T['input']['slot']): void;
+    create<T extends Fragment>(node: T, callback?: T['input']['slot']): T['input']['return'];
     /**
      * Defines an if node
      * @param cond {IValue} condition
@@ -317,6 +317,7 @@ export declare class Tag<K extends keyof AcceptedTagsMap> extends INode<TagOptio
  */
 export declare class Extension<T extends TagOptions<any> = TagOptions<any>> extends INode<T> {
     preinit(app: AppNode, parent: Fragment): void;
+    extend(options: T): void;
     $destroy(): void;
 }
 /**

package/types/node/watch.d.ts

@@ -1,7 +1,7 @@
 import { Fragment } from "./node";
 import { IValue } from "../core/ivalue";
-import { Options } from "../functional/options";
-interface WatchOptions<T> extends Options {
+import { FragmentOptions } from "../functional/options";
+interface WatchOptions<T> extends FragmentOptions {
     model: IValue<T>;
     slot?: (node: Fragment, value: T) => void;
 }

package/types/views/repeat-node.d.ts

@@ -1,5 +1,5 @@
 import { Fragment, INodePrivate } from "../node/node";
-import { Options } from "../functional/options";
+import { FragmentOptions } from "../functional/options";
 /**
  * Private part of repeat node
  * @class RepeatNodePrivate
@@ -14,7 +14,7 @@ export declare class RepeatNodePrivate<IdT> extends INodePrivate {
     constructor();
     $destroy(): void;
 }
-export interface RNO<T, IdT> extends Options {
+export interface RNO<T, IdT> extends FragmentOptions {
     slot?: (node: Fragment, value: T, index: IdT) => void;
 }
 /**

package/lib/core/executor.js

@@ -1,154 +0,0 @@
-import { internalError, notOverwritten } from "./errors";
-/**
- * Represents an executor unit interface
- * @class Executor
- */
-export 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
- */
-export 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
- */
-export 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);
-    }
-}
-export const instantExecutor = new InstantExecutor();
-export const timeoutExecutor = new TimeoutExecutor();

package/lib/core/signal.js

@@ -1,50 +0,0 @@
-/**
- * Signal is an event generator
- * @class Signal
- */
-export 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);
-    }
-}

package/lib/core/slot.js

@@ -1,47 +0,0 @@
-/**
- * Component slot
- * @class Slot
- */
-export 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);
-    }
-}

package/lib/functional/components.js

@@ -1,17 +0,0 @@
-import { Fragment } from "../node/node";
-import { current } from "../core/core";
-import { userError } from "../core/errors";
-export function text(text) {
-    if (!(current instanceof Fragment))
-        throw userError('missing parent node', 'out-of-context');
-    ;
-    current.text(text);
-}
-export function debug(text) {
-    if (!(current instanceof Fragment))
-        throw userError('missing parent node', 'out-of-context');
-    current.debug(text);
-}
-export function predefine(slot, predefined) {
-    return slot || predefined;
-}

package/lib/functional/merge.js

@@ -1,41 +0,0 @@
-import { IValue } from "../core/ivalue";
-export 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]);
-                }
-            }
-        });
-    });
-}

package/lib/functional/models.js

@@ -1,26 +0,0 @@
-import { ArrayModel } from "../models/array-model";
-import { MapModel } from "../models/map-model";
-import { SetModel } from "../models/set-model";
-import { ObjectModel } from "../models/object-model";
-import { current } from "../core/core";
-import { userError } from "../core/errors";
-export function arrayModel(arr = []) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new ArrayModel(arr)).proxy();
-}
-export function mapModel(map = []) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new MapModel(map));
-}
-export function setModel(arr = []) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new SetModel(arr));
-}
-export function objectModel(obj = {}) {
-    if (!current)
-        throw userError('missing parent node', 'out-of-context');
-    return current.register(new ObjectModel(obj));
-}

package/lib/functional/reactivity.js

@@ -1,33 +0,0 @@
-import { IValue } from "../core/ivalue";
-import { Pointer } from "../value/pointer";
-import { current } from "../core/core";
-export function ref(value) {
-    const ref = current.ref(value);
-    return [ref, (value) => ref.$ = value];
-}
-export function mirror(value) {
-    return current.mirror(value);
-}
-export function forward(value) {
-    return current.forward(value);
-}
-export function point(value) {
-    return current.point(value);
-}
-export function expr(func, ...values) {
-    return current.expr(func, ...values);
-}
-export function watch(func, ...values) {
-    current.watch(func, ...values);
-}
-export function valueOf(value) {
-    return value.$;
-}
-export function setValue(ref, value) {
-    if (ref instanceof Pointer && value instanceof IValue) {
-        ref.$$ = value;
-    }
-    else {
-        ref.$ = value instanceof IValue ? value.$ : value;
-    }
-}

package/lib/functional/stack.js

@@ -1,127 +0,0 @@
-import { Component, Extension, Fragment } from "../node/node";
-import { App } from "../node/app";
-import { current } from "../core/core";
-import { ArrayModel } from "../models/array-model";
-import { ArrayView } from "../views/array-view";
-import { MapModel } from "../models/map-model";
-import { MapView } from "../views/map-view";
-import { SetModel } from "../models/set-model";
-import { SetView } from "../views/set-view";
-import { ObjectModel } from "../models/object-model";
-import { ObjectView } from "../views/object-view";
-import { Watch } from "../node/watch";
-import { userError } from "../core/errors";
-export function app(renderer) {
-    return (node, opts) => {
-        return new App(node, opts).runFunctional(renderer, opts);
-    };
-}
-export 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;
-    };
-}
-export 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);
-    };
-}
-export 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);
-    };
-}
-export 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);
-        })
-    };
-}
-export 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;
-}
-export 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);
-    }
-};

package/lib/node/interceptor.js

@@ -1,83 +0,0 @@
-import { Fragment } from "./node";
-import { Destroyable } from "../core/destroyable";
-import { Signal } from "../core/signal";
-import { Slot } from "../core/slot";
-/**
- * Interceptor is designed to connect signals & methods of children elements
- * @class Interceptor
- * @extends Destroyable
- */
-export 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
- */
-export 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);
-    }
-}

package/lib/v/index.js

@@ -1,23 +0,0 @@
-import { debug, text } from "../functional/components";
-import { arrayModel, mapModel, objectModel, setModel } from "../functional/models";
-import { expr, forward, mirror, point, ref, setValue, valueOf, watch } from "../functional/reactivity";
-import { app, component, create, extension, fragment, tag, vx } from "../functional/stack";
-import { current } from "../core/core";
-import { Reference } from "../value/reference";
-import { merge } from "../functional/merge";
-export { debug, arrayModel, mapModel, objectModel, setModel, expr, forward, mirror, point, ref, setValue, valueOf, watch };
-export 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);
-    } });