vasille 3.0.2 → 3.2.0

package/types/node/node.d.ts

@@ -1,29 +1,31 @@
-import { Reactive } from "../core/core";
-import { IValue } from "../core/ivalue";
-import { AttrType, TagOptions } from "../functional/options";
+import { Reactive } from "../core/core.js";
+import { IValue } from "../core/ivalue.js";
+import { Runner } from "./runner.js";
 /**
  * This class is symbolic
  * @extends Reactive
  */
-export declare abstract class Root<T extends object = object> extends Reactive<T> {
+export declare abstract class Root<Node, Element, TagOptions extends object, T extends object = object> extends Reactive<T> {
     /**
      * The children list
      * @type Array
      */
-    children: Set<Fragment>;
-    lastChild: Fragment | undefined;
+    readonly children: Set<Fragment<Node, Element, TagOptions>>;
+    readonly runner: Runner<Node, Element, TagOptions>;
+    lastChild: Fragment<Node, Element, TagOptions> | undefined;
+    protected constructor(input: T, runner: Runner<Node, Element, TagOptions>);
     /**
      * Pushes a node to children immediately
      * @param node {Fragment} A node to push
      * @protected
      */
-    protected pushNode(node: Fragment): void;
+    protected pushNode(node: Fragment<Node, Element, TagOptions>): void;
     /**
      * Find the first node in the element if so exists
      * @return {?Element}
      * @protected
      */
-    protected findFirstChild(): Node | undefined;
+    protected findFirstChild(): Node | Element | undefined;
     /**
      * Append a node to end of element
      * @param node {Node} node to insert
@@ -42,64 +44,64 @@ export declare abstract class Root<T extends object = object> extends Reactive<T
      * @param input
      * @param cb {function(Tag, *)} callback
      */
-    tag(tagName: string, input: TagOptionsWithSlot, cb?: (ctx: Tag) => void): void;
+    tag(tagName: string, input: TagOptions, cb?: (ctx: Tag<Node, Element, TagOptions>) => void): void;
     /**
      * Defines a custom element
      * @param node {Fragment} vasille element to insert
      * @param callback {function($ : *)}
      */
-    create<T extends Fragment>(node: T, callback?: (ctx: T) => void): void;
+    create<T extends Fragment<Node, Element, TagOptions>>(node: T, callback?: (ctx: T) => void): void;
     /**
      * Defines an if node
      * @param cond {IValue} condition
      * @param cb {function(Fragment)} callback to run on true
      * @return {this}
      */
-    if(cond: IValue<unknown>, cb: (node: Fragment) => void): void;
-    else(cb: (node: Fragment) => void): void;
-    elif(cond: IValue<unknown>, cb: (node: Fragment) => void): void;
+    if(cond: IValue<unknown>, cb: (node: Fragment<Node, Element, TagOptions>) => void): void;
+    else(cb: (node: Fragment<Node, Element, TagOptions>) => void): void;
+    elif(cond: IValue<unknown>, cb: (node: Fragment<Node, Element, TagOptions>) => void): void;
     /**
      * Create a case for switch
      * @param cond {IValue<boolean>}
      * @param cb {function(Fragment) : void}
      * @return {{cond : IValue, cb : (function(Fragment) : void)}}
      */
-    case(cond: IValue<unknown>, cb: (node: Fragment) => void): {
+    case(cond: IValue<unknown>, cb: (node: Fragment<Node, Element, TagOptions>) => void): {
         cond: IValue<unknown>;
-        cb: (node: Fragment) => void;
+        cb: (node: Fragment<Node, Element, TagOptions>) => void;
     };
     /**
      * @param cb {(function(Fragment) : void)}
      * @return {{cond : IValue, cb : (function(Fragment) : void)}}
      */
-    default(cb: (node: Fragment) => void): {
+    default(cb: (node: Fragment<Node, Element, TagOptions>) => void): {
         cond: IValue<boolean>;
-        cb: (node: Fragment) => void;
+        cb: (node: Fragment<Node, Element, TagOptions>) => void;
     };
     destroy(): void;
 }
-export declare class Fragment<T extends object = object> extends Root<T> {
+export declare class Fragment<Node, Element, TagOptions extends object, T extends object = object> extends Root<Node, Element, TagOptions, T> {
     readonly name?: string;
-    parent: Root;
-    constructor(input: T, name?: string);
+    parent: Root<Node, Element, TagOptions>;
+    constructor(input: T, runner: Runner<Node, Element, TagOptions>, name?: string);
     /**
      * Next node
      * @type {?Fragment}
      */
-    protected next?: Fragment;
+    protected next?: Fragment<Node, Element, TagOptions>;
     /**
      * Previous node
      * @type {?Fragment}
      */
-    protected prev?: Fragment;
+    protected prev?: Fragment<Node, Element, TagOptions>;
     /**
      * Pushes a node to children immediately
      * @param node {Fragment} A node to push
      * @protected
      */
-    protected pushNode(node: Fragment): void;
+    protected pushNode(node: Fragment<Node, Element, TagOptions>): void;
     /**
-     * Append a node to end of element
+     * Append a node to the end of element
      * @param node {Node} node to insert
      */
     appendNode(node: Node): void;
@@ -109,12 +111,12 @@ export declare class Fragment<T extends object = object> extends Root<T> {
      */
     insertAdjacent(node: Node): void;
     compose(): void;
-    insertBefore(node: Fragment): void;
-    insertAfter(node: Fragment): void;
+    insertBefore(node: Fragment<Node, Element, TagOptions>): void;
+    insertAfter(node: Fragment<Node, Element, TagOptions>): void;
     remove(): void;
     destroy(): void;
 }
-interface TextProps {
+export interface TextProps {
     text: unknown;
 }
 /**
@@ -122,11 +124,11 @@ interface TextProps {
  * @class TextNode
  * @extends Fragment
  */
-export declare class TextNode extends Fragment<TextProps> {
-    private node;
-    constructor(input: TextProps);
-    compose(): void;
-    protected findFirstChild(): Node;
+export declare abstract class TextNode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions, TextProps> {
+    protected handler: ((v: unknown) => void) | null;
+    constructor(input: TextProps, runner: Runner<Node, Element, TagOptions>);
+    abstract compose(): void;
+    protected abstract findFirstChild(): Node;
     destroy(): void;
 }
 /**
@@ -134,124 +136,31 @@ export declare class TextNode extends Fragment<TextProps> {
  * @class INode
  * @extends Fragment
  */
-export declare class INode<T extends TagOptions = TagOptions> extends Fragment<T> {
-    /**
-     * Defines if node is unmounted
-     * @type {boolean}
-     */
-    protected unmounted: boolean;
+export declare abstract class INode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions, TagOptions> {
     /**
      * The element of vasille node
      * @type Element
      */
     protected node: Element;
     get element(): Element;
-    /**
-     * Bind attribute value
-     * @param name {String} name of attribute
-     * @param value {IValue} value
-     */
-    attr(name: string, value: IValue<string | number | boolean | null | undefined>): void;
-    /**
-     * Set attribute value
-     * @param name {string} name of attribute
-     * @param value {string} value
-     */
-    setAttr(name: string, value: string | number | boolean | null | undefined): this;
-    /**
-     * Adds a CSS class
-     * @param cl {string} Class name
-     */
-    addClass(cl: string): void;
-    /**
-     * Adds some CSS classes
-     * @param cl {string} classes names
-     */
-    removeClass(cl: string): void;
-    /**
-     * Bind a CSS class
-     * @param className {IValue}
-     */
-    bindClass(className: IValue<string>): void;
-    /**
-     * Bind a floating class name
-     * @param cond {IValue} condition
-     * @param className {string} class name
-     */
-    floatingClass(cond: IValue<boolean>, className: string): void;
-    /**
-     * Defines a style attribute
-     * @param name {String} name of style attribute
-     * @param value {IValue} value
-     */
-    style(name: string, value: IValue<string | number | number[]>): void;
-    /**
-     * Sets a style property value
-     * @param prop {string} Property name
-     * @param value {string} Property value
-     */
-    setStyle(prop: string, value: string | number | number[]): this;
-    /**
-     * Add a listener for an event
-     * @param name {string} Event name
-     * @param handler {function (Event)} Event handler
-     * @param options {Object | boolean} addEventListener options
-     */
-    listen(name: string, handler: (ev: Event) => void, options?: boolean | AddEventListenerOptions): void;
     insertAdjacent(node: Node): void;
-    /**
-     * A v-show & ngShow alternative
-     * @param cond {IValue} show condition
-     */
-    bindShow(cond: IValue<unknown>): void;
-    /**
-     * bind HTML
-     * @param value {IValue}
-     */
-    bindDomApi(name: string, value: IValue<string>): void;
-    protected applyAttrs(attrs: Record<string, AttrType<number | boolean>>): void;
-    protected applyStyle(style: Record<string, string | number | number[] | IValue<string | number | number[]>>): void;
-    protected applyBind(bind: Record<string, any>): void;
-    protected applyOptions(options: T): void;
-}
-export interface TagOptionsWithSlot extends TagOptions {
-    slot?: (ctx: Tag) => void;
-    callback?: (node: Element) => void;
+    protected abstract applyOptions(options: TagOptions): void;
 }
 /**
  * Represents an Vasille.js HTML element node
  * @class Tag
  * @extends INode
  */
-export declare class Tag extends INode<TagOptionsWithSlot> {
-    constructor(input: TagOptionsWithSlot, tagName: string);
-    compose(): void;
-    protected findFirstChild(): Node | undefined;
-    insertAdjacent(node: Node): void;
+export declare abstract class Tag<Node, Element, TagOptions extends object> extends INode<Node, Element, TagOptions> {
+    constructor(input: TagOptions, runner: Runner<Node, Element, TagOptions>, tagName: string);
+    abstract compose(): void;
+    protected findFirstChild(): Node | Element | undefined;
     appendNode(node: Node): void;
-    extent(options: TagOptions): void;
-    /**
-     * Mount/Unmount a node
-     * @param cond {IValue} show condition
-     */
-    bindMount(cond: IValue<unknown>): void;
-    /**
-     * Runs GC
-     */
-    destroy(): void;
-}
-/**
- * Represents a vasille extension node
- * @class Extension
- * @extends INode
- */
-export declare class Extension extends Fragment {
-    tag(tagName: string, input: TagOptionsWithSlot): void;
 }
 /**
  * Defines a node which can switch its children conditionally
  */
-export declare class SwitchedNode extends Fragment {
+export declare class SwitchedNode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions> {
     /**
      * Index of current true condition
      * @type number
@@ -270,19 +179,19 @@ export declare class SwitchedNode extends Fragment {
     /**
      * Constructs a switch node and define a sync function
      */
-    constructor();
+    constructor(runner: Runner<Node, Element, TagOptions>);
     addCase(case_: {
         cond: IValue<unknown>;
-        cb: (node: Fragment) => void;
+        cb: (node: Fragment<Node, Element, TagOptions>) => void;
     }): void;
     /**
      * Creates a child node
      * @param cb {function(Fragment)} Call-back
      */
-    createChild(cb: (node: Fragment) => void): void;
+    createChild(cb: (node: Fragment<Node, Element, TagOptions>) => void): void;
     destroy(): void;
 }
-interface DebugProps {
+export interface DebugProps {
     text: IValue<unknown>;
 }
 /**
@@ -290,13 +199,9 @@ interface DebugProps {
  * @class DebugNode
  * @extends Fragment
  */
-export declare class DebugNode extends Fragment<DebugProps> {
-    private node;
-    constructor(input: DebugProps);
-    compose(): void;
-    /**
-     * Runs garbage collector
-     */
+export declare abstract class DebugNode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions, DebugProps> {
+    protected handler: ((v: unknown) => void) | null;
+    constructor(input: DebugProps, runner: Runner<Node, Element, TagOptions>);
+    abstract compose(): void;
     destroy(): void;
 }
-export {};

package/types/node/runner.d.ts

@@ -0,0 +1,10 @@
+import { IValue } from "../core/ivalue.js";
+import { DebugNode, Tag, TextNode } from "./node.js";
+export interface Runner<Node, Element, TagOptions extends object> {
+    debugUi: boolean;
+    insertBefore(node: Node, before: Node | Element): void;
+    appendChild(node: Element, child: Node | Element): void;
+    textNode(text: unknown): TextNode<Node, Element, TagOptions>;
+    debugNode(text: IValue<unknown>): DebugNode<Node, Element, TagOptions>;
+    tag(tagName: string, input: TagOptions, cb?: (ctx: Tag<Node, Element, TagOptions>) => void): Tag<Node, Element, TagOptions>;
+}

package/types/node/watch.d.ts

@@ -1,16 +1,17 @@
-import { Fragment } from "./node";
-import { IValue } from "../core/ivalue";
-interface WatchOptions<T> {
+import { Fragment } from "./node.js";
+import { IValue } from "../core/ivalue.js";
+import { Runner } from "./runner.js";
+interface WatchOptions<Node, Element, TagOptions extends object, T> {
     model: IValue<T>;
-    slot?: (ctx: Fragment, value: T) => void;
+    slot?: (ctx: Fragment<Node, Element, TagOptions>, value: T) => void;
 }
 /**
  * Watch Node
  * @class Watch
  * @extends Fragment
  */
-export declare class Watch<T> extends Fragment<WatchOptions<T>> {
-    constructor(input: WatchOptions<T>);
+export declare class Watch<Node, Element, TagOptions extends object, T> extends Fragment<Node, Element, TagOptions, WatchOptions<Node, Element, TagOptions, T>> {
+    constructor(input: WatchOptions<Node, Element, TagOptions, T>, runner: Runner<Node, Element, TagOptions>);
     compose(): void;
 }
 export {};

package/types/{binding → runner/web/binding}/attribute.d.ts

@@ -1,6 +1,6 @@
-import { Binding } from "./binding";
-import type { INode } from "../node/node";
-import type { IValue } from "../core/ivalue";
+import { Binding } from "./binding.js";
+import type { INode } from "../../../node/node.js";
+import type { IValue } from "../../../core/ivalue.js";
 /**
  * Represents an Attribute binding description
  * @class AttributeBinding
@@ -13,5 +13,5 @@ export declare class AttributeBinding extends Binding<string | number | boolean
      * @param name {String} the name of attribute
      * @param value {IValue} value to bind
      */
-    constructor(node: INode, name: string, value: IValue<string | number | boolean | null | undefined>);
+    constructor(node: INode<Node, Element, object>, name: string, value: IValue<string | number | boolean | null | undefined>);
 }

package/types/{binding → runner/web/binding}/binding.d.ts

@@ -1,5 +1,5 @@
-import { Destroyable } from "../core/destroyable";
-import type { IValue } from "../core/ivalue";
+import { Destroyable } from "../../../core/destroyable.js";
+import type { IValue } from "../../../core/ivalue.js";
 /**
  * Describe a common binding logic
  * @class Binding

package/types/runner/web/binding/class.d.ts

@@ -0,0 +1,11 @@
+import { Binding } from "./binding.js";
+import type { INode } from "../../../node/node.js";
+import type { IValue } from "../../../core/ivalue.js";
+export declare class StaticClassBinding extends Binding<boolean> {
+    private current;
+    constructor(node: INode<Node, Element, object>, name: string, value: IValue<boolean>);
+}
+export declare class DynamicalClassBinding extends Binding<string> {
+    private current;
+    constructor(node: INode<Node, Element, object>, value: IValue<string>);
+}

package/types/{binding → runner/web/binding}/style.d.ts

@@ -1,6 +1,6 @@
-import { Binding } from "./binding";
-import type { INode } from "../node/node";
-import type { IValue } from "../core/ivalue";
+import { Binding } from "./binding.js";
+import type { INode } from "../../../node/node.js";
+import type { IValue } from "../../../core/ivalue.js";
 export declare function stringifyStyleValue(value: string | number | number[]): string;
 /**
  * Describes a style attribute binding
@@ -14,5 +14,5 @@ export declare class StyleBinding extends Binding<string | number | number[]> {
      * @param name {string} the name of style property
      * @param value {IValue} the value to bind
      */
-    constructor(node: INode, name: string, value: IValue<string | number | number[]>);
+    constructor(node: INode<Node, Element, object>, name: string, value: IValue<string | number | number[]>);
 }

package/types/runner/web/runner.d.ts

@@ -0,0 +1,42 @@
+import { TextNode as AbstractTextNode, DebugNode as AbstractDebugNode, Tag as AbstractTag, Runner as IRunner, IValue } from "../../index.js";
+export type AttrType<T> = IValue<T | string | null> | T | string | null | undefined;
+export type StyleType<T> = T | number | number[] | IValue<string | number | number[]>;
+export interface TagOptions {
+    attr?: Record<string, AttrType<number | boolean>>;
+    class?: (string | IValue<string> | Record<string, boolean | IValue<boolean>>)[];
+    style?: Record<string, StyleType<string>>;
+    events?: Record<string, (...args: unknown[]) => unknown>;
+    bind?: Record<string, any>;
+    slot?: (ctx: Tag) => void;
+    callback?: (node: Element) => void;
+}
+export declare class TextNode extends AbstractTextNode<Node, Element, TagOptions> {
+    readonly runner: Runner;
+    protected node: Text;
+    compose(): void;
+    destroy(): void;
+    protected findFirstChild(): Node;
+}
+export declare class DebugNode extends AbstractDebugNode<Node, Element, TagOptions> {
+    readonly runner: Runner;
+    protected node: Comment;
+    compose(): void;
+    destroy(): void;
+    protected findFirstChild(): Node | Element | undefined;
+}
+export declare class Tag extends AbstractTag<Node, Element, TagOptions> {
+    readonly runner: Runner;
+    compose(): void;
+    destroy(): void;
+    protected applyOptions(options: TagOptions): void;
+}
+export declare class Runner implements IRunner<Node, Element, TagOptions> {
+    readonly debugUi: boolean;
+    readonly document: Document;
+    constructor(debugUi: boolean, document: Document);
+    insertBefore(node: Node, before: Element | Node): void;
+    appendChild(node: Element, child: Element | Node): void;
+    textNode(text: unknown): AbstractTextNode<Node, Element, TagOptions>;
+    debugNode(text: IValue<unknown>): AbstractDebugNode<Node, Element, TagOptions>;
+    tag(tagName: string, input: TagOptions, cb?: ((ctx: AbstractTag<Node, Element, TagOptions>) => void) | undefined): AbstractTag<Node, Element, TagOptions>;
+}

package/types/tsconfig-types.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/binding/attribute.ts","../src/binding/binding.ts","../src/binding/class.ts","../src/binding/style.ts","../src/core/config.ts","../src/core/core.ts","../src/core/destroyable.ts","../src/core/errors.ts","../src/core/ivalue.ts","../src/functional/options.ts","../src/functional/safety.ts","../src/models/array-model.ts","../src/models/listener.ts","../src/models/map-model.ts","../src/models/model.ts","../src/models/set-model.ts","../src/node/app.ts","../src/node/node.ts","../src/node/watch.ts","../src/value/expression.ts","../src/value/pointer.ts","../src/value/reference.ts","../src/views/array-view.ts","../src/views/base-view.ts","../src/views/map-view.ts","../src/views/repeat-node.ts","../src/views/set-view.ts"],"version":"5.6.2"}
+{"root":["../src/index.ts","../src/core/core.ts","../src/core/destroyable.ts","../src/core/errors.ts","../src/core/ivalue.ts","../src/functional/safety.ts","../src/models/array-model.ts","../src/models/listener.ts","../src/models/map-model.ts","../src/models/model.ts","../src/models/set-model.ts","../src/node/app.ts","../src/node/node.ts","../src/node/runner.ts","../src/node/watch.ts","../src/runner/web/runner.ts","../src/runner/web/binding/attribute.ts","../src/runner/web/binding/binding.ts","../src/runner/web/binding/class.ts","../src/runner/web/binding/style.ts","../src/value/expression.ts","../src/value/pointer.ts","../src/value/reference.ts","../src/views/array-view.ts","../src/views/base-view.ts","../src/views/map-view.ts","../src/views/repeat-node.ts","../src/views/set-view.ts"],"version":"5.8.3"}

package/types/value/expression.d.ts

@@ -1,4 +1,4 @@
-import { IValue } from "../core/ivalue";
+import { IValue } from "../core/ivalue.js";
 export type KindOfIValue<T extends unknown[]> = {
     [K in keyof T]: IValue<T[K]>;
 };
@@ -36,7 +36,7 @@ export declare class Expression<T, Args extends unknown[]> extends IValue<T> {
      * @param values
      * @param link {Boolean} links immediately if true
      */
-    constructor(func: (...args: Args) => T, ...values: KindOfIValue<Args>);
+    constructor(func: (...args: Args) => T, values: KindOfIValue<Args>);
     get $(): T;
     set $(value: T);
     on(handler: (value: T) => void): void;

package/types/value/pointer.d.ts

@@ -1,4 +1,4 @@
-import { IValue } from "../core/ivalue";
+import { IValue } from "../core/ivalue.js";
 /**
  * r/w pointer to a value
  * @class Pointer

package/types/value/reference.d.ts

@@ -1,4 +1,4 @@
-import { IValue } from "../core/ivalue";
+import { IValue } from "../core/ivalue.js";
 /**
  * Declares a notifiable value
  * @class Reference

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

@@ -1,12 +1,12 @@
-import { BaseView, BaseViewOptions } from "./base-view";
-import { ArrayModel } from "../models/array-model";
-import { Fragment } from "../node/node";
+import { BaseView, BaseViewOptions } from "./base-view.js";
+import { ArrayModel } from "../models/array-model.js";
+import { Fragment } from "../node/node.js";
 /**
  * Represents a view of an array model
  * @class ArrayView
  * @extends BaseView
  */
-export declare class ArrayView<T> extends BaseView<T, T, ArrayModel<T>> {
-    createChild(input: BaseViewOptions<T, T, ArrayModel<T>>, id: T, item: T, before?: Fragment): any;
+export declare class ArrayView<Node, Element, TagOptions extends object, T> extends BaseView<Node, Element, TagOptions, T, T, ArrayModel<T>> {
+    createChild(input: BaseViewOptions<Node, Element, TagOptions, T, T, ArrayModel<T>>, id: T, item: T, before?: Fragment<Node, Element, TagOptions>): any;
     compose(): void;
 }

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

@@ -1,6 +1,7 @@
-import { RepeatNode, RepeatNodeOptions } from "./repeat-node";
-import { ListenableModel } from "../models/model";
-export interface BaseViewOptions<K, T, Model extends ListenableModel<K, T>> extends RepeatNodeOptions<T, K> {
+import { Runner } from "../node/runner.js";
+import { RepeatNode, RepeatNodeOptions } from "./repeat-node.js";
+import { ListenableModel } from "../models/model.js";
+export interface BaseViewOptions<Node, Element, TagOptions extends object, K, T, Model extends ListenableModel<K, T>> extends RepeatNodeOptions<Node, Element, TagOptions, T, K> {
     model: Model;
 }
 /**
@@ -9,8 +10,8 @@ export interface BaseViewOptions<K, T, Model extends ListenableModel<K, T>> exte
  * @extends RepeatNode
  * @implements IModel
  */
-export declare class BaseView<K, T, Model extends ListenableModel<K, T>> extends RepeatNode<K, T, BaseViewOptions<K, T, Model>> {
-    readonly input: BaseViewOptions<K, T, Model>;
+export declare class BaseView<Node, Element, TagOptions extends object, K, T, Model extends ListenableModel<K, T>> extends RepeatNode<Node, Element, TagOptions, K, T, BaseViewOptions<Node, Element, TagOptions, K, T, Model>> {
+    readonly input: BaseViewOptions<Node, Element, TagOptions, K, T, Model>;
     /**
      * Handler to catch values addition
      * @type {Function}
@@ -21,7 +22,7 @@ export declare class BaseView<K, T, Model extends ListenableModel<K, T>> extends
      * @type {Function}
      */
     protected removeHandler: (index: K, value: T) => void;
-    constructor(input: BaseViewOptions<K, T, Model>, name?: string);
+    constructor(input: BaseViewOptions<Node, Element, TagOptions, K, T, Model>, runner: Runner<Node, Element, TagOptions>, name?: string);
     compose(): void;
     destroy(): void;
 }

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

@@ -1,10 +1,10 @@
-import { BaseView } from "./base-view";
-import { MapModel } from "../models/map-model";
+import { BaseView } from "./base-view.js";
+import { MapModel } from "../models/map-model.js";
 /**
  * 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>> {
+export declare class MapView<Node, Element, TagOptions extends object, K, T> extends BaseView<Node, Element, TagOptions, K, T, MapModel<K, T>> {
     compose(): void;
 }

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

@@ -1,20 +1,21 @@
-import { Fragment } from "../node/node";
-export interface RepeatNodeOptions<T, IdT> {
-    slot?: (ctx: Fragment, value: T, index: IdT) => void;
+import { Fragment } from "../node/node.js";
+import { Runner } from "../node/runner.js";
+export interface RepeatNodeOptions<Node, Element, TagOptions extends object, T, IdT> {
+    slot?: (ctx: Fragment<Node, Element, TagOptions>, value: T, index: IdT) => void;
 }
 /**
  * Repeat node repeats its children
  * @class RepeatNode
  * @extends Fragment
  */
-export declare class RepeatNode<IdT, T, Opts extends RepeatNodeOptions<T, IdT> = RepeatNodeOptions<T, IdT>> extends Fragment<Opts> {
+export declare class RepeatNode<Node, Element, TagOptions extends object, IdT, T, Opts extends RepeatNodeOptions<Node, Element, TagOptions, T, IdT> = RepeatNodeOptions<Node, Element, TagOptions, T, IdT>> extends Fragment<Node, Element, TagOptions, Opts> {
     /**
      * Children node hash
      * @type {Map}
      */
-    protected nodes: Map<IdT, Fragment>;
-    constructor(input: Opts, name?: string);
-    createChild(opts: Opts, id: IdT, item: T, before?: Fragment): any;
+    protected nodes: Map<IdT, Fragment<Node, Element, TagOptions>>;
+    constructor(input: Opts, runner: Runner<Node, Element, TagOptions>, name?: string);
+    createChild(opts: Opts, id: IdT, item: T, before?: Fragment<Node, Element, TagOptions>): any;
     destroyChild(id: IdT, item: T): void;
     destroy(): void;
 }

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

@@ -1,11 +1,12 @@
-import { BaseView, BaseViewOptions } from "./base-view";
-import { SetModel } from "../models/set-model";
+import { Runner } from "../node/runner.js";
+import { BaseView, BaseViewOptions } from "./base-view.js";
+import { SetModel } from "../models/set-model.js";
 /**
  * Create a children pack for each set value
  * @class SetView
  * @extends BaseView
  */
-export declare class SetView<T> extends BaseView<T, T, SetModel<T>> {
-    constructor(input: BaseViewOptions<T, T, SetModel<T>>);
+export declare class SetView<Node, Element, TagOptions extends object, T> extends BaseView<Node, Element, TagOptions, T, T, SetModel<T>> {
+    constructor(input: BaseViewOptions<Node, Element, TagOptions, T, T, SetModel<T>>, runner: Runner<Node, Element, TagOptions>);
     compose(): {};
 }

package/lib/core/config.js

@@ -1,3 +0,0 @@
-export const config = {
-    debugUi: true,
-};