@odoo/owl 2.0.0-beta.3 → 2.0.1

package/dist/types/owl.d.ts

@@ -0,0 +1,539 @@
+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;
+}
+declare function toggler(key: string, child: VNode): VNode<VToggler>;
+
+declare 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
+ */
+declare function createBlock(str: string): BlockType;
+
+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;
+}
+declare function list(children: VNode[]): VNode<VList>;
+
+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;
+}
+declare function multi(children: (VNode | undefined)[]): VNode<VMulti>;
+
+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;
+}
+declare function text(str: string | String): VNode<VText>;
+declare function comment(str: string): VNode<VComment>;
+
+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;
+}
+declare function html(str: string): VNode<VHtml>;
+
+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;
+}
+declare type BDom = VNode<any>;
+declare function mount$1(vnode: VNode, fixture: HTMLElement, afterNode?: Node | null): void;
+declare function patch(vnode1: VNode, vnode2: VNode, withBeforeRemove?: boolean): void;
+declare function remove(vnode: VNode, withBeforeRemove?: boolean): void;
+
+declare type Callback = () => void;
+declare function validateTarget(target: HTMLElement): void;
+declare class EventBus extends EventTarget {
+    trigger(name: string, payload?: any): void;
+}
+declare function whenReady(fn?: any): Promise<void>;
+declare function loadFile(url: string): Promise<string>;
+declare class Markup extends String {
+}
+declare function markup(value: any): Markup;
+
+declare const TARGET: unique symbol;
+declare const SKIP: unique symbol;
+declare type Target = object;
+declare type Reactive<T extends Target = Target> = T & {
+    [TARGET]: any;
+};
+declare type NonReactive<T extends Target = Target> = T & {
+    [SKIP]: any;
+};
+/**
+ * Mark an object or array so that it is ignored by the reactivity system
+ *
+ * @param value the value to mark
+ * @returns the object itself
+ */
+declare function markRaw<T extends Target>(value: T): NonReactive<T>;
+/**
+ * Given a reactive objet, return the raw (non reactive) underlying object
+ *
+ * @param value a reactive value
+ * @returns the underlying value
+ */
+declare function toRaw<T extends object>(value: Reactive<T>): T;
+declare function getSubscriptions(callback: Callback): {
+    target: object;
+    keys: PropertyKey[];
+}[];
+/**
+ * Creates a reactive proxy for an object. Reading data on the reactive object
+ * subscribes to changes to the data. Writing data on the object will cause the
+ * notify callback to be called if there are suscriptions to that data. Nested
+ * objects and arrays are automatically made reactive as well.
+ *
+ * Whenever you are notified of a change, all subscriptions are cleared, and if
+ * you would like to be notified of any further changes, you should go read
+ * the underlying data again. We assume that if you don't go read it again after
+ * being notified, it means that you are no longer interested in that data.
+ *
+ * Subscriptions:
+ * + Reading a property on an object will subscribe you to changes in the value
+ *    of that property.
+ * + Accessing an object keys (eg with Object.keys or with `for..in`) will
+ *    subscribe you to the creation/deletion of keys. Checking the presence of a
+ *    key on the object with 'in' has the same effect.
+ * - getOwnPropertyDescriptor does not currently subscribe you to the property.
+ *    This is a choice that was made because changing a key's value will trigger
+ *    this trap and we do not want to subscribe by writes. This also means that
+ *    Object.hasOwnProperty doesn't subscribe as it goes through this trap.
+ *
+ * @param target the object for which to create a reactive proxy
+ * @param callback the function to call when an observed property of the
+ *  reactive has changed
+ * @returns a proxy that tracks changes to it
+ */
+declare function reactive<T extends Target>(target: T, callback?: Callback): Reactive<T> | NonReactive<T>;
+
+declare type BaseType = typeof String | typeof Boolean | typeof Number | typeof Date | typeof Object | typeof Array | true | "*";
+interface TypeInfo {
+    type?: TypeDescription;
+    optional?: boolean;
+    validate?: Function;
+    shape?: Schema;
+    element?: TypeDescription;
+}
+declare type ValueType = {
+    value: any;
+};
+declare type TypeDescription = BaseType | TypeInfo | ValueType | TypeDescription[];
+declare type SimplifiedSchema = string[];
+declare type NormalizedSchema = {
+    [key: string]: TypeDescription;
+};
+declare type Schema = SimplifiedSchema | NormalizedSchema;
+/**
+ * Main validate function
+ */
+declare function validate(obj: {
+    [key: string]: any;
+}, spec: Schema): void;
+
+declare class Fiber {
+    node: ComponentNode;
+    bdom: BDom | null;
+    root: RootFiber | null;
+    parent: Fiber | null;
+    children: Fiber[];
+    appliedToDom: boolean;
+    deep: boolean;
+    childrenMap: ComponentNode["children"];
+    constructor(node: ComponentNode, parent: Fiber | null);
+    render(): void;
+    _render(): void;
+}
+declare class RootFiber extends Fiber {
+    counter: number;
+    willPatch: Fiber[];
+    patched: Fiber[];
+    mounted: Fiber[];
+    locked: boolean;
+    complete(): void;
+    setCounter(newValue: number): void;
+}
+declare type Position = "first-child" | "last-child";
+interface MountOptions {
+    position?: Position;
+}
+declare class MountFiber extends RootFiber {
+    target: HTMLElement;
+    position: Position;
+    constructor(node: ComponentNode, target: HTMLElement, options?: MountOptions);
+    complete(): void;
+}
+
+declare const enum STATUS {
+    NEW = 0,
+    MOUNTED = 1,
+    DESTROYED = 2
+}
+declare type STATUS_DESCR = "new" | "mounted" | "destroyed";
+declare function status(component: Component): STATUS_DESCR;
+
+declare function useComponent(): Component;
+/**
+ * Creates a reactive object that will be observed by the current component.
+ * Reading data from the returned object (eg during rendering) will cause the
+ * component to subscribe to that data and be rerendered when it changes.
+ *
+ * @param state the state to observe
+ * @returns a reactive object that will cause the component to re-render on
+ *  relevant changes
+ * @see reactive
+ */
+declare function useState<T extends object>(state: T): Reactive<T> | NonReactive<T>;
+declare type LifecycleHook = Function;
+declare class ComponentNode<P extends Props = any, E = any> implements VNode<ComponentNode<P, E>> {
+    el?: HTMLElement | Text | undefined;
+    app: App;
+    fiber: Fiber | null;
+    component: Component<P, E>;
+    bdom: BDom | null;
+    status: STATUS;
+    forceNextRender: boolean;
+    parentKey: string | null;
+    props: P;
+    renderFn: Function;
+    parent: ComponentNode | null;
+    childEnv: Env;
+    children: {
+        [key: string]: ComponentNode;
+    };
+    refs: any;
+    willStart: LifecycleHook[];
+    willUpdateProps: LifecycleHook[];
+    willUnmount: LifecycleHook[];
+    mounted: LifecycleHook[];
+    willPatch: LifecycleHook[];
+    patched: LifecycleHook[];
+    willDestroy: LifecycleHook[];
+    constructor(C: ComponentConstructor<P, E>, props: P, 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>;
+    destroy(): void;
+    _destroy(): void;
+    updateAndRender(props: P, 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<P, E> | null, afterNode: Node | null): void;
+    patch(): void;
+    _patch(): void;
+    beforeRemove(): void;
+    remove(): void;
+    get name(): string;
+    get subscriptions(): ReturnType<typeof getSubscriptions>;
+}
+
+declare type Props = {
+    [key: string]: any;
+};
+interface StaticComponentProperties {
+    template: string;
+    defaultProps?: any;
+    props?: Schema;
+    components?: {
+        [componentName: string]: ComponentConstructor;
+    };
+}
+declare type ComponentConstructor<P extends Props = any, E = any> = (new (props: P, env: E, node: ComponentNode) => Component<P, E>) & StaticComponentProperties;
+declare class Component<Props = any, Env = any> {
+    static template: string;
+    static props?: any;
+    static defaultProps?: any;
+    props: Props;
+    env: Env;
+    __owl__: ComponentNode;
+    constructor(props: Props, env: Env, node: ComponentNode);
+    setup(): void;
+    render(deep?: boolean): void;
+}
+
+declare class Scheduler {
+    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+    tasks: Set<RootFiber>;
+    requestAnimationFrame: Window["requestAnimationFrame"];
+    frame: number;
+    delayedRenders: Fiber[];
+    constructor();
+    addFiber(fiber: Fiber): void;
+    /**
+     * Process all current tasks. This only applies to the fibers that are ready.
+     * Other tasks are left unchanged.
+     */
+    flush(): void;
+    processFiber(fiber: RootFiber): void;
+}
+
+interface Config {
+    translateFn?: (s: string) => string;
+    translatableAttributes?: string[];
+    dev?: boolean;
+}
+
+declare type Template = (context: any, vnode: any, key?: string) => BDom;
+declare type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
+interface CompileOptions extends Config {
+    name?: string;
+}
+declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
+
+declare class Portal extends Component {
+    static template: string;
+    static props: {
+        target: {
+            type: StringConstructor;
+        };
+        slots: boolean;
+    };
+    setup(): void;
+}
+
+interface TemplateSetConfig {
+    dev?: boolean;
+    translatableAttributes?: string[];
+    translateFn?: (s: string) => string;
+    templates?: string | Document;
+}
+declare class TemplateSet {
+    static registerTemplate(name: string, fn: TemplateFunction): void;
+    dev: boolean;
+    rawTemplates: typeof globalTemplates;
+    templates: {
+        [name: string]: Template;
+    };
+    translateFn?: (s: string) => string;
+    translatableAttributes?: string[];
+    Portal: typeof Portal;
+    constructor(config?: TemplateSetConfig);
+    addTemplate(name: string, template: string | Element): void;
+    addTemplates(xml: string | Document): void;
+    getTemplate(name: string): Template;
+    _compileTemplate(name: string, template: string | Element): ReturnType<typeof compile>;
+    callTemplate(owner: any, subTemplate: string, ctx: any, parent: any, key: any): any;
+}
+declare const globalTemplates: {
+    [key: string]: string | Element | TemplateFunction;
+};
+declare function xml(...args: Parameters<typeof String.raw>): string;
+declare namespace xml {
+    var nextId: number;
+}
+
+declare class OwlError extends Error {
+    cause?: any;
+}
+declare type ErrorParams = {
+    error: any;
+} & ({
+    node: ComponentNode;
+} | {
+    fiber: Fiber;
+});
+declare function handleError(params: ErrorParams): void;
+
+interface Env {
+    [key: string]: any;
+}
+interface AppConfig<P, E> extends TemplateSetConfig {
+    props?: P;
+    env?: E;
+    test?: boolean;
+    warnIfNoStaticProps?: boolean;
+}
+declare class App<T extends abstract new (...args: any) => any = any, P extends object = any, E = any> extends TemplateSet {
+    static validateTarget: typeof validateTarget;
+    Root: ComponentConstructor<P, E>;
+    props: P;
+    env: E;
+    scheduler: Scheduler;
+    root: ComponentNode<P, E> | null;
+    warnIfNoStaticProps: boolean;
+    constructor(Root: ComponentConstructor<P, E>, config?: AppConfig<P, E>);
+    mount(target: HTMLElement, options?: MountOptions): Promise<Component<P, E> & InstanceType<T>>;
+    makeNode(Component: ComponentConstructor, props: any): ComponentNode;
+    mountNode(node: ComponentNode, target: HTMLElement, options?: MountOptions): any;
+    destroy(): void;
+    createComponent<P extends Props>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, hasNoProp: boolean): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
+    handleError(...args: Parameters<typeof handleError>): void;
+}
+declare function mount<T extends abstract new (...args: any) => any = any, P extends object = any, E = any>(C: T & ComponentConstructor<P, E>, target: HTMLElement, config?: AppConfig<P, E> & MountOptions): Promise<Component<P, E> & InstanceType<T>>;
+
+/**
+ * The purpose of this hook is to allow components to get a reference to a sub
+ * html node or component.
+ */
+declare function useRef<T extends HTMLElement = HTMLElement>(name: string): {
+    el: T | null;
+};
+/**
+ * This hook is useful as a building block for some customized hooks, that may
+ * need a reference to the env of the component calling them.
+ */
+declare function useEnv<E extends Env>(): E;
+/**
+ * This hook is a simple way to let components use a sub environment.  Note that
+ * like for all hooks, it is important that this is only called in the
+ * constructor method.
+ */
+declare function useSubEnv(envExtension: Env): void;
+declare function useChildSubEnv(envExtension: Env): void;
+/**
+ * @param {...any} dependencies the dependencies computed by computeDependencies
+ * @returns {void|(()=>void)} a cleanup function that reverses the side
+ *      effects of the effect callback.
+ */
+declare type Effect = (...dependencies: any[]) => void | (() => void);
+/**
+ * This hook will run a callback when a component is mounted and patched, and
+ * will run a cleanup function before patching and before unmounting the
+ * the component.
+ *
+ * @param {Effect} effect the effect to run on component mount and/or patch
+ * @param {()=>any[]} [computeDependencies=()=>[NaN]] a callback to compute
+ *      dependencies that will decide if the effect needs to be cleaned up and
+ *      run again. If the dependencies did not change, the effect will not run
+ *      again. The default value returns an array containing only NaN because
+ *      NaN !== NaN, which will cause the effect to rerun on every patch.
+ */
+declare function useEffect(effect: Effect, computeDependencies?: () => any[]): void;
+/**
+ * When a component needs to listen to DOM Events on element(s) that are not
+ * part of his hierarchy, we can use the `useExternalListener` hook.
+ * It will correctly add and remove the event listener, whenever the
+ * component is mounted and unmounted.
+ *
+ * Example:
+ *  a menu needs to listen to the click on window to be closed automatically
+ *
+ * Usage:
+ *  in the constructor of the OWL component that needs to be notified,
+ *  `useExternalListener(window, 'click', this._doSomething);`
+ * */
+declare function useExternalListener(target: HTMLElement | typeof window, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
+
+declare function onWillStart(fn: () => Promise<void> | void | any): void;
+declare function onWillUpdateProps(fn: (nextProps: any) => Promise<void> | void | any): void;
+declare function onMounted(fn: () => void | any): void;
+declare function onWillPatch(fn: () => Promise<void> | any | void): void;
+declare function onPatched(fn: () => void | any): void;
+declare function onWillUnmount(fn: () => Promise<void> | void | any): void;
+declare function onWillDestroy(fn: () => Promise<void> | void | any): void;
+declare function onWillRender(fn: () => void | any): void;
+declare function onRendered(fn: () => void | any): void;
+declare type OnErrorCallback = (error: any) => void | any;
+declare function onError(callback: OnErrorCallback): void;
+
+declare const blockDom: {
+    config: {
+        shouldNormalizeDom: boolean;
+        mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null | undefined) => boolean;
+    };
+    mount: typeof mount$1;
+    patch: typeof patch;
+    remove: typeof remove;
+    list: typeof list;
+    multi: typeof multi;
+    text: typeof text;
+    toggler: typeof toggler;
+    createBlock: typeof createBlock;
+    html: typeof html;
+    comment: typeof comment;
+};
+
+declare const __info__: {};
+
+export { App, Component, ComponentConstructor, EventBus, OwlError, Reactive, __info__, blockDom, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, useRef, useState, useSubEnv, validate, whenReady, xml };

package/dist/types/{app → runtime}/app.d.ts

@@ -1,9 +1,10 @@
-import { Component, ComponentConstructor } from "../component/component";
-import { ComponentNode } from "../component/component_node";
-import { MountOptions } from "../component/fibers";
-import { Scheduler } from "../component/scheduler";
+import { Component, ComponentConstructor, Props } from "./component";
+import { ComponentNode } from "./component_node";
+import { MountOptions } from "./fibers";
+import { Scheduler } from "./scheduler";
 import { TemplateSet, TemplateSetConfig } from "./template_set";
-import { validateTarget } from "../utils";
+import { validateTarget } from "./utils";
+import { handleError } from "./error_handling";
 export interface Env {
     [key: string]: any;
 }
@@ -11,6 +12,7 @@ export interface AppConfig<P, E> extends TemplateSetConfig {
     props?: P;
     env?: E;
     test?: boolean;
+    warnIfNoStaticProps?: boolean;
 }
 export declare const DEV_MSG: () => string;
 export declare class App<T extends abstract new (...args: any) => any = any, P extends object = any, E = any> extends TemplateSet {
@@ -20,10 +22,13 @@ export declare class App<T extends abstract new (...args: any) => any = any, P e
     env: E;
     scheduler: Scheduler;
     root: ComponentNode<P, E> | null;
+    warnIfNoStaticProps: boolean;
     constructor(Root: ComponentConstructor<P, E>, config?: AppConfig<P, E>);
     mount(target: HTMLElement, options?: MountOptions): Promise<Component<P, E> & InstanceType<T>>;
     makeNode(Component: ComponentConstructor, props: any): ComponentNode;
     mountNode(node: ComponentNode, target: HTMLElement, options?: MountOptions): any;
     destroy(): void;
+    createComponent<P extends Props>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, hasNoProp: boolean): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
+    handleError(...args: Parameters<typeof handleError>): void;
 }
 export declare function mount<T extends abstract new (...args: any) => any = any, P extends object = any, E = any>(C: T & ComponentConstructor<P, E>, target: HTMLElement, config?: AppConfig<P, E> & MountOptions): Promise<Component<P, E> & InstanceType<T>>;

package/dist/types/{blockdom → runtime/blockdom}/html.d.ts

@@ -5,7 +5,8 @@ declare class VHtml {
     content: ChildNode[];
     constructor(html: string);
     mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBefore(other: VHtml | null, 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;

package/dist/types/{blockdom → runtime/blockdom}/index.d.ts

@@ -8,7 +8,8 @@ export { html } from "./html";
 export { createCatcher } from "./event_catcher";
 export interface VNode<T = any> {
     mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBefore(other: T | null, 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;

package/dist/types/{blockdom → runtime/blockdom}/list.d.ts

@@ -6,7 +6,8 @@ declare class VList {
     isOnlyChild?: boolean | undefined;
     constructor(children: VNode[]);
     mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBefore(other: VList | null, 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;

package/dist/types/{blockdom → runtime/blockdom}/multi.d.ts

@@ -6,7 +6,8 @@ export declare class VMulti {
     isOnlyChild?: boolean | undefined;
     constructor(children: (VNode | undefined)[]);
     mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBefore(other: VMulti | null, 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;

package/dist/types/{blockdom → runtime/blockdom}/text.d.ts

@@ -5,7 +5,8 @@ declare abstract class VSimpleNode {
     el?: any;
     constructor(text: string | String);
     mountNode(node: Node, parent: HTMLElement, afterNode: Node | null): void;
-    moveBefore(other: VText | null, 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;

package/dist/types/{blockdom → runtime/blockdom}/toggler.d.ts

@@ -5,7 +5,8 @@ declare class VToggler {
     parentEl?: HTMLElement | undefined;
     constructor(key: string, child: VNode);
     mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBefore(other: VToggler | null, 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;

package/dist/types/{component → runtime}/component.d.ts

@@ -1,11 +1,15 @@
+import { Schema } from "./validation";
 import type { ComponentNode } from "./component_node";
-declare type Props = {
+export declare type Props = {
     [key: string]: any;
 };
 interface StaticComponentProperties {
     template: string;
     defaultProps?: any;
-    props?: any;
+    props?: Schema;
+    components?: {
+        [componentName: string]: ComponentConstructor;
+    };
 }
 export declare type ComponentConstructor<P extends Props = any, E = any> = (new (props: P, env: E, node: ComponentNode) => Component<P, E>) & StaticComponentProperties;
 export declare class Component<Props = any, Env = any> {