vasille 4.3.1 → 5.0.0

package/lib/value/expression.js

@@ -1,3 +1,4 @@
+import { safe } from "../functional/safety.js";
 import { Reference } from "./reference.js";
 import { IValue } from "../core/ivalue.js";
 /**
@@ -29,13 +30,13 @@ export class Expression extends IValue {
      */
     constructor(func, values, ctx) {
         super();
-        const handler = (i) => {
+        const handler = safe((i) => {
             /* istanbul ignore else */
             if (typeof i === "number") {
                 this.valuesCache[i] = this.values[i]?.V;
             }
             this.sync.V = func.apply(this, this.valuesCache);
-        };
+        });
         this.valuesCache = values.map(item => item?.V);
         this.sync = new Reference(func.apply(this, this.valuesCache));
         let i = 0;

package/lib/views/repeat-node.js

@@ -17,7 +17,7 @@ export class RepeatNode extends Fragment {
         this.slot = input.slot && safe(input.slot);
     }
     createChild(id, item, before) {
-        const node = new Fragment(this.runner);
+        const node = this.newChild(id, item);
         node.parent = this;
         this.destroyChild(id, item);
         if (before) {
@@ -47,4 +47,7 @@ export class RepeatNode extends Fragment {
     destroy() {
         this.nodes.clear();
     }
+    newChild(_id, _item) {
+        return new Fragment(this.runner);
+    }
 }

package/package.json

@@ -3,7 +3,7 @@
   "description": "The same framework which is designed to build bulletproof frontends (core library).",
   "main": "lib/index.js",
   "types": "types/index.d.ts",
-  "version": "4.3.1",
+  "version": "5.0.0",
   "exports": {
     ".": {
       "types": "./types/index.d.ts",
@@ -11,6 +11,12 @@
       "browser": "./lib/index.js",
       "node": "./lib/index.js"
     },
+    "./dev": {
+      "types": "./types/dev/index.d.ts",
+      "import": "./lib/dev/index.js",
+      "browser": "./lib/dev/index.js",
+      "node": "./lib/dev/index.js"
+    },
     "./web-runner": {
       "types": "./types/runner/web/runner.d.ts",
       "import": "./lib/runner/web/runner.js",

package/types/dev/components.d.ts

@@ -0,0 +1,20 @@
+import { App, Portal, PortalOptions } from "../node/app.js";
+import { Fragment, SwitchedNode, SwitchedNodeCase } from "../node/node.js";
+import { Watch, WatchOptions } from "../node/watch.js";
+import { IDevRunner, StaticPosition } from "./inspectable.js";
+export declare class DevWatch<Node, Element, TagOptions extends object, T> extends Watch<Node, Element, TagOptions, T> {
+    constructor(input: WatchOptions<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>, T>, runner: IDevRunner<Node, Element, TagOptions>, usage: StaticPosition);
+}
+export declare class DevApp<Node, Element, TagOptions extends object> extends App<Node, Element, TagOptions> {
+    constructor(node: Element, runner: IDevRunner<Node, Element, TagOptions>);
+}
+export declare class DevPortal<Node, Element, TagOptions extends object, Runner extends IDevRunner<Node, Element, TagOptions>> extends Portal<Node, Element, TagOptions, Runner> {
+    readonly id: number;
+    constructor(input: PortalOptions<Node, Element, TagOptions, Runner>, runner: Runner, declaration: StaticPosition | undefined, usage: StaticPosition | undefined, name: string | undefined);
+}
+export declare class DevSwitchedNode<Node, Element, TagOptions extends object> extends SwitchedNode<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>> {
+    readonly id: number;
+    constructor(usage: StaticPosition, runner: IDevRunner<Node, Element, TagOptions>, cases: SwitchedNodeCase<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>[], _default?: (node: Fragment<Node, Element, TagOptions>) => void);
+    destroy(): void;
+    protected newChild(index: number): Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>;
+}

package/types/dev/core.d.ts

@@ -0,0 +1,8 @@
+import { Reactive } from "../core/core.js";
+import { IDevRunner, InspectableReactive } from "./inspectable.js";
+export declare class DevReactive<Runner extends IDevRunner<unknown, unknown, object>> extends Reactive implements InspectableReactive {
+    readonly id: number;
+    readonly runner: Pick<Runner, "inspector">;
+    constructor(runner: Pick<Runner, "inspector">);
+    destroy(): void;
+}

package/types/dev/index.d.ts

@@ -0,0 +1,8 @@
+export { DevReactive } from "./core.js";
+export { DevApp, DevPortal, DevSwitchedNode, DevWatch } from "./components.js";
+export { type Dependency, type DevValue, type Inspectable, type InspectableReactive, type InspectableReference, type Inspector, type StaticPosition, type ExecutionPosition, type ProtocolExecutionPosition, type ProtocolComponent, type ProtocolDependency, type ProtocolExpression, type ProtocolExpressionError, type ProtocolExpressionUpdate, type ProtocolModel, type ProtocolModelUpdate, type ProtocolNode, type ProtocolParent, type ProtocolPosition, type ProtocolReference, type ProtocolReferenceError, type ProtocolReferenceUpdate, type ProtocolState, type ProtocolTag, type ProtocolCustomModel, type ProtocolStore, type ProtocolRouterActionCall, type ProtocolDevValue, type ProtocolSlotError, type ProtocolRouterStateChange, type ProtocolRoutes, type ProtocolRouterTargetResult, type ProtocolFunctionError, type ProtocolFunctionResult, type ProtocolFunctionCall, type ProtocolEventTrigger, type ProtocolComposeTime, type ProtocolError, type IDevRunner, type DestroyData, executionPosition, provideId, runFn, wrapFn, registerReference, toDevId, toDevIdOrValue, toDevObject, toDevValue, } from "./inspectable.js";
+export { DevArrayModel, DevMapModel, DevSetModel } from "./models.js";
+export { DevFragment, ModelId, shareStateById } from "./node.js";
+export { DevRunner, PositionedText, type DevTagOptions, positionedText, remapObject, DevTextNode, DevTag, } from "./runner.js";
+export { BaseDevReference, DevExpression, DevIValue, DevReference, ExpressionDevReference, type KindOfDevIValue, } from "./state.js";
+export { DevArrayView, DevMapView, DevSetView } from "./views.js";

package/types/dev/inspectable.d.ts

@@ -0,0 +1,244 @@
+import { IRunner } from "../node/runner.js";
+import { DevReference } from "./state.js";
+export type StaticPosition = [string, number, number, number, number];
+export type ExecutionPosition = number;
+export declare function executionPosition(inspector: Inspector, pathLineAndChar: StaticPosition, error: Error): ExecutionPosition;
+export interface Inspectable {
+    id: number;
+}
+export interface InspectableReactive {
+    id: number;
+}
+export interface InspectableReference<T> extends Inspectable {
+    declaration?: StaticPosition;
+    update(value: T, position?: ExecutionPosition): void;
+}
+export interface Dependency extends Inspectable {
+    code: string;
+    value: DevValue;
+}
+export interface ProtocolPosition {
+    id: number;
+    declaration: StaticPosition;
+}
+export interface ProtocolReference extends ProtocolPosition {
+    value: DevValue;
+    time: number;
+}
+export interface ProtocolReferenceUpdate {
+    id: number;
+    time: number;
+    value: DevValue;
+    position?: ExecutionPosition;
+}
+export interface ProtocolError {
+    targetId: number;
+    time: number;
+    error: string;
+}
+export interface ProtocolReferenceError extends ProtocolError {
+    position?: ExecutionPosition;
+}
+export interface ProtocolExpression extends ProtocolReference {
+    deps: (Dependency | string)[];
+    isWatch: boolean;
+}
+export interface ProtocolExpressionUpdate extends ProtocolReferenceUpdate {
+    deps: DevValue[];
+}
+export interface ProtocolExpressionError extends ProtocolReferenceError {
+    deps: DevValue[];
+}
+export interface ProtocolDependency {
+    dependant: number;
+    dependency: number;
+}
+export interface ProtocolComponent {
+    id: number;
+    name: string;
+    props: {
+        [k: string]: number | DevValue;
+    };
+    declaration?: StaticPosition | null;
+    usage?: StaticPosition | null;
+    time: number;
+}
+export interface ProtocolState {
+    id: number;
+    name: string;
+    stateId: number;
+}
+export interface ProtocolParent {
+    child: number;
+    parent: number;
+}
+export interface ProtocolTag {
+    id: number;
+    time: number;
+    usage: StaticPosition | undefined;
+    tagName: string;
+    attr?: {
+        [k: string]: number | DevValue;
+    };
+    class?: (number | string | {
+        [k: string]: number | DevValue;
+    })[];
+    style?: {
+        [k: string]: number | string;
+    };
+    events?: {
+        [k: string]: DevValue;
+    };
+    bind?: {
+        [k: string]: number | DevValue;
+    };
+    callback?: number | DevValue;
+}
+export interface ProtocolNode {
+    id: number;
+    time: number;
+    text: number | DevValue;
+    position: StaticPosition;
+}
+export interface ProtocolSlotError extends ProtocolError {
+    usage: StaticPosition;
+}
+export interface ProtocolComposeTime {
+    id: number;
+    time: number;
+}
+export interface ProtocolModel {
+    id: number;
+    type: "array" | "set" | "map";
+    values: [DevValue, DevValue][];
+    usage: StaticPosition;
+    time: number;
+}
+export interface ProtocolModelUpdate {
+    id: number;
+    method: string;
+    args: DevValue[];
+    return: DevValue;
+}
+export interface ProtocolStore extends ProtocolPosition {
+    name: string;
+    time: number;
+}
+export interface ProtocolCustomModel extends ProtocolPosition {
+    time: number;
+    usage: StaticPosition;
+    name: string;
+    props: {
+        [k: string]: number | DevValue;
+    };
+}
+export interface ProtocolRouterTargetResult {
+    time: number;
+    url: string;
+    path: string;
+    query: {
+        [k: string]: string[];
+    };
+    hash: string;
+    targetFound: boolean;
+    params: object;
+}
+export interface ProtocolExecutionPosition {
+    id: number;
+    position: StaticPosition;
+    stack: string[];
+}
+export interface ProtocolDevValue {
+    id: number;
+    pos: StaticPosition;
+}
+export interface ProtocolRoutes {
+    time: number;
+    paths: string[];
+}
+export interface ProtocolRouterStateChange {
+    time: number;
+    name: string;
+    value: string | null | undefined;
+}
+export interface ProtocolRouterActionCall {
+    time: number;
+    name: string;
+    path: string;
+}
+export interface ProtocolFunctionCall {
+    position: StaticPosition;
+    id: number;
+    args: DevValue[];
+    time: number;
+}
+export interface ProtocolEventTrigger {
+    tagId: number;
+    eventName: string;
+    time: number;
+}
+export interface ProtocolFunctionResult {
+    id: number;
+    result: DevValue;
+    async: boolean;
+    time: number;
+}
+export interface ProtocolFunctionError extends ProtocolError {
+    async: boolean;
+}
+export interface DestroyData {
+    id: number;
+    time: number;
+}
+export interface Inspector {
+    registerExecutionPosition(pos: ProtocolExecutionPosition): void;
+    reportError(err: ProtocolError): void;
+    newReference(ref: ProtocolReference): void;
+    updateReference(update: ProtocolReferenceUpdate): void;
+    reportReferenceError(error: ProtocolReferenceError): void;
+    newExpression(expr: ProtocolExpression): void;
+    updateExpression(update: ProtocolExpressionUpdate): void;
+    reportExpressionCalculationError(error: ProtocolExpressionError): void;
+    createComponent(comp: ProtocolComponent): void;
+    createTag(tag: ProtocolTag): void;
+    createNode(node: ProtocolNode): void;
+    addContextState(state: ProtocolState): void;
+    setElementParent(parent: ProtocolParent): void;
+    reportComponentError(error: ProtocolError): void;
+    reportComponentSlotError(error: ProtocolSlotError): void;
+    composeTime(time: ProtocolComposeTime): void;
+    createModel(model: ProtocolModel): void;
+    updateModel(update: ProtocolModelUpdate): void;
+    createStore(store: ProtocolStore): void;
+    createCustomModel(model: ProtocolCustomModel): void;
+    registeredRoutes(routes: ProtocolRoutes): void;
+    routerStateChange(change: ProtocolRouterStateChange): void;
+    routerActionCall(call: ProtocolRouterActionCall): void;
+    routerTargetResult(data: ProtocolRouterTargetResult): void;
+    functionCall(call: ProtocolFunctionCall): void;
+    functionReturn(result: ProtocolFunctionResult): void;
+    functionThrows(error: ProtocolFunctionError): void;
+    eventTrigger(call: ProtocolEventTrigger): void;
+    destroy(data: DestroyData): void;
+}
+export declare function provideId(): number;
+export interface DevValue {
+    type: string;
+    value?: string | undefined;
+    id?: number;
+}
+export declare function registerReference<T>(value: DevReference<T>, declaration: StaticPosition, inspector: Inspector): DevReference<T>;
+export declare function wrapFn<Args extends unknown[], Result extends object>(fn: (...args: Args) => Result, declaration: StaticPosition, inspector: Inspector): (...args: Args) => Result;
+export declare function runFn<Args extends unknown[], Result extends object>(fn: (...args: Args) => Result, args: Args, declaration: StaticPosition, inspector: Inspector): Result;
+export declare function toDevValue(value: unknown): {
+    type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    value: string | undefined;
+};
+export declare function toDevId(value: unknown): number | undefined;
+export declare function toDevIdOrValue(value: unknown): number | DevValue;
+export declare function toDevObject(value: object): {
+    [k: string]: number | DevValue;
+};
+export interface IDevRunner<Node, Element, TagOptions extends object> extends IRunner<Node, Element, TagOptions> {
+    inspector: Inspector;
+}

package/types/dev/models.d.ts

@@ -0,0 +1,38 @@
+import { Reactive } from "../core/core.js";
+import { ArrayModel } from "../models/array-model.js";
+import { MapModel } from "../models/map-model.js";
+import { SetModel } from "../models/set-model.js";
+import { Inspector, StaticPosition } from "./inspectable.js";
+export declare class DevArrayModel<T> extends ArrayModel<T> {
+    readonly id: number;
+    readonly inspector: Inspector | undefined;
+    constructor(inspector: Inspector | undefined, usage: StaticPosition, data?: Array<T> | number, ctx?: Reactive);
+    destroy(): void;
+    fill(value: T, start?: number, end?: number): this;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    shift(): T | undefined;
+    splice(start: number, deleteCount?: number, ...items: T[]): ArrayModel<T>;
+    unshift(...items: T[]): number;
+    protected shareChange(method: string, args: unknown[], result: unknown): void;
+}
+export declare class DevSetModel<T> extends SetModel<T> {
+    readonly id: number;
+    readonly inspector: Inspector | undefined;
+    constructor(inspector: Inspector | undefined, usage: StaticPosition, set?: T[], ctx?: Reactive);
+    destroy(): void;
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    protected shareChange(method: string, args: unknown[], result: unknown): void;
+}
+export declare class DevMapModel<K, T> extends MapModel<K, T> {
+    readonly id: number;
+    readonly inspector: Inspector | undefined;
+    constructor(inspector: Inspector | undefined, usage: StaticPosition, map?: [K, T][], ctx?: Reactive);
+    destroy(): void;
+    clear(): void;
+    delete(key: K): boolean;
+    set(key: K, value: T): this;
+    protected shareChange(method: string, args: unknown[], result: unknown): void;
+}

package/types/dev/node.d.ts

@@ -0,0 +1,12 @@
+import { Fragment } from "../node/node.js";
+import { IDevRunner, InspectableReactive, Inspector, StaticPosition } from "./inspectable.js";
+export declare const ModelId: unique symbol;
+export declare function shareStateById<T>(id: number | undefined, runner: IDevRunner<unknown, unknown, object>, name: string, value: T): T;
+export declare class DevFragment<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>> implements InspectableReactive {
+    id: number;
+    declaration: StaticPosition | null;
+    inspector: Inspector;
+    constructor(runner: IDevRunner<Node, Element, TagOptions>, declaration: StaticPosition | null, usage: StaticPosition | null, name: string, props: object);
+    destroy(): void;
+    protected pushNode(node: Fragment<Node, Element, TagOptions>): void;
+}

package/types/dev/runner.d.ts

@@ -0,0 +1,37 @@
+import { TextProps } from "../node/node.js";
+import { Runner, Tag, TagOptions, TextNode } from "../runner/web/runner.js";
+import { IDevRunner, Inspector, StaticPosition } from "./inspectable.js";
+export interface DevTagOptions extends TagOptions {
+    usage?: StaticPosition;
+}
+export declare class PositionedText {
+    text: unknown;
+    position: StaticPosition;
+    constructor(text: unknown, position: StaticPosition);
+}
+export declare function positionedText(text: unknown, position: StaticPosition): PositionedText;
+export declare class DevTextNode extends TextNode<DevTagOptions, DevRunner> {
+    readonly id: number;
+    constructor(input: TextProps, runner: DevRunner, usage: StaticPosition, inspector: Inspector);
+    destroy(): void;
+    compose(): void;
+}
+export declare function remapObject<Before, After>(obj: {
+    [k: string]: Before;
+}, transform: (v: Before) => After): {
+    [k: string]: After;
+};
+export declare class DevTag extends Tag<DevTagOptions, DevRunner> {
+    readonly id: number;
+    constructor(options: DevTagOptions, runner: DevRunner, tagName: string, usage: StaticPosition | undefined, inspector: Inspector);
+    applyOptions(options: DevTagOptions): void;
+    getNode(): Element;
+    destroy(): void;
+    compose(): void;
+}
+export declare class DevRunner extends Runner<DevTagOptions> implements IDevRunner<Node, Element, DevTagOptions> {
+    readonly inspector: Inspector;
+    constructor(document: Document, inspector: Inspector);
+    textNode(text: unknown): TextNode<DevTagOptions, DevRunner>;
+    tag(tagName: string, input: DevTagOptions, cb?: ((ctx: DevTag) => void) | undefined): DevTag;
+}

package/types/dev/state.d.ts

@@ -0,0 +1,53 @@
+import { Reactive } from "../core/core.js";
+import { Destroyable } from "../core/destroyable.js";
+import { IValue } from "../core/ivalue.js";
+import { ExecutionPosition, InspectableReference, Inspector, StaticPosition } from "./inspectable.js";
+export type KindOfDevIValue<T extends unknown[]> = {
+    [K in keyof T]: IValue<T[K]> | DevIValue<T[K]> | undefined;
+};
+export declare abstract class DevIValue<T> extends IValue<T> {
+    abstract update(value: T, position: ExecutionPosition): void;
+}
+export declare class BaseDevReference<T> extends DevIValue<T> {
+    protected state: T;
+    protected readonly onChange: Set<(value: T, position?: ExecutionPosition) => void>;
+    constructor(value: T);
+    get V(): T;
+    set V(value: T);
+    update(value: T, position?: ExecutionPosition): void;
+    on(handler: (value: T, position: ExecutionPosition) => void): void;
+    off(handler: (value: T, position: ExecutionPosition) => void): void;
+    protected shareUpdate(position?: ExecutionPosition): void;
+    protected shareError(error: unknown, position?: ExecutionPosition): void;
+}
+export declare class DevReference<T> extends BaseDevReference<T> implements InspectableReference<T>, Destroyable {
+    readonly id: number;
+    readonly inspector: Inspector | undefined;
+    constructor(value: T, declaration: StaticPosition, inspector?: Inspector);
+    destroy(): void;
+    protected shareUpdate(position?: ExecutionPosition): void;
+    protected shareError(error: unknown, position?: ExecutionPosition): void;
+    protected shareDestroy(): void;
+}
+export declare class ExpressionDevReference<T> extends BaseDevReference<T> implements InspectableReference<T> {
+    readonly id: number;
+    readonly inspector: Inspector | undefined;
+    constructor(id: number, value: T, inspector: Inspector | undefined);
+    protected shareError(error: unknown, position: ExecutionPosition): void;
+}
+export declare class DevExpression<T, Args extends unknown[]> extends IValue<T> implements Destroyable, InspectableReference<T> {
+    readonly id: number;
+    readonly declaration: StaticPosition;
+    readonly inspector: Inspector | undefined;
+    private values;
+    private readonly valuesCache;
+    private linkedFunc;
+    private sync;
+    constructor(func: (...args: Args) => T, values: KindOfDevIValue<Args>, ctx: Reactive | undefined, depsCode: string[], declaration: StaticPosition, inspector: Inspector | undefined, isWatch: boolean);
+    update(value: T, position?: ExecutionPosition): void;
+    get V(): T;
+    set V(v: T);
+    on(handler: (value: T, position: ExecutionPosition) => void): void;
+    off(handler: (value: T, position: ExecutionPosition) => void): void;
+    destroy(): void;
+}

package/types/dev/views.d.ts

@@ -0,0 +1,22 @@
+import { Fragment } from "../node/node.js";
+import { ArrayView } from "../views/array-view.js";
+import { BaseViewOptions } from "../views/base-view.js";
+import { MapView } from "../views/map-view.js";
+import { SetView } from "../views/set-view.js";
+import { IDevRunner, StaticPosition } from "./inspectable.js";
+import { DevArrayModel, DevMapModel, DevSetModel } from "./models.js";
+export declare class DevArrayView<Node, Element, TagOptions extends object, T> extends ArrayView<Node, Element, TagOptions, T, IDevRunner<Node, Element, TagOptions>> {
+    readonly id: number;
+    constructor(input: BaseViewOptions<Node, Element, TagOptions, T, T, DevArrayModel<T>, IDevRunner<Node, Element, TagOptions>>, runner: IDevRunner<Node, Element, TagOptions>, usage: StaticPosition);
+    protected newChild(id: T, item: T): Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>;
+}
+export declare class DevSetView<Node, Element, TagOptions extends object, T> extends SetView<Node, Element, TagOptions, T, IDevRunner<Node, Element, TagOptions>> {
+    readonly id: number;
+    constructor(input: BaseViewOptions<Node, Element, TagOptions, T, T, DevSetModel<T>, IDevRunner<Node, Element, TagOptions>>, runner: IDevRunner<Node, Element, TagOptions>, usage: StaticPosition);
+    protected newChild(_id: T, item: T): Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>;
+}
+export declare class DevMapView<Node, Element, TagOptions extends object, K, T> extends MapView<Node, Element, TagOptions, K, T, IDevRunner<Node, Element, TagOptions>> {
+    readonly id: number;
+    constructor(input: BaseViewOptions<Node, Element, TagOptions, K, T, DevMapModel<K, T>, IDevRunner<Node, Element, TagOptions>>, runner: IDevRunner<Node, Element, TagOptions>, usage: StaticPosition);
+    protected newChild(key: K, value: T): Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>;
+}

package/types/index.d.ts

@@ -7,9 +7,8 @@ export { Listener } from "./models/listener.js";
 export { MapModel } from "./models/map-model.js";
 export { SetModel } from "./models/set-model.js";
 export { App, Portal } from "./node/app.js";
-export { Fragment, Tag, TextNode, DebugNode, SwitchedNode } from "./node/node.js";
+export { Fragment, Tag, TextNode, SwitchedNode } from "./node/node.js";
 export { Expression, type KindOfIValue } from "./value/expression.js";
-export { Forward, Backward } from "./value/pointer.js";
 export { Reference } from "./value/reference.js";
 export { ArrayView } from "./views/array-view.js";
 export { BaseView } from "./views/base-view.js";
@@ -18,4 +17,4 @@ export { SetView } from "./views/set-view.js";
 export { userError } from "./core/errors.js";
 export { type ListenableModel } from "./models/model.js";
 export { Watch } from "./node/watch.js";
-export { type Runner } from "./node/runner.js";
+export { type IRunner as Runner } from "./node/runner.js";

package/types/node/app.d.ts

@@ -1,27 +1,26 @@
 import { Fragment, Root } from "./node.js";
-import { Runner } from "./runner.js";
+import { IRunner } from "./runner.js";
 /**
  * Represents a Vasille.js application
  * @class App
  * @extends Root
  */
-export declare class App<Node, Element, TagOptions extends object, T extends object = object> extends Root<Node, Element, TagOptions> {
+export declare class App<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Root<Node, Element, TagOptions, Runner> {
     private readonly node;
     /**
      * Constructs an app node
      * @param node {Element} The root of application
-     * @param runner {Runner} A adapter which execute DOM manipulation
+     * @param runner {IRunner} A adapter which execute DOM manipulation
      */
-    constructor(node: Element, runner: Runner<Node, Element, TagOptions>);
+    constructor(node: Element, runner: Runner);
     appendNode(node: Node): void;
 }
-interface PortalOptions<Node, Element, TagOptions extends object> {
+export interface PortalOptions<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions>> {
     node: Element;
-    slot?: (ctx: Fragment<Node, Element, TagOptions>) => void;
+    slot?: (ctx: Fragment<Node, Element, TagOptions, Runner>) => void;
 }
-export declare class Portal<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions> {
+export declare class Portal<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Fragment<Node, Element, TagOptions, Runner> {
     private readonly node;
-    constructor(input: PortalOptions<Node, Element, TagOptions>, runner: Runner<Node, Element, TagOptions>);
+    constructor(input: PortalOptions<Node, Element, TagOptions, Runner>, runner: Runner);
     appendNode(node: Node): void;
 }
-export {};