vasille 2.0.5 → 2.2.2

package/types/core/executor.d.ts

@@ -1,87 +0,0 @@
-/**
- * Represents an executor unit interface
- * @class Executor
- */
-export declare class Executor {
-    /**
-     * Adds a CSS class
-     * @param el {Element} element to manipulate
-     * @param cl {string} class to be added
-     */
-    addClass(el: Element, cl: string): void;
-    /**
-     * Removes a CSS class
-     * @param el {Element} element to manipulate
-     * @param cl {string} class to be removed
-     */
-    removeClass(el: Element, cl: string): void;
-    /**
-     * Sets a tag attribute
-     * @param el {Element} element to manipulate
-     * @param name {string} name of attribute
-     * @param value {string} value of attribute
-     */
-    setAttribute(el: Element, name: string, value: string): void;
-    /**
-     * Removes a tag attribute
-     * @param el {Element} element to manipulate
-     * @param name {string} name of attribute
-     */
-    removeAttribute(el: Element, name: string): void;
-    /**
-     * Sets a style attribute
-     * @param el {HTMLElement} element to manipulate
-     * @param prop {string} property name
-     * @param value {string} property value
-     */
-    setStyle(el: HTMLElement, prop: string, value: string): void;
-    /**
-     * Inserts a child before target
-     * @param target {Element} target element
-     * @param child {Node} element to insert before
-     */
-    insertBefore(target: Node, child: Node): void;
-    /**
-     * Appends a child to element
-     * @param el {Element} element
-     * @param child {Node} child to be inserted
-     */
-    appendChild(el: Element, child: Node): void;
-    /**
-     * Calls a call-back function
-     * @param cb {function} call-back function
-     */
-    callCallback(cb: () => void): void;
-}
-/**
- * Executor which execute any commands immediately
- * @class InstantExecutor
- * @extends Executor
- */
-export declare class InstantExecutor extends Executor {
-    addClass(el: Element, cl: string): void;
-    removeClass(el: Element, cl: string): void;
-    setAttribute(el: Element, name: string, value: string): void;
-    removeAttribute(el: Element, name: string): void;
-    setStyle(el: HTMLElement, prop: string, value: string): void;
-    insertBefore(target: Node, child: Node): void;
-    appendChild(el: Node, child: Node): void;
-    callCallback(cb: () => void): void;
-}
-/**
- * Executor which execute any commands over timeout
- * @class TimeoutExecutor
- * @extends InstantExecutor
- */
-export declare class TimeoutExecutor extends InstantExecutor {
-    addClass(el: Element, cl: string): void;
-    removeClass(el: Element, cl: string): void;
-    setAttribute(el: Element, name: string, value: string): void;
-    removeAttribute(el: Element, name: string): void;
-    setStyle(el: HTMLElement, prop: string, value: string): void;
-    insertBefore(target: Node, child: Node): void;
-    appendChild(el: Node, child: Node): void;
-    callCallback(cb: () => void): void;
-}
-export declare const instantExecutor: InstantExecutor;
-export declare const timeoutExecutor: TimeoutExecutor;

package/types/core/signal.d.ts

@@ -1,35 +0,0 @@
-/**
- * Signal is an event generator
- * @class Signal
- */
-export declare class Signal<T1 = void, T2 = void, T3 = void, T4 = void, T5 = void, T6 = void, T7 = void, T8 = void, T9 = void> {
-    /**
-     * Handler of event
-     * @type {Set}
-     * @private
-     */
-    private handlers;
-    /**
-     * 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: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9): void;
-    /**
-     * Subscribe to event
-     * @param func {function} handler
-     */
-    subscribe(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => void): void;
-    /**
-     * Unsubscribe from event
-     * @param func {function} handler
-     */
-    unsubscribe(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => void): void;
-}

package/types/core/slot.d.ts

@@ -1,45 +0,0 @@
-import { Fragment } from "../node/node";
-/**
- * Component slot
- * @class Slot
- */
-export declare class Slot<t extends Fragment = Fragment, t1 = void, t2 = void, t3 = void, t4 = void, t5 = void, t6 = void, t7 = void, t8 = void, t9 = void> {
-    /**
-     * Function to run
-     * @type {function(node : Fragment)}
-     */
-    private runner?;
-    /**
-     * Sets the runner
-     * @param func {function} the function to run
-     */
-    insert(func: (a0: t, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void): void;
-    /**
-     * @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: t, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9): void;
-    /**
-     * 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: t, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void, a0: t, a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9): void;
-}

package/types/node/interceptor.d.ts

@@ -1,50 +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 declare class Interceptor<t1 = void, t2 = void, t3 = void, t4 = void, t5 = void, t6 = void, t7 = void, t8 = void, t9 = void> extends Destroyable {
-    /**
-     * Set of signals
-     * @type Set
-     */
-    signals: Set<Signal<t1, t2, t3, t4, t5, t6, t7, t8, t9>>;
-    /**
-     * Set of handlers
-     * @type Set
-     */
-    handlers: Set<(a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void>;
-    /**
-     * Connect a signal or a handler
-     * @param thing {Signal | function}
-     */
-    connect(thing: Signal<t1, t2, t3, t4, t5, t6, t7, t8, t9> | ((a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void)): void;
-    /**
-     * Disconnect a handler from signals
-     * @param handler {function}
-     */
-    disconnect(handler: (a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void): void;
-    destroy(): void;
-}
-/**
- * Interceptor node to implement directly to vasille DOM
- * @class InterceptorNode
- * @extends Extension
- */
-export declare class InterceptorNode<t1 = void, t2 = void, t3 = void, t4 = void, t5 = void, t6 = void, t7 = void, t8 = void, t9 = void> extends Fragment {
-    /**
-     * Internal interceptor
-     * @type Interceptor
-     */
-    interceptor: Interceptor<t1, t2, t3, t4, t5, t6, t7, t8, t9>;
-    /**
-     * The default slot of node
-     * @type Slot
-     */
-    slot: Slot<Fragment, Interceptor<t1, t2, t3, t4, t5, t6, t7, t8, t9>>;
-    compose(): void;
-}

package/types/views/repeater.d.ts

@@ -1,38 +0,0 @@
-import { RepeatNode, RepeatNodePrivate } from "./repeat-node";
-import { IValue } from "../core/ivalue";
-/**
- * Private part of repeater
- * @class RepeaterPrivate
- * @extends RepeatNodePrivate
- */
-export declare class RepeaterPrivate<IdT> extends RepeatNodePrivate<IdT> {
-    /**
-     * Handler to catch count updates
-     */
-    updateHandler: (value: number) => void;
-    /**
-     * Current count of child nodes
-     */
-    currentCount: number;
-    constructor();
-}
-/**
- * The simplest repeat node interpretation, repeat children pack a several times
- * @class Repeater
- * @extends RepeatNode
- */
-export declare class Repeater extends RepeatNode<number, number> {
-    protected $: RepeaterPrivate<number>;
-    /**
-     * The count of children
-     */
-    count: IValue<number>;
-    constructor($?: RepeaterPrivate<number>);
-    /**
-     * Changes the children count
-     */
-    changeCount(number: number): void;
-    created(): void;
-    ready(): void;
-    destroy(): void;
-}