vasille 1.2.9 → 2.0.3

package/types/node/watch.d.ts

@@ -0,0 +1,23 @@
+import { Fragment } from "./node";
+import { Slot } from "../core/slot";
+import { IValue } from "../core/ivalue";
+/**
+ * Watch Node
+ * @class Watch
+ * @extends Fragment
+ */
+export declare class Watch<T> extends Fragment {
+    /**
+     * Default slot
+     * @type Slot
+     */
+    slot: Slot<Fragment, T>;
+    /**
+     * iValue to watch
+     * @type IValue
+     */
+    model: IValue<T>;
+    constructor();
+    $createWatchers(): void;
+    $compose(): void;
+}

package/types/value/expression.d.ts

@@ -0,0 +1,60 @@
+import { IValue } from "../core/ivalue";
+/**
+ * Bind some values to one expression
+ * @class Expression
+ * @extends IValue
+ */
+export declare class Expression<T, T1 = void, T2 = void, T3 = void, T4 = void, T5 = void, T6 = void, T7 = void, T8 = void, T9 = void> extends IValue<T> {
+    /**
+     * The array of value which will trigger recalculation
+     * @type {Array}
+     */
+    private values;
+    /**
+     * Cache the values of expression variables
+     * @type {Array}
+     */
+    private readonly valuesCache;
+    /**
+     * The function which will be executed on recalculation
+     */
+    private readonly func;
+    /**
+     * Expression will link different handler for each value of list
+     */
+    private linkedFunc;
+    /**
+     * The buffer to keep the last calculated value
+     */
+    private sync;
+    /**
+     * Creates a function bounded to N values
+     * @param func {Function} the function to bound
+     * @param link {Boolean} links immediately if true
+     * @param v1 {*} argument
+     * @param v2 {*} argument
+     * @param v3 {*} argument
+     * @param v4 {*} argument
+     * @param v5 {*} argument
+     * @param v6 {*} argument
+     * @param v7 {*} argument
+     * @param v8 {*} argument
+     * @param v9 {*} argument
+     */
+    constructor(func: (a1: T1) => T, link: boolean, v1: IValue<T1>, v2?: IValue<void>, v3?: IValue<void>, v4?: IValue<void>, v5?: IValue<void>, v6?: IValue<void>, v7?: IValue<void>, v8?: IValue<void>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3?: IValue<void>, v4?: IValue<void>, v5?: IValue<void>, v6?: IValue<void>, v7?: IValue<void>, v8?: IValue<void>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2, a3: T3) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4?: IValue<void>, v5?: IValue<void>, v6?: IValue<void>, v7?: IValue<void>, v8?: IValue<void>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2, a3: T3, a4: T4) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5?: IValue<void>, v6?: IValue<void>, v7?: IValue<void>, v8?: IValue<void>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6?: IValue<void>, v7?: IValue<void>, v8?: IValue<void>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7?: IValue<void>, v8?: IValue<void>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>, v8?: IValue<void>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>, v8: IValue<T8>, v9?: IValue<void>);
+    constructor(func: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => T, link: boolean, v1: IValue<T1>, v2: IValue<T2>, v3: IValue<T3>, v4: IValue<T4>, v5: IValue<T5>, v6: IValue<T6>, v7: IValue<T7>, v8: IValue<T8>, v9: IValue<T9>);
+    get $(): T;
+    set $(value: T);
+    on(handler: (value: T) => void): this;
+    off(handler: (value: T) => void): this;
+    enable(): this;
+    disable(): this;
+    $destroy(): void;
+}

package/types/value/mirror.d.ts

@@ -0,0 +1,35 @@
+import { IValue } from "../core/ivalue";
+import { Reference } from "./reference";
+/**
+ * Declares a notifiable bind to a value
+ * @class Mirror
+ * @extends IValue
+ * @version 2
+ */
+export declare class Mirror<T> extends Reference<T> {
+    /**
+     * pointed value
+     * @type IValue
+     */
+    protected pointedValue: IValue<T>;
+    /**
+     * Collection of handlers
+     * @type Set
+     */
+    private readonly handler;
+    /**
+     * Ensure forward only synchronization
+     */
+    forwardOnly: boolean;
+    /**
+     * Constructs a notifiable bind to a value
+     * @param value {IValue} is initial value
+     * @param forwardOnly {boolean} ensure forward only synchronization
+     */
+    constructor(value: IValue<T>, forwardOnly?: boolean);
+    get $(): T;
+    set $(v: T);
+    enable(): this;
+    disable(): this;
+    $destroy(): void;
+}

package/types/value/pointer.d.ts

@@ -0,0 +1,19 @@
+import { Mirror } from "./mirror";
+import { IValue } from "../core/ivalue";
+/**
+ * r/w pointer to a value
+ * @class Pointer
+ * @extends Mirror
+ */
+export declare class Pointer<T> extends Mirror<T> {
+    /**
+     * @param value {IValue} value to point
+     * @param forwardOnly {boolean} forward only data flow
+     */
+    constructor(value: IValue<T>, forwardOnly?: boolean);
+    /**
+     * Point a new ivalue
+     * @param value {IValue} value to point
+     */
+    point(value: IValue<T>): void;
+}

package/types/value/reference.d.ts

@@ -0,0 +1,30 @@
+import { IValue } from "../core/ivalue";
+/**
+ * Declares a notifiable value
+ * @class Reference
+ * @extends IValue
+ */
+export declare class Reference<T> extends IValue<T> {
+    /**
+     * The encapsulated value
+     * @type {*}
+     */
+    private value;
+    /**
+     * Array of handlers
+     * @type {Set}
+     * @readonly
+     */
+    private readonly onchange;
+    /**
+     * @param value {any} the initial value
+     */
+    constructor(value: T);
+    get $(): T;
+    set $(value: T);
+    enable(): this;
+    disable(): this;
+    on(handler: (value: T) => void): this;
+    off(handler: (value: T) => void): this;
+    $destroy(): void;
+}

package/types/views/array-view.d.ts

@@ -0,0 +1,13 @@
+import { BaseView } from "./base-view";
+import { ArrayModel } from "../models/array-model";
+import { Fragment } from "../node/node";
+/**
+ * Represents a view of an array model
+ * @class ArrayView
+ * @extends BaseView
+ */
+export declare class ArrayView<T> extends BaseView<T, T, ArrayModel<T>> {
+    constructor(model: ArrayModel<T>);
+    createChild(id: T, item: T, before?: Fragment): any;
+    $ready(): void;
+}

package/types/views/base-view.d.ts

@@ -0,0 +1,43 @@
+import { RepeatNode, RepeatNodePrivate } from "./repeat-node";
+import { IModel } from "../models/model";
+/**
+ * Private part of BaseView
+ * @class BaseViewPrivate
+ * @extends RepeatNodePrivate
+ */
+export declare class BaseViewPrivate<K, T> extends RepeatNodePrivate<K> {
+    /**
+     * Handler to catch values addition
+     * @type {Function}
+     */
+    addHandler: (index: K, value: T) => void;
+    /**
+     * Handler to catch values removes
+     * @type {Function}
+     */
+    removeHandler: (index: K, value: T) => void;
+    constructor();
+}
+/**
+ * Base class of default views
+ * @class BaseView
+ * @extends RepeatNode
+ * @implements IModel
+ */
+export declare class BaseView<K, T, Model extends IModel<K, T>> extends RepeatNode<K, T> {
+    protected $: BaseViewPrivate<K, T>;
+    /**
+     * Property which will contain a model
+     * @type {IModel}
+     */
+    model: Model;
+    constructor($1?: BaseViewPrivate<K, T>);
+    /**
+     * Handle ready event
+     */
+    $ready(): void;
+    /**
+     * Handles destroy event
+     */
+    $destroy(): void;
+}

package/types/views/map-view.d.ts

@@ -0,0 +1,11 @@
+import { BaseView } from "./base-view";
+import { MapModel } from "../models/map-model";
+/**
+ * Create a children pack for each map value
+ * @class MapView
+ * @extends BaseView
+ */
+export declare class MapView<K, T> extends BaseView<K, T, MapModel<K, T>> {
+    constructor(model: MapModel<K, T>);
+    $ready(): void;
+}

package/types/views/object-view.d.ts

@@ -0,0 +1,11 @@
+import { BaseView } from "./base-view";
+import { ObjectModel } from "../models/object-model";
+/**
+ * Create a children pack for each object field
+ * @class ObjectView
+ * @extends BaseView
+ */
+export declare class ObjectView<T> extends BaseView<string, T, ObjectModel<T>> {
+    constructor(model: ObjectModel<T>);
+    $ready(): void;
+}

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

@@ -0,0 +1,35 @@
+import { Fragment, INodePrivate } from "../node/node";
+import { Slot } from "../core/slot";
+/**
+ * Private part of repeat node
+ * @class RepeatNodePrivate
+ * @extends INodePrivate
+ */
+export declare class RepeatNodePrivate<IdT> extends INodePrivate {
+    /**
+     * Children node hash
+     * @type {Map}
+     */
+    nodes: Map<IdT, Fragment>;
+    constructor();
+    $destroy(): void;
+}
+/**
+ * Repeat node repeats its children
+ * @class RepeatNode
+ * @extends Fragment
+ */
+export declare class RepeatNode<IdT, T> extends Fragment {
+    protected $: RepeatNodePrivate<IdT>;
+    /**
+     * Default slot
+     */
+    slot: Slot<Fragment, T, IdT>;
+    /**
+     * If false will use timeout executor, otherwise the app executor
+     */
+    freezeUi: boolean;
+    constructor($?: RepeatNodePrivate<IdT>);
+    createChild(id: IdT, item: T, before?: Fragment): any;
+    destroyChild(id: IdT, item: T): void;
+}

package/types/views/repeater.d.ts

@@ -0,0 +1,38 @@
+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;
+}

package/types/views/set-view.d.ts

@@ -0,0 +1,11 @@
+import { BaseView } from "./base-view";
+import { SetModel } from "../models/set-model";
+/**
+ * Create a children pack for each set value
+ * @class SetView
+ * @extends BaseView
+ */
+export declare class SetView<T> extends BaseView<T, T, SetModel<T>> {
+    constructor(model: SetModel<T>);
+    $ready(): void;
+}

package/CHANGELOG.md

@@ -1,23 +0,0 @@
-# Changelog
-
-## 1.2
-
-* `:alive` directive
-* `:mount` directive
-* `on$destroy` & `on$mount` events
-
-## 1.1
-
-* Boost up **Reactive References**
-* `:show` directive
-* Small bug fixes
-
-## 1.0
-
-Initial version which includes:
-* **Vasille.js node** classes (Component, Fragment, App)
-* **Reactive Reference** library: Reference, Pointer & Expression
-* **Conditional** node: SwitchNode
-* **Loop nodes**: Repeater, ObjectView, ArrayView, SetView & MapView
-* **Bindings**: class, attribute, event
-* **DOM** creation tools