vasille 2.0.5 → 2.2.2

package/types/spec/react.d.ts

@@ -0,0 +1,4 @@
+import { SvgTagMap, SvgTagNameMap } from "./svg";
+import { HtmlTagMap, TagNameMap } from "./html";
+export declare type AcceptedTagsMap = TagNameMap & SvgTagNameMap;
+export declare type AcceptedTagsSpec = HtmlTagMap & SvgTagMap;

package/types/spec/svg.d.ts

@@ -0,0 +1,314 @@
+import { EventHandler, HtmlAndSvgEvents, Tag } from "./html";
+declare type SvgEvents = {
+    [K in keyof SVGElementEventMap]: EventHandler<SVGElementEventMap[K]> | undefined;
+};
+interface SvgAreaAttrs {
+    "aria-activedescendant": string;
+    "aria-atomic": string;
+    "aria-autocomplete": string;
+    "aria-busy": string;
+    "aria-checked": string;
+    "aria-colcount": string;
+    "aria-colindex": string;
+    "aria-colspan": string;
+    "aria-controls": string;
+    "aria-current": string;
+    "aria-describedby": string;
+    "aria-details": string;
+    "aria-disabled": string;
+    "aria-dropeffect": string;
+    "aria-errormessage": string;
+    "aria-expanded": string;
+    "aria-flowto": string;
+    "aria-grabbed": string;
+    "aria-haspopup": string;
+    "aria-hidden": string;
+    "aria-invalid": string;
+    "aria-keyshortcuts": string;
+    "aria-label": string;
+    "aria-labelledby": string;
+    "aria-level": string;
+    "aria-live": string;
+    "aria-modal": string;
+    "aria-multiline": string;
+    "aria-multiselectable": string;
+    "aria-orientation": string;
+    "aria-owns": string;
+    "aria-placeholder": string;
+    "aria-posinset": string;
+    "aria-pressed": string;
+    "aria-readonly": string;
+    "aria-relevant": string;
+    "aria-required": string;
+    "aria-roledescription": string;
+    "aria-rowcount": string;
+    "aria-rowindex": string;
+    "aria-rowspan": string;
+    "aria-selected": string;
+    "aria-setsize": string;
+    "aria-sort": string;
+    "aria-valuemax": string;
+    "aria-valuemin": string;
+    "aria-valuenow": string;
+    "aria-valuetext": string;
+    "role": string;
+}
+interface SvgConditionalProcessingAtttrs {
+    "requiredExtensions": string;
+    "systemLanguage": string;
+}
+interface SvgCoreAttrs {
+    "id": string;
+    "tabindex": string;
+    "lang": string;
+    "xml:space": string;
+}
+interface SvgSvgAttrs extends SvgAreaAttrs, SvgConditionalProcessingAtttrs, SvgCoreAttrs {
+    "viewBox": string;
+    "preserveAspectRatio": string;
+    "zoomAndPan": string;
+    "transform": string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface Svg3in1Attrs extends SvgAreaAttrs, SvgConditionalProcessingAtttrs, SvgCoreAttrs {
+}
+interface SvgUseAttrs extends Svg3in1Attrs {
+    href: string;
+}
+interface SvgPathLengthAttrs extends Svg3in1Attrs {
+    pathLength: number;
+    "marker-start": string;
+    "marker-mid": string;
+    "marker-end": string;
+}
+interface SvgPathAttrs extends SvgPathLengthAttrs {
+    d: string;
+}
+interface SvgRectAttrs extends SvgPathLengthAttrs {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx: number;
+    ry: number;
+}
+interface SvgCircleAttrs extends SvgPathLengthAttrs {
+    cx: number;
+    cy: number;
+    r: number;
+}
+interface SvgEllipseAttrs extends SvgPathLengthAttrs {
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+}
+interface SvgLineAttrs extends SvgPathLengthAttrs {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+interface SvgPolygonAttrs extends SvgPathLengthAttrs {
+    points: number;
+}
+interface SvgCommonTextAttrs extends Svg3in1Attrs {
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    rotate: number;
+    textLength: number;
+    lengthAdjust: 'spacing' | 'spacingAndGlyphs';
+}
+interface SvgTextPathAttrs extends Svg3in1Attrs {
+    "lengthAdjust": 'spacing' | 'spacingAndGlyphs';
+    "textLength": number;
+    "path": string;
+    "href": string;
+    "startOffset": number;
+    "method": 'align' | 'stretch';
+    "spacing": 'auto' | 'exact';
+    "side": 'left' | 'right';
+}
+interface SvgImageAttrs extends Svg3in1Attrs {
+    "preserveAspectRatio": string;
+    "href": string;
+    "crossorigin": string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface SvgForeignObjectAttrs extends Svg3in1Attrs {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface SvgMarkerAttrs extends Svg3in1Attrs {
+    "viewBox": string;
+    "preserveAspectRatio": string;
+    "refX": number;
+    "refY": number;
+    "markerUnits": 'strokeWidth' | 'userSpaceOnUse';
+    "markerWidth": number | `${number}%` | 'left' | 'center' | 'right';
+    "markerHeight": number | `${number}%` | 'top' | 'center' | 'bottom';
+    "orient": 'auto' | 'auto-start-reverse' | `${number}deg` | number;
+}
+interface SvgAAttrs extends SvgCoreAttrs {
+    href: string;
+    "target": '_self' | '_parent' | '_top' | '_blank';
+    "download": string;
+    "ping": string;
+    "rel": string;
+    "hreflang": string;
+    "type": string;
+    "referrerpolicy": string;
+}
+interface SvgViewAttrs extends SvgCoreAttrs, SvgAreaAttrs {
+    "viewBox": string;
+    "preserveAspectRatio": string;
+    "zoomAndPan": string;
+}
+export interface SvgTagMap {
+    "a": Tag<SvgAAttrs, SvgEvents>;
+    "animate": Tag<SvgCoreAttrs, SvgEvents>;
+    "animateMotion": Tag<SvgCoreAttrs, SvgEvents>;
+    "animateTransform": Tag<SvgCoreAttrs, SvgEvents>;
+    "circle": Tag<SvgCircleAttrs, SvgEvents>;
+    "clipPath": Tag<SvgCoreAttrs, SvgEvents>;
+    "defs": Tag<SvgCoreAttrs, SvgEvents>;
+    "desc": Tag<SvgCoreAttrs, SvgEvents>;
+    "ellipse": Tag<SvgEllipseAttrs, SvgEvents>;
+    "feBlend": Tag<SvgCoreAttrs, SvgEvents>;
+    "feColorMatrix": Tag<SvgCoreAttrs, SvgEvents>;
+    "feComponentTransfer": Tag<SvgCoreAttrs, SvgEvents>;
+    "feComposite": Tag<SvgCoreAttrs, SvgEvents>;
+    "feConvolveMatrix": Tag<SvgCoreAttrs, SvgEvents>;
+    "feDiffuseLighting": Tag<SvgCoreAttrs, SvgEvents>;
+    "feDisplacementMap": Tag<SvgCoreAttrs, SvgEvents>;
+    "feDistantLight": Tag<SvgCoreAttrs, SvgEvents>;
+    "feDropShadow": Tag<SvgCoreAttrs, SvgEvents>;
+    "feFlood": Tag<SvgCoreAttrs, SvgEvents>;
+    "feFuncA": Tag<SvgCoreAttrs, SvgEvents>;
+    "feFuncB": Tag<SvgCoreAttrs, SvgEvents>;
+    "feFuncG": Tag<SvgCoreAttrs, SvgEvents>;
+    "feFuncR": Tag<SvgCoreAttrs, SvgEvents>;
+    "feGaussianBlur": Tag<SvgCoreAttrs, SvgEvents>;
+    "feImage": Tag<SvgCoreAttrs, SvgEvents>;
+    "feMerge": Tag<SvgCoreAttrs, SvgEvents>;
+    "feMergeNode": Tag<SvgCoreAttrs, SvgEvents>;
+    "feMorphology": Tag<SvgCoreAttrs, SvgEvents>;
+    "feOffset": Tag<SvgCoreAttrs, SvgEvents>;
+    "fePointLight": Tag<SvgCoreAttrs, SvgEvents>;
+    "feSpecularLighting": Tag<SvgCoreAttrs, SvgEvents>;
+    "feSpotLight": Tag<SvgCoreAttrs, SvgEvents>;
+    "feTile": Tag<SvgCoreAttrs, SvgEvents>;
+    "feTurbulence": Tag<SvgCoreAttrs, SvgEvents>;
+    "filter": Tag<SvgCoreAttrs, SvgEvents>;
+    "foreignObject": Tag<SvgForeignObjectAttrs, SvgEvents>;
+    "g": Tag<Svg3in1Attrs, SvgEvents>;
+    "image": Tag<SvgImageAttrs, SvgEvents>;
+    "line": Tag<SvgLineAttrs, SvgEvents>;
+    "linearGradient": Tag<SvgCoreAttrs, SvgEvents>;
+    "marker": Tag<SvgMarkerAttrs, SvgEvents>;
+    "mask": Tag<SvgCoreAttrs, SvgEvents>;
+    "metadata": Tag<SvgCoreAttrs, SvgEvents>;
+    "mpath": Tag<SvgCoreAttrs, SvgEvents>;
+    "path": Tag<SvgPathAttrs, SvgEvents>;
+    "pattern": Tag<SvgCoreAttrs, SvgEvents>;
+    "polygon": Tag<SvgCoreAttrs, SvgEvents>;
+    "polyline": Tag<SvgPolygonAttrs, SvgEvents>;
+    "radialGradient": Tag<SvgCoreAttrs, SvgEvents>;
+    "rect": Tag<SvgRectAttrs, SvgEvents>;
+    "script": Tag<SvgCoreAttrs, SvgEvents>;
+    "set": Tag<SvgCoreAttrs, SvgEvents>;
+    "stop": Tag<SvgCoreAttrs, SvgEvents>;
+    "style": Tag<SvgCoreAttrs, SvgEvents>;
+    "svg": Tag<SvgSvgAttrs, SvgEvents>;
+    "switch": Tag<Svg3in1Attrs, SvgEvents>;
+    "symbol": Tag<SvgCoreAttrs, SvgEvents>;
+    "text": Tag<SvgCommonTextAttrs, SvgEvents>;
+    "textPath": Tag<SvgTextPathAttrs, SvgEvents>;
+    "title": Tag<SvgCoreAttrs, SvgEvents>;
+    "tspan": Tag<SvgCommonTextAttrs, SvgEvents>;
+    "use": Tag<SvgUseAttrs, SvgEvents>;
+    "view": Tag<SvgViewAttrs, SvgEvents>;
+}
+declare type SvgTag = HtmlAndSvgEvents;
+interface SvgATag extends SvgTag {
+    rel: string;
+}
+interface SvgSvgTag extends SvgTag {
+    currentScale: number;
+}
+export interface SvgTagNameMap {
+    "a": SvgATag;
+    "animate": SvgTag;
+    "animateMotion": SvgTag;
+    "animateTransform": SvgTag;
+    "circle": SvgTag;
+    "clipPath": SvgTag;
+    "defs": SvgTag;
+    "desc": SvgTag;
+    "ellipse": SvgTag;
+    "feBlend": SvgTag;
+    "feColorMatrix": SvgTag;
+    "feComponentTransfer": SvgTag;
+    "feComposite": SvgTag;
+    "feConvolveMatrix": SvgTag;
+    "feDiffuseLighting": SvgTag;
+    "feDisplacementMap": SvgTag;
+    "feDistantLight": SvgTag;
+    "feDropShadow": SvgTag;
+    "feFlood": SvgTag;
+    "feFuncA": SvgTag;
+    "feFuncB": SvgTag;
+    "feFuncG": SvgTag;
+    "feFuncR": SvgTag;
+    "feGaussianBlur": SvgTag;
+    "feImage": SvgTag;
+    "feMerge": SvgTag;
+    "feMergeNode": SvgTag;
+    "feMorphology": SvgTag;
+    "feOffset": SvgTag;
+    "fePointLight": SvgTag;
+    "feSpecularLighting": SvgTag;
+    "feSpotLight": SvgTag;
+    "feTile": SvgTag;
+    "feTurbulence": SvgTag;
+    "filter": SvgTag;
+    "foreignObject": SvgTag;
+    "g": SvgTag;
+    "image": SvgTag;
+    "line": SvgTag;
+    "linearGradient": SvgTag;
+    "marker": SvgTag;
+    "mask": SvgTag;
+    "metadata": SvgTag;
+    "mpath": SvgTag;
+    "path": SvgTag;
+    "pattern": SvgTag;
+    "polygon": SvgTag;
+    "polyline": SvgTag;
+    "radialGradient": SvgTag;
+    "rect": SvgTag;
+    "script": SvgTag;
+    "set": SvgTag;
+    "stop": SvgTag;
+    "style": SvgTag;
+    "svg": SvgSvgTag;
+    "switch": SvgTag;
+    "symbol": SvgTag;
+    "text": SvgTag;
+    "textPath": SvgTag;
+    "title": SvgTag;
+    "tspan": SvgTag;
+    "use": SvgTag;
+    "view": SvgTag;
+}
+export {};

package/types/v/index.d.ts

@@ -0,0 +1,36 @@
+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 } from "../functional/stack";
+import { Options, TagOptions } from "../functional/options";
+import { AppOptions } from "../node/app";
+import { Reference } from "../value/reference";
+import { merge } from "../functional/merge";
+export { debug, arrayModel, mapModel, objectModel, setModel, expr, forward, mirror, point, ref, setValue, valueOf, watch, Options, TagOptions, AppOptions };
+export declare type VApp<In extends AppOptions<any> = AppOptions<'div'>> = (node: Element, opts: In) => In['return'];
+export declare type VComponent<In extends TagOptions<any>> = (opts: In, callback?: In['slot']) => In['return'];
+export declare type VFragment<In extends Options = Options> = (opts: In, callback?: In['slot']) => In['return'];
+export declare type VExtension<In extends TagOptions<any>> = (opts: In, callback?: In['slot']) => In['return'];
+export declare const v: {
+    merge: typeof merge;
+    destructor(): any;
+    runOnDestroy(callback: () => void): void;
+    if(condition: import("../index").IValue<boolean>, callback: () => void): void;
+    else(callback: () => void): void;
+    elif(condition: import("../index").IValue<boolean>, callback: () => void): void;
+    for<T, K>(model: import("../models/model").ListenableModel<K, T>, callback: (value: T, index: K) => void): void;
+    watch<T_1>(model: import("../index").IValue<T_1>, callback: (value: T_1) => void): void;
+    nextTick(callback: () => void): void;
+    ref(value: any): import("../index").IValue<any>;
+    expr: typeof expr;
+    of: typeof valueOf;
+    sv: typeof setValue;
+    alwaysFalse: Reference<boolean>;
+    app: typeof app;
+    component: typeof component;
+    fragment: typeof fragment;
+    extension: typeof extension;
+    text: typeof text;
+    tag: typeof tag;
+    create: typeof create;
+};

package/types/value/expression.d.ts

@@ -1,10 +1,13 @@
 import { IValue } from "../core/ivalue";
+export declare type KindOfIValue<T extends unknown[]> = {
+    [K in keyof T]: IValue<T[K]>;
+};
 /**
  * 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> {
+export declare class Expression<T, Args extends unknown[]> extends IValue<T> {
     /**
      * The array of value which will trigger recalculation
      * @type {Array}
@@ -30,31 +33,15 @@ export declare class Expression<T, T1 = void, T2 = void, T3 = void, T4 = void, T
     /**
      * Creates a function bounded to N values
      * @param func {Function} the function to bound
+     * @param values
      * @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>);
+    constructor(func: (...args: Args) => T, link: boolean, ...values: KindOfIValue<Args>);
     get $(): T;
     set $(value: T);
-    on(handler: (value: T) => void): this;
-    off(handler: (value: T) => void): this;
-    enable(): this;
-    disable(): this;
-    destroy(): void;
+    $on(handler: (value: T) => void): this;
+    $off(handler: (value: T) => void): this;
+    $enable(): this;
+    $disable(): this;
+    $destroy(): void;
 }

package/types/value/mirror.d.ts

@@ -11,16 +11,16 @@ export declare class Mirror<T> extends Reference<T> {
      * pointed value
      * @type IValue
      */
-    protected pointedValue: IValue<T>;
+    protected $pointedValue: IValue<T>;
     /**
      * Collection of handlers
      * @type Set
      */
-    private readonly handler;
+    private readonly $handler;
     /**
      * Ensure forward only synchronization
      */
-    forwardOnly: boolean;
+    $forwardOnly: boolean;
     /**
      * Constructs a notifiable bind to a value
      * @param value {IValue} is initial value
@@ -29,7 +29,7 @@ export declare class Mirror<T> extends Reference<T> {
     constructor(value: IValue<T>, forwardOnly?: boolean);
     get $(): T;
     set $(v: T);
-    enable(): void;
-    disable(): void;
-    destroy(): void;
+    $enable(): void;
+    $disable(): void;
+    $destroy(): void;
 }

package/types/value/pointer.d.ts

@@ -15,5 +15,5 @@ export declare class Pointer<T> extends Mirror<T> {
      * Point a new ivalue
      * @param value {IValue} value to point
      */
-    point(value: IValue<T>): void;
+    set $$(value: IValue<T>);
 }

package/types/value/reference.d.ts

@@ -9,22 +9,22 @@ export declare class Reference<T> extends IValue<T> {
      * The encapsulated value
      * @type {*}
      */
-    private value;
+    private $value;
     /**
      * Array of handlers
      * @type {Set}
      * @readonly
      */
-    private readonly onchange;
+    private readonly $onchange;
     /**
      * @param value {any} the initial value
      */
     constructor(value: T);
     get $(): T;
     set $(value: T);
-    enable(): void;
-    disable(): void;
-    on(handler: (value: T) => void): void;
-    off(handler: (value: T) => void): void;
-    destroy(): void;
+    $enable(): void;
+    $disable(): void;
+    $on(handler: (value: T) => void): void;
+    $off(handler: (value: T) => void): void;
+    $destroy(): void;
 }

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

@@ -1,4 +1,4 @@
-import { BaseView } from "./base-view";
+import { BaseView, BSO } from "./base-view";
 import { ArrayModel } from "../models/array-model";
 import { Fragment } from "../node/node";
 /**
@@ -7,7 +7,6 @@ import { Fragment } from "../node/node";
  * @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;
+    createChild(input: BSO<T, T, ArrayModel<T>>, id: T, item: T, before?: Fragment): any;
+    protected compose(input: BSO<T, T, ArrayModel<T>>): void;
 }

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

@@ -1,4 +1,4 @@
-import { RepeatNode, RepeatNodePrivate } from "./repeat-node";
+import { RepeatNode, RepeatNodePrivate, RNO } from "./repeat-node";
 import { ListenableModel } from "../models/model";
 /**
  * Private part of BaseView
@@ -18,26 +18,18 @@ export declare class BaseViewPrivate<K, T> extends RepeatNodePrivate<K> {
     removeHandler: (index: K, value: T) => void;
     constructor();
 }
+export interface BSO<K, T, Model extends ListenableModel<K, T>> extends RNO<T, K> {
+    model: Model;
+}
 /**
  * Base class of default views
  * @class BaseView
  * @extends RepeatNode
  * @implements IModel
  */
-export declare class BaseView<K, T, Model extends ListenableModel<K, T>> extends RepeatNode<K, T> {
+export declare class BaseView<K, T, Model extends ListenableModel<K, T>> extends RepeatNode<K, T, BSO<K, T, Model>> {
     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;
+    input: BSO<K, T, Model>;
+    constructor(input: BSO<K, T, Model>, $?: BaseViewPrivate<K, T>);
+    protected compose(input: BSO<K, T, Model>): void;
 }

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { Fragment, INodePrivate } from "../node/node";
-import { Slot } from "../core/slot";
+import { Options } from "../functional/options";
 /**
  * Private part of repeat node
  * @class RepeatNodePrivate
@@ -12,24 +12,23 @@ export declare class RepeatNodePrivate<IdT> extends INodePrivate {
      */
     nodes: Map<IdT, Fragment>;
     constructor();
-    destroy(): void;
+    $destroy(): void;
+}
+export interface RNO<T, IdT> extends Options {
+    slot?: (node: Fragment, value: T, index: IdT) => void;
 }
 /**
  * Repeat node repeats its children
  * @class RepeatNode
  * @extends Fragment
  */
-export declare class RepeatNode<IdT, T> extends Fragment {
+export declare class RepeatNode<IdT, T, Opts extends RNO<T, IdT> = RNO<T, IdT>> extends Fragment<Opts> {
     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;
+    constructor(input: Opts, $: RepeatNodePrivate<IdT>);
+    createChild(opts: Opts, id: IdT, item: T, before?: Fragment): any;
     destroyChild(id: IdT, item: T): void;
 }

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

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