@odoo/owl 3.0.0-alpha.13 → 3.0.0-alpha.14

package/dist/types/runtime/app.d.ts

@@ -1,57 +1,57 @@
-import { ComponentConstructor } from "./component";
-import { ComponentNode } from "./component_node";
-import { handleError } from "./rendering/error_handling";
-import { Fiber, MountOptions, RootFiber } from "./rendering/fibers";
-import { Plugin, PluginManager } from "./plugins";
-import { state, toRaw } from "./reactivity/state";
-import { Scheduler } from "./rendering/scheduler";
-import { TemplateSet, TemplateSetConfig } from "./template_set";
-import { validateTarget } from "./utils";
-import { GetProps } from "./props";
-type ComponentInstance<C extends ComponentConstructor> = C extends new (...args: any) => infer T ? T : never;
-interface RootConfig<P> {
-    pluginManager?: PluginManager;
-    props?: P;
-}
-export interface AppConfig extends TemplateSetConfig {
-    name?: string;
-    plugins?: typeof Plugin[];
-    pluginManager?: PluginManager;
-    test?: boolean;
-}
-declare global {
-    interface Window {
-        __OWL_DEVTOOLS__: {
-            apps: Set<App>;
-            Fiber: typeof Fiber;
-            RootFiber: typeof RootFiber;
-            toRaw: typeof toRaw;
-            proxy: typeof state;
-        };
-    }
-}
-type MountTarget = HTMLElement | ShadowRoot;
-interface Root<T extends ComponentConstructor> {
-    node: ComponentNode;
-    promise: Promise<ComponentInstance<T>>;
-    mount(target: MountTarget, options?: MountOptions): Promise<ComponentInstance<T>>;
-    destroy(): void;
-}
-export declare class App extends TemplateSet {
-    static validateTarget: typeof validateTarget;
-    static apps: Set<App>;
-    static version: string;
-    name: string;
-    scheduler: Scheduler;
-    roots: Set<Root<any>>;
-    pluginManager: PluginManager;
-    constructor(config?: AppConfig);
-    createRoot<T extends ComponentConstructor>(Root: T, config?: RootConfig<GetProps<ComponentInstance<T>>>): Root<T>;
-    makeNode<T extends ComponentConstructor>(Component: T, props: GetProps<ComponentInstance<T>>): ComponentNode;
-    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, resolve: (c: any) => void, reject: (e: any) => void, options?: MountOptions): void;
-    destroy(): void;
-    createComponent<P extends Record<string, any>>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
-    handleError(...args: Parameters<typeof handleError>): void;
-}
-export declare function mount<T extends ComponentConstructor>(C: T, target: MountTarget, config?: AppConfig & RootConfig<GetProps<ComponentInstance<T>>> & MountOptions): Promise<ComponentInstance<T>>;
-export {};
+import { ComponentConstructor } from "./component";
+import { ComponentNode } from "./component_node";
+import { handleError } from "./rendering/error_handling";
+import { Fiber, MountOptions, RootFiber } from "./rendering/fibers";
+import { Plugin, PluginManager } from "./plugins";
+import { proxy, toRaw } from "./reactivity/proxy";
+import { Scheduler } from "./rendering/scheduler";
+import { TemplateSet, TemplateSetConfig } from "./template_set";
+import { validateTarget } from "./utils";
+import { GetProps } from "./props";
+type ComponentInstance<C extends ComponentConstructor> = C extends new (...args: any) => infer T ? T : never;
+interface RootConfig<P> {
+    pluginManager?: PluginManager;
+    props?: P;
+}
+export interface AppConfig extends TemplateSetConfig {
+    name?: string;
+    plugins?: (typeof Plugin)[];
+    pluginManager?: PluginManager;
+    test?: boolean;
+}
+declare global {
+    interface Window {
+        __OWL_DEVTOOLS__: {
+            apps: Set<App>;
+            Fiber: typeof Fiber;
+            RootFiber: typeof RootFiber;
+            toRaw: typeof toRaw;
+            proxy: typeof proxy;
+        };
+    }
+}
+type MountTarget = HTMLElement | ShadowRoot;
+interface Root<T extends ComponentConstructor> {
+    node: ComponentNode;
+    promise: Promise<ComponentInstance<T>>;
+    mount(target: MountTarget, options?: MountOptions): Promise<ComponentInstance<T>>;
+    destroy(): void;
+}
+export declare class App extends TemplateSet {
+    static validateTarget: typeof validateTarget;
+    static apps: Set<App>;
+    static version: string;
+    name: string;
+    scheduler: Scheduler;
+    roots: Set<Root<any>>;
+    pluginManager: PluginManager;
+    constructor(config?: AppConfig);
+    createRoot<T extends ComponentConstructor>(Root: T, config?: RootConfig<GetProps<ComponentInstance<T>>>): Root<T>;
+    makeNode<T extends ComponentConstructor>(Component: T, props: GetProps<ComponentInstance<T>>): ComponentNode;
+    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, resolve: (c: any) => void, reject: (e: any) => void, options?: MountOptions): void;
+    destroy(): void;
+    createComponent<P extends Record<string, any>>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
+    handleError(...args: Parameters<typeof handleError>): void;
+}
+export declare function mount<T extends ComponentConstructor>(C: T, target: MountTarget, config?: AppConfig & RootConfig<GetProps<ComponentInstance<T>>> & MountOptions): Promise<ComponentInstance<T>>;
+export {};

package/dist/types/runtime/blockdom/attributes.d.ts

@@ -1,6 +1,6 @@
-import type { Setter } from "./block_compiler";
-export declare function createAttrUpdater(attr: string): Setter<HTMLElement>;
-export declare function attrsSetter(this: HTMLElement, attrs: any): void;
-export declare function attrsUpdater(this: HTMLElement, attrs: any, oldAttrs: any): void;
-export declare function setClass(this: HTMLElement, val: any): void;
-export declare function updateClass(this: HTMLElement, val: any, oldVal: any): void;
+import type { Setter } from "./block_compiler";
+export declare function createAttrUpdater(attr: string): Setter<HTMLElement>;
+export declare function attrsSetter(this: HTMLElement, attrs: any): void;
+export declare function attrsUpdater(this: HTMLElement, attrs: any, oldAttrs: any): void;
+export declare function setClass(this: HTMLElement, val: any): void;
+export declare function updateClass(this: HTMLElement, val: any, oldVal: any): void;

package/dist/types/runtime/blockdom/block_compiler.d.ts

@@ -1,21 +1,21 @@
-import type { VNode } from "./index";
-type BlockType = (data?: any[], children?: VNode[]) => VNode;
-/**
- * Compiling blocks is a multi-step process:
- *
- * 1. build an IntermediateTree from the HTML element. This intermediate tree
- *    is a binary tree structure that encode dynamic info sub nodes, and the
- *    path required to reach them
- * 2. process the tree to build a block context, which is an object that aggregate
- *    all dynamic info in a list, and also, all ref indexes.
- * 3. process the context to build appropriate builder/setter functions
- * 4. make a dynamic block class, which will efficiently collect references and
- *    create/update dynamic locations/children
- *
- * @param str
- * @returns a new block type, that can build concrete blocks
- */
-export declare function createBlock(str: string): BlockType;
-export type Setter<T = any> = (this: T, value: any) => void;
-export type Updater<T = any> = (this: T, value: any, oldVal: any) => void;
-export {};
+import type { VNode } from "./index";
+type BlockType = (data?: any[], children?: VNode[]) => VNode;
+/**
+ * Compiling blocks is a multi-step process:
+ *
+ * 1. build an IntermediateTree from the HTML element. This intermediate tree
+ *    is a binary tree structure that encode dynamic info sub nodes, and the
+ *    path required to reach them
+ * 2. process the tree to build a block context, which is an object that aggregate
+ *    all dynamic info in a list, and also, all ref indexes.
+ * 3. process the context to build appropriate builder/setter functions
+ * 4. make a dynamic block class, which will efficiently collect references and
+ *    create/update dynamic locations/children
+ *
+ * @param str
+ * @returns a new block type, that can build concrete blocks
+ */
+export declare function createBlock(str: string): BlockType;
+export type Setter<T = any> = (this: T, value: any) => void;
+export type Updater<T = any> = (this: T, value: any, oldVal: any) => void;
+export {};

package/dist/types/runtime/blockdom/config.d.ts

@@ -1,8 +1,8 @@
-export declare function filterOutModifiersFromData(dataList: any[]): {
-    modifiers: string[];
-    data: any[];
-};
-export declare const config: {
-    shouldNormalizeDom: boolean;
-    mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;
-};
+export declare function filterOutModifiersFromData(dataList: any[]): {
+    modifiers: string[];
+    data: any[];
+};
+export declare const config: {
+    shouldNormalizeDom: boolean;
+    mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;
+};

package/dist/types/runtime/blockdom/event_catcher.d.ts

@@ -1,7 +1,7 @@
-import type { VNode } from "./index";
-type EventsSpec = {
-    [name: string]: number;
-};
-type Catcher = (child: VNode, handlers: any[]) => VNode;
-export declare function createCatcher(eventsSpec: EventsSpec): Catcher;
-export {};
+import type { VNode } from "./index";
+type EventsSpec = {
+    [name: string]: number;
+};
+type Catcher = (child: VNode, handlers: any[]) => VNode;
+export declare function createCatcher(eventsSpec: EventsSpec): Catcher;
+export {};

package/dist/types/runtime/blockdom/events.d.ts

@@ -1,8 +1,8 @@
-type EventHandlerSetter = (this: HTMLElement, data: any) => void;
-interface EventHandlerCreator {
-    setup: EventHandlerSetter;
-    update: EventHandlerSetter;
-    remove: (this: HTMLElement) => void;
-}
-export declare function createEventHandler(rawEvent: string): EventHandlerCreator;
-export {};
+type EventHandlerSetter = (this: HTMLElement, data: any) => void;
+interface EventHandlerCreator {
+    setup: EventHandlerSetter;
+    update: EventHandlerSetter;
+    remove: (this: HTMLElement) => void;
+}
+export declare function createEventHandler(rawEvent: string): EventHandlerCreator;
+export {};

package/dist/types/runtime/blockdom/html.d.ts

@@ -1,17 +1,17 @@
-import type { VNode } from "./index";
-declare class VHtml {
-    html: string;
-    parentEl?: HTMLElement | undefined;
-    content: ChildNode[];
-    constructor(html: string);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VHtml | null, afterNode: Node | null): void;
-    patch(other: VHtml): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node;
-    toString(): string;
-}
-export declare function html(str: string): VNode<VHtml>;
-export {};
+import type { VNode } from "./index";
+declare class VHtml {
+    html: string;
+    parentEl?: HTMLElement | undefined;
+    content: ChildNode[];
+    constructor(html: string);
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
+    moveBeforeVNode(other: VHtml | null, afterNode: Node | null): void;
+    patch(other: VHtml): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node;
+    toString(): string;
+}
+export declare function html(str: string): VNode<VHtml>;
+export {};

package/dist/types/runtime/blockdom/index.d.ts

@@ -1,26 +1,26 @@
-export { config } from "./config";
-export { toggler } from "./toggler";
-export { createBlock } from "./block_compiler";
-export { list } from "./list";
-export { multi } from "./multi";
-export { text, comment } from "./text";
-export { html } from "./html";
-export { createCatcher } from "./event_catcher";
-export interface VNode<T = any> {
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: T | null, afterNode: Node | null): void;
-    patch(other: T, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    el?: undefined | HTMLElement | Text;
-    parentEl?: undefined | HTMLElement;
-    isOnlyChild?: boolean | undefined;
-    key?: any;
-}
-export type BDom = VNode<any>;
-export declare function mount(vnode: VNode, fixture: HTMLElement, afterNode?: Node | null): void;
-export declare function patch(vnode1: VNode, vnode2: VNode, withBeforeRemove?: boolean): void;
-export declare function remove(vnode: VNode, withBeforeRemove?: boolean): void;
-export declare function withKey(vnode: VNode, key: any): VNode<any>;
+export { config } from "./config";
+export { toggler } from "./toggler";
+export { createBlock } from "./block_compiler";
+export { list } from "./list";
+export { multi } from "./multi";
+export { text, comment } from "./text";
+export { html } from "./html";
+export { createCatcher } from "./event_catcher";
+export interface VNode<T = any> {
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
+    moveBeforeVNode(other: T | null, afterNode: Node | null): void;
+    patch(other: T, withBeforeRemove: boolean): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node | undefined;
+    el?: undefined | HTMLElement | Text;
+    parentEl?: undefined | HTMLElement;
+    isOnlyChild?: boolean | undefined;
+    key?: any;
+}
+export type BDom = VNode<any>;
+export declare function mount(vnode: VNode, fixture: HTMLElement, afterNode?: Node | null): void;
+export declare function patch(vnode1: VNode, vnode2: VNode, withBeforeRemove?: boolean): void;
+export declare function remove(vnode: VNode, withBeforeRemove?: boolean): void;
+export declare function withKey(vnode: VNode, key: any): VNode<any>;

package/dist/types/runtime/blockdom/list.d.ts

@@ -1,18 +1,18 @@
-import type { VNode } from "./index";
-declare class VList {
-    children: VNode[];
-    anchor: Node | undefined;
-    parentEl?: HTMLElement | undefined;
-    isOnlyChild?: boolean | undefined;
-    constructor(children: VNode[]);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VList | null, afterNode: Node | null): void;
-    patch(other: VList, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function list(children: VNode[]): VNode<VList>;
-export {};
+import type { VNode } from "./index";
+declare class VList {
+    children: VNode[];
+    anchor: Node | undefined;
+    parentEl?: HTMLElement | undefined;
+    isOnlyChild?: boolean | undefined;
+    constructor(children: VNode[]);
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
+    moveBeforeVNode(other: VList | null, afterNode: Node | null): void;
+    patch(other: VList, withBeforeRemove: boolean): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node | undefined;
+    toString(): string;
+}
+export declare function list(children: VNode[]): VNode<VList>;
+export {};

package/dist/types/runtime/blockdom/multi.d.ts

@@ -1,17 +1,17 @@
-import type { VNode } from "./index";
-export declare class VMulti {
-    children: (VNode | undefined)[];
-    anchors?: Node[] | undefined;
-    parentEl?: HTMLElement | undefined;
-    isOnlyChild?: boolean | undefined;
-    constructor(children: (VNode | undefined)[]);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VMulti | null, afterNode: Node | null): void;
-    patch(other: VMulti, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function multi(children: (VNode | undefined)[]): VNode<VMulti>;
+import type { VNode } from "./index";
+export declare class VMulti {
+    children: (VNode | undefined)[];
+    anchors?: Node[] | undefined;
+    parentEl?: HTMLElement | undefined;
+    isOnlyChild?: boolean | undefined;
+    constructor(children: (VNode | undefined)[]);
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
+    moveBeforeVNode(other: VMulti | null, afterNode: Node | null): void;
+    patch(other: VMulti, withBeforeRemove: boolean): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node | undefined;
+    toString(): string;
+}
+export declare function multi(children: (VNode | undefined)[]): VNode<VMulti>;

package/dist/types/runtime/blockdom/text.d.ts

@@ -1,26 +1,26 @@
-import type { VNode } from "./index";
-declare abstract class VSimpleNode {
-    text: string | String;
-    parentEl?: HTMLElement | undefined;
-    el?: any;
-    constructor(text: string | String);
-    mountNode(node: Node, parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VText | null, afterNode: Node | null): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node;
-    toString(): string | String;
-}
-declare class VText extends VSimpleNode {
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    patch(other: VText): void;
-}
-declare class VComment extends VSimpleNode {
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    patch(): void;
-}
-export declare function text(str: string | String): VNode<VText>;
-export declare function comment(str: string): VNode<VComment>;
-export declare function toText(value: any): string;
-export {};
+import type { VNode } from "./index";
+declare abstract class VSimpleNode {
+    text: string | String;
+    parentEl?: HTMLElement | undefined;
+    el?: any;
+    constructor(text: string | String);
+    mountNode(node: Node, parent: HTMLElement, afterNode: Node | null): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
+    moveBeforeVNode(other: VText | null, afterNode: Node | null): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node;
+    toString(): string | String;
+}
+declare class VText extends VSimpleNode {
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    patch(other: VText): void;
+}
+declare class VComment extends VSimpleNode {
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    patch(): void;
+}
+export declare function text(str: string | String): VNode<VText>;
+export declare function comment(str: string): VNode<VComment>;
+export declare function toText(value: any): string;
+export {};

package/dist/types/runtime/blockdom/toggler.d.ts

@@ -1,17 +1,17 @@
-import type { VNode } from "./index";
-declare class VToggler {
-    key: string;
-    child: VNode;
-    parentEl?: HTMLElement | undefined;
-    constructor(key: string, child: VNode);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: VToggler | null, afterNode: Node | null): void;
-    patch(other: VToggler, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function toggler(key: string, child: VNode): VNode<VToggler>;
-export {};
+import type { VNode } from "./index";
+declare class VToggler {
+    key: string;
+    child: VNode;
+    parentEl?: HTMLElement | undefined;
+    constructor(key: string, child: VNode);
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
+    moveBeforeVNode(other: VToggler | null, afterNode: Node | null): void;
+    patch(other: VToggler, withBeforeRemove: boolean): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node | undefined;
+    toString(): string;
+}
+export declare function toggler(key: string, child: VNode): VNode<VToggler>;
+export {};

package/dist/types/runtime/component.d.ts

@@ -1,18 +1,18 @@
-import type { ComponentNode } from "./component_node";
-interface StaticComponentProperties {
-    template: string;
-    components?: {
-        [componentName: string]: ComponentConstructor;
-    };
-}
-export interface ComponentConstructor extends StaticComponentProperties {
-    new (node: ComponentNode): Component;
-}
-export declare class Component {
-    static template: string;
-    __owl__: ComponentNode;
-    constructor(node: ComponentNode);
-    setup(): void;
-    render(deep?: boolean): void;
-}
-export {};
+import type { ComponentNode } from "./component_node";
+interface StaticComponentProperties {
+    template: string;
+    components?: {
+        [componentName: string]: ComponentConstructor;
+    };
+}
+export interface ComponentConstructor extends StaticComponentProperties {
+    new (node: ComponentNode): Component;
+}
+export declare class Component {
+    static template: string;
+    __owl__: ComponentNode;
+    constructor(node: ComponentNode);
+    setup(): void;
+    render(deep?: boolean): void;
+}
+export {};

package/dist/types/runtime/component_node.d.ts

@@ -1,61 +1,61 @@
-import type { App } from "./app";
-import { BDom, VNode } from "./blockdom";
-import { Component, ComponentConstructor } from "./component";
-import { PluginManager } from "./plugins";
-import { Computation } from "./reactivity/computations";
-import { Fiber, MountFiber, MountOptions } from "./rendering/fibers";
-import { STATUS } from "./status";
-export declare function saveCurrent(): () => void;
-export declare function getCurrent(): ComponentNode;
-export declare function useComponent(): Component;
-type LifecycleHook = Function;
-export declare class ComponentNode implements VNode<ComponentNode> {
-    el?: HTMLElement | Text | undefined;
-    app: App;
-    fiber: Fiber | null;
-    component: Component;
-    bdom: BDom | null;
-    status: STATUS;
-    forceNextRender: boolean;
-    parentKey: string | null;
-    name: string;
-    props: Record<string, any>;
-    renderFn: Function;
-    parent: ComponentNode | null;
-    children: {
-        [key: string]: ComponentNode;
-    };
-    willStart: LifecycleHook[];
-    willUpdateProps: LifecycleHook[];
-    willUnmount: LifecycleHook[];
-    mounted: LifecycleHook[];
-    willPatch: LifecycleHook[];
-    patched: LifecycleHook[];
-    willDestroy: LifecycleHook[];
-    signalComputation: Computation;
-    pluginManager: PluginManager;
-    constructor(C: ComponentConstructor, props: Record<string, any>, app: App, parent: ComponentNode | null, parentKey: string | null);
-    mountComponent(target: any, options?: MountOptions): void;
-    initiateRender(fiber: Fiber | MountFiber): Promise<void>;
-    render(deep: boolean): Promise<void>;
-    cancel(): void;
-    _cancel(): void;
-    destroy(): void;
-    _destroy(): void;
-    updateAndRender(props: Record<string, any>, parentFiber: Fiber): Promise<void>;
-    /**
-     * Finds a child that has dom that is not yet updated, and update it. This
-     * method is meant to be used only in the context of repatching the dom after
-     * a mounted hook failed and was handled.
-     */
-    updateDom(): void;
-    firstNode(): Node | undefined;
-    mount(parent: HTMLElement, anchor: ChildNode): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: ComponentNode | null, afterNode: Node | null): void;
-    patch(): void;
-    _patch(): void;
-    beforeRemove(): void;
-    remove(): void;
-}
-export {};
+import type { App } from "./app";
+import { BDom, VNode } from "./blockdom";
+import { Component, ComponentConstructor } from "./component";
+import { PluginManager } from "./plugins";
+import { Computation } from "./reactivity/computations";
+import { Fiber, MountFiber, MountOptions } from "./rendering/fibers";
+import { STATUS } from "./status";
+export declare function saveCurrent(): () => void;
+export declare function getCurrent(): ComponentNode;
+export declare function useComponent(): Component;
+type LifecycleHook = Function;
+export declare class ComponentNode implements VNode<ComponentNode> {
+    el?: HTMLElement | Text | undefined;
+    app: App;
+    fiber: Fiber | null;
+    component: Component;
+    bdom: BDom | null;
+    status: STATUS;
+    forceNextRender: boolean;
+    parentKey: string | null;
+    name: string;
+    props: Record<string, any>;
+    renderFn: Function;
+    parent: ComponentNode | null;
+    children: {
+        [key: string]: ComponentNode;
+    };
+    willStart: LifecycleHook[];
+    willUpdateProps: LifecycleHook[];
+    willUnmount: LifecycleHook[];
+    mounted: LifecycleHook[];
+    willPatch: LifecycleHook[];
+    patched: LifecycleHook[];
+    willDestroy: LifecycleHook[];
+    signalComputation: Computation;
+    pluginManager: PluginManager;
+    constructor(C: ComponentConstructor, props: Record<string, any>, app: App, parent: ComponentNode | null, parentKey: string | null);
+    mountComponent(target: any, options?: MountOptions): void;
+    initiateRender(fiber: Fiber | MountFiber): Promise<void>;
+    render(deep: boolean): Promise<void>;
+    cancel(): void;
+    _cancel(): void;
+    destroy(): void;
+    _destroy(): void;
+    updateAndRender(props: Record<string, any>, parentFiber: Fiber): Promise<void>;
+    /**
+     * Finds a child that has dom that is not yet updated, and update it. This
+     * method is meant to be used only in the context of repatching the dom after
+     * a mounted hook failed and was handled.
+     */
+    updateDom(): void;
+    firstNode(): Node | undefined;
+    mount(parent: HTMLElement, anchor: ChildNode): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
+    moveBeforeVNode(other: ComponentNode | null, afterNode: Node | null): void;
+    patch(): void;
+    _patch(): void;
+    beforeRemove(): void;
+    remove(): void;
+}
+export {};

package/dist/types/runtime/event_handling.d.ts

@@ -1 +1 @@
-export declare const mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;
+export declare const mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;