@odoo/owl 3.0.0-alpha.2 → 3.0.0-alpha.20

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

@@ -1,62 +1,55 @@
-import { Component, ComponentConstructor, Props } from "./component";
-import { ComponentNode } from "./component_node";
-import { handleError } from "./error_handling";
-import { Fiber, RootFiber, MountOptions } from "./fibers";
-import { Scheduler } from "./scheduler";
-import { TemplateSet, TemplateSetConfig } from "./template_set";
-import { validateTarget } from "./utils";
-import { toRaw, reactive } from "./reactivity";
-import { PluginCtor, PluginManager } from "./plugins";
-export interface Env {
-    [key: string]: any;
-}
-export interface RootConfig<P, E> {
-    props?: P;
-    env?: E;
-    Plugins?: PluginCtor[];
-}
-export interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
-    name?: string;
-    test?: boolean;
-    warnIfNoStaticProps?: boolean;
-}
-declare global {
-    interface Window {
-        __OWL_DEVTOOLS__: {
-            apps: Set<App>;
-            Fiber: typeof Fiber;
-            RootFiber: typeof RootFiber;
-            toRaw: typeof toRaw;
-            reactive: typeof reactive;
-        };
-    }
-}
-interface Root<P extends Props, E> {
-    node: ComponentNode<P, E>;
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E>>;
-    destroy(): void;
-}
-export declare class App<T extends abstract new (...args: any) => any = any, P extends object = any, E = any> extends TemplateSet {
-    static validateTarget: typeof validateTarget;
-    static apps: Set<App<any, any, any>>;
-    static version: string;
-    name: string;
-    Root: ComponentConstructor<P, E>;
-    props: P;
-    env: E;
-    scheduler: Scheduler;
-    subRoots: Set<ComponentNode>;
-    root: ComponentNode<P, E> | null;
-    warnIfNoStaticProps: boolean;
-    pluginManager: PluginManager;
-    constructor(Root: ComponentConstructor<P, E>, config?: AppConfig<P, E>);
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E> & InstanceType<T>>;
-    createRoot<Props extends object, SubEnv = any>(Root: ComponentConstructor<Props, E>, config?: RootConfig<Props, SubEnv>): Root<Props, SubEnv>;
-    makeNode(Component: ComponentConstructor, props: any): ComponentNode;
-    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, options?: MountOptions): any;
-    destroy(): void;
-    createComponent<P extends Props>(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 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>>;
-export {};
+import { ComponentConstructor } from "./component";
+import { ComponentNode } from "./component_node";
+import { PluginConstructor, PluginManager } from "./plugin_manager";
+import { GetProps } from "./props";
+import { proxy, toRaw } from "./reactivity/proxy";
+import { handleError } from "./rendering/error_handling";
+import { Fiber, MountOptions, RootFiber } from "./rendering/fibers";
+import { Scheduler } from "./rendering/scheduler";
+import { Resource } from "./resource";
+import { TemplateSet, TemplateSetConfig } from "./template_set";
+import { validateTarget } from "./utils";
+type ComponentInstance<C extends ComponentConstructor> = C extends new (...args: any) => infer T ? T : never;
+interface RootConfig<P> {
+    props?: P;
+}
+export interface AppConfig extends TemplateSetConfig {
+    name?: string;
+    plugins?: PluginConstructor[] | Resource<PluginConstructor>;
+    config?: Record<string, any>;
+    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>;
+    private mountNode;
+    destroy(): void;
+    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";
-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
- */
-export declare function createBlock(str: string): BlockType;
-export declare type Setter<T = any> = (this: T, value: any) => void;
-export declare 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 | undefined) => 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";
-declare type EventsSpec = {
-    [name: string]: number;
-};
-declare 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 @@
-declare 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,25 @@
-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 declare 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;

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,28 +1,17 @@
-import { Schema } from "./validation";
-import type { ComponentNode } from "./component_node";
-import type { PluginManager } from "./plugins";
-export declare type Props = {
-    [key: string]: any;
-};
-interface StaticComponentProperties {
-    template: string;
-    defaultProps?: any;
-    props?: Schema;
-    components?: {
-        [componentName: string]: ComponentConstructor;
-    };
-}
-export declare type ComponentConstructor<P extends Props = any, Plugins = any, E = any> = (new (props: P, env: E, plugins: Plugins, node: ComponentNode) => Component<P, Plugins, E>) & StaticComponentProperties;
-export declare class Component<Props = any, Plugins = PluginManager["plugins"], Env = any> {
-    static template: string;
-    static props?: Schema;
-    static defaultProps?: any;
-    props: Props;
-    env: Env;
-    plugins: Plugins;
-    __owl__: ComponentNode;
-    constructor(props: Props, env: Env, plugins: Plugins, 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;
+}
+export {};