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

package/dist/types/owl.d.ts

@@ -166,32 +166,6 @@ declare class Registry<T> {
     has(key: string): boolean;
 }
 
-interface ReactiveValue<TRead, TWrite = TRead> {
-    (): TRead;
-    /**
-     * Update the value of the reactive with a new value. If the new value is different
-     * from the previous values, all computations that depends on this reactive will
-     * be invalidated, and effects will rerun.
-     */
-    set(nextValue: TWrite): void;
-}
-declare enum ComputationState {
-    EXECUTED = 0,
-    STALE = 1,
-    PENDING = 2
-}
-interface Atom<T = any> {
-    observers: Set<ComputationAtom>;
-    value: T;
-}
-interface ComputationAtom<T = any> extends Atom<T> {
-    compute: () => T;
-    isDerived: boolean;
-    sources: Set<Atom>;
-    state: ComputationState;
-}
-declare function untrack<T>(fn: (...args: any[]) => T): T;
-
 declare const enum STATUS {
     NEW = 0,
     MOUNTED = 1,// is ready, and in DOM. It has a valid el
@@ -215,7 +189,6 @@ declare class Plugin {
 }
 interface PluginManagerOptions {
     parent?: PluginManager | null;
-    plugins?: ReactiveValue<PluginConstructor[]>;
     config?: Record<string, any>;
 }
 declare class PluginManager {
@@ -232,6 +205,32 @@ declare class PluginManager {
     startPlugins(pluginConstructors: PluginConstructor[]): void;
 }
 
+interface ReactiveValue<TRead, TWrite = TRead> {
+    (): TRead;
+    /**
+     * Update the value of the reactive with a new value. If the new value is different
+     * from the previous values, all computations that depends on this reactive will
+     * be invalidated, and effects will rerun.
+     */
+    set(nextValue: TWrite): void;
+}
+declare enum ComputationState {
+    EXECUTED = 0,
+    STALE = 1,
+    PENDING = 2
+}
+interface Atom<T = any> {
+    observers: Set<ComputationAtom>;
+    value: T;
+}
+interface ComputationAtom<T = any> extends Atom<T> {
+    compute: () => T;
+    isDerived: boolean;
+    sources: Set<Atom>;
+    state: ComputationState;
+}
+declare function untrack<T>(fn: (...args: any[]) => T): T;
+
 declare class Fiber {
     node: ComponentNode;
     bdom: BDom | null;
@@ -331,8 +330,8 @@ declare class Component {
     setup(): void;
 }
 
-type Constructor = {
-    new (...args: any[]): any;
+type Constructor<T = any> = {
+    new (...args: any[]): T;
 };
 type GetOptionalEntries<T> = {
     [K in keyof T as K extends `${infer P}?` ? P : never]?: T[K];
@@ -361,6 +360,7 @@ declare function instanceType<T extends Constructor>(constructor: T): InstanceTy
 declare function intersection<T extends any[]>(types: T): UnionToIntersection<T[number]>;
 type LiteralTypes = number | string | boolean | null | undefined;
 declare function literalType<const T extends LiteralTypes>(literal: T): T;
+declare function literalSelection<const T extends LiteralTypes>(literals: T[]): T;
 declare function objectType(): Record<string, any>;
 declare function objectType<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
 declare function objectType<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
@@ -372,7 +372,10 @@ declare function tuple<const T extends any[]>(types: T): T;
 declare function union<T extends any[]>(types: T): T[number];
 declare function reactiveValueType(): ReactiveValue<any>;
 declare function reactiveValueType<T>(type: T): ReactiveValue<T>;
+declare function ref(): HTMLElement | null;
+declare function ref<T extends Constructor<HTMLElement>>(type: T): InstanceType<T> | null;
 declare const types: {
+    and: typeof intersection;
     any: any;
     array: typeof arrayType;
     boolean: boolean;
@@ -383,13 +386,14 @@ declare const types: {
     literal: typeof literalType;
     number: number;
     object: typeof objectType;
+    or: typeof union;
     promise: typeof promiseType;
-    signal: typeof reactiveValueType;
     record: typeof recordType;
+    ref: typeof ref;
+    selection: typeof literalSelection;
+    signal: typeof reactiveValueType;
     string: string;
     tuple: typeof tuple;
-    and: typeof intersection;
-    or: typeof union;
 };
 
 declare const isProps: unique symbol;
@@ -486,29 +490,9 @@ declare class Scheduler {
     processFiber(fiber: RootFiber): void;
 }
 
-interface Config {
-    translateFn?: (s: string, translationCtx: string) => string;
-    translatableAttributes?: string[];
-    dev?: boolean;
-}
-
 type CustomDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
 type Template = (context: any, vnode: any, key?: string) => BDom;
 type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
-interface CompileOptions extends Config {
-    name?: string;
-    customDirectives?: CustomDirectives;
-    hasGlobalValues: boolean;
-}
-declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
-
-declare class Portal extends Component {
-    static template: string;
-    props: Props<{
-        target: string;
-    }>;
-    setup(): void;
-}
 
 interface TemplateSetConfig {
     dev?: boolean;
@@ -529,7 +513,6 @@ declare class TemplateSet {
     getRawTemplate?: (s: string) => Element | Function | string | void;
     translateFn?: (s: string, translationCtx: string) => string;
     translatableAttributes?: string[];
-    Portal: typeof Portal;
     customDirectives: CustomDirectives;
     runtimeUtils: object;
     hasGlobalValues: boolean;
@@ -537,8 +520,7 @@ declare class TemplateSet {
     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;
+    private _compileTemplate;
 }
 declare const globalTemplates: {
     [key: string]: string | Element | TemplateFunction;
@@ -548,7 +530,7 @@ declare namespace xml {
     var nextId: number;
 }
 
-type Callback = () => void;
+type Callback = (...args: any[]) => void;
 /**
  * Creates a batched version of a callback so that all calls to it in the same
  * microtick will only call the original callback once.
@@ -606,10 +588,8 @@ declare class App extends TemplateSet {
     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;
+    private mountNode;
     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;
 }
 declare function mount<T extends ComponentConstructor>(C: T, target: MountTarget, config?: AppConfig & RootConfig<GetProps<ComponentInstance<T>>> & MountOptions): Promise<ComponentInstance<T>>;
@@ -625,19 +605,24 @@ interface Signal<T> extends ReactiveValue<T> {
 interface SignalOptions<T> {
     type?: T;
 }
-declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
-declare namespace signal {
-    var invalidate: (signal: Signal<any>) => void;
-    var Array: <T>(initialValue: T[], options?: SignalOptions<T>) => Signal<T[]>;
-    var Object: <T extends object>(initialValue: T, options?: SignalOptions<T>) => Signal<T>;
-    var Map: <K, V>(initialValue: Map<K, V>, options?: MapSignalOptions<K, V>) => Signal<Map<K, V>>;
-    var Set: <T>(initialValue: Set<T>, options?: SignalOptions<T>) => Signal<Set<T>>;
-}
+declare function invalidateSignal(signal: Signal<any>): void;
+declare function signalArray<T>(initialValue: T[], options?: SignalOptions<T>): Signal<T[]>;
+declare function signalObject<T extends Record<PropertyKey, any>>(initialValue: T, options?: SignalOptions<T>): Signal<T>;
 interface MapSignalOptions<K, V> {
     name?: string;
     keyType?: K;
     valueType?: V;
 }
+declare function signalMap<K, V>(initialValue: Map<K, V>, options?: MapSignalOptions<K, V>): Signal<Map<K, V>>;
+declare function signalSet<T>(initialValue: Set<T>, options?: SignalOptions<T>): Signal<Set<T>>;
+declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
+declare namespace signal {
+    var invalidate: typeof invalidateSignal;
+    var Array: typeof signalArray;
+    var Map: typeof signalMap;
+    var Object: typeof signalObject;
+    var Set: typeof signalSet;
+}
 
 interface ComputedOptions<TWrite> {
     set?(value: TWrite): void;
@@ -702,7 +687,7 @@ declare class OwlError extends Error {
 type PluginInstance<T extends PluginConstructor> = Omit<InstanceType<T>, "setup">;
 declare function plugin<T extends PluginConstructor>(pluginType: T): PluginInstance<T>;
 declare function config<T = any>(name: string, type?: T): T;
-declare function providePlugins<const P extends PluginConstructor[]>(pluginConstructors: P, config?: Record<string, any>): void;
+declare function providePlugins(pluginConstructors: PluginConstructor[] | Resource<PluginConstructor>, config?: Record<string, any>): void;
 
 interface CapturedContext {
     run<T = void>(callback: () => T): T;

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

@@ -47,10 +47,8 @@ export declare class App extends TemplateSet {
     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;
+    private mountNode;
     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>>;

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

@@ -23,4 +23,3 @@ 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/index.d.ts

@@ -25,8 +25,8 @@ export { props } from "./props";
 export type { GetProps } from "./props";
 export { status } from "./status";
 export { proxy, markRaw, toRaw } from "./reactivity/proxy";
-export { untrack, ReactiveValue } from "./reactivity/computations";
-export { signal, Signal } from "./reactivity/signal";
+export { untrack, type ReactiveValue } from "./reactivity/computations";
+export { signal, type Signal } from "./reactivity/signal";
 export { computed } from "./reactivity/computed";
 export { effect } from "./reactivity/effect";
 export { useEffect, useListener, useApp } from "./hooks";

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

@@ -1,5 +1,6 @@
 import { PluginConstructor } from "./plugin_manager";
+import { Resource } from "./resource";
 export type PluginInstance<T extends PluginConstructor> = Omit<InstanceType<T>, "setup">;
 export declare function plugin<T extends PluginConstructor>(pluginType: T): PluginInstance<T>;
 export declare function config<T = any>(name: string, type?: T): T;
-export declare function providePlugins<const P extends PluginConstructor[]>(pluginConstructors: P, config?: Record<string, any>): void;
+export declare function providePlugins(pluginConstructors: PluginConstructor[] | Resource<PluginConstructor>, config?: Record<string, any>): void;

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

@@ -1,5 +1,5 @@
 import { App } from "./app";
-import { ReactiveValue } from "./reactivity/computations";
+import { Resource } from "./resource";
 import { STATUS } from "./status";
 export interface PluginConstructor {
     new (...args: any[]): Plugin;
@@ -15,7 +15,6 @@ export declare class Plugin {
 }
 interface PluginManagerOptions {
     parent?: PluginManager | null;
-    plugins?: ReactiveValue<PluginConstructor[]>;
     config?: Record<string, any>;
 }
 export declare class PluginManager {
@@ -31,4 +30,5 @@ export declare class PluginManager {
     startPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
     startPlugins(pluginConstructors: PluginConstructor[]): void;
 }
+export declare function startPlugins(manager: PluginManager, plugins: PluginConstructor[] | Resource<PluginConstructor>): void;
 export {};

package/dist/types/runtime/reactivity/async_computed.d.ts

@@ -0,0 +1 @@
+export declare function asyncComputed<T>(fn: () => Promise<T>): () => Promise<T>;

package/dist/types/runtime/reactivity/computations.d.ts

@@ -23,7 +23,7 @@ export interface ComputationAtom<T = any> extends Atom<T> {
     state: ComputationState;
 }
 export declare const atomSymbol: unique symbol;
-export declare function createComputation(options?: Partial<ComputationAtom>): ComputationAtom;
+export declare function createComputation(compute: () => any, isDerived: boolean, state?: ComputationState): ComputationAtom;
 export declare function onReadAtom(atom: Atom): void;
 export declare function onWriteAtom(atom: Atom): void;
 export declare function getCurrentComputation(): ComputationAtom<any> | undefined;

package/dist/types/runtime/reactivity/proxy.d.ts

@@ -15,7 +15,6 @@ export declare function markRaw<T extends Target>(value: T): T;
  * @returns the underlying value
  */
 export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
-export declare const targets: WeakMap<object, object>;
 export declare function proxifyTarget<T extends Target>(target: T, atom: Atom | null): T;
 /**
  * Creates a reactive proxy for an object. Reading data on the proxy object

package/dist/types/runtime/reactivity/signal.d.ts

@@ -10,17 +10,22 @@ export interface Signal<T> extends ReactiveValue<T> {
 interface SignalOptions<T> {
     type?: T;
 }
-export declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
-export declare namespace signal {
-    var invalidate: (signal: Signal<any>) => void;
-    var Array: <T>(initialValue: T[], options?: SignalOptions<T>) => Signal<T[]>;
-    var Object: <T extends object>(initialValue: T, options?: SignalOptions<T>) => Signal<T>;
-    var Map: <K, V>(initialValue: Map<K, V>, options?: MapSignalOptions<K, V>) => Signal<Map<K, V>>;
-    var Set: <T>(initialValue: Set<T>, options?: SignalOptions<T>) => Signal<Set<T>>;
-}
+declare function invalidateSignal(signal: Signal<any>): void;
+declare function signalArray<T>(initialValue: T[], options?: SignalOptions<T>): Signal<T[]>;
+declare function signalObject<T extends Record<PropertyKey, any>>(initialValue: T, options?: SignalOptions<T>): Signal<T>;
 interface MapSignalOptions<K, V> {
     name?: string;
     keyType?: K;
     valueType?: V;
 }
+declare function signalMap<K, V>(initialValue: Map<K, V>, options?: MapSignalOptions<K, V>): Signal<Map<K, V>>;
+declare function signalSet<T>(initialValue: Set<T>, options?: SignalOptions<T>): Signal<Set<T>>;
+export declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
+export declare namespace signal {
+    var invalidate: typeof invalidateSignal;
+    var Array: typeof signalArray;
+    var Map: typeof signalMap;
+    var Object: typeof signalObject;
+    var Set: typeof signalSet;
+}
 export {};

package/dist/types/runtime/rendering/template_helpers.d.ts

@@ -1,18 +1,17 @@
-import { BDom, toggler, createCatcher } from "../blockdom";
-import { markRaw } from "../reactivity/proxy";
 import { OwlError } from "../../common/owl_error";
+import { App } from "../app";
+import { BDom, createCatcher, toggler } from "../blockdom";
+import { ComponentNode } from "../component_node";
+import { Portal } from "../portal";
+import { markRaw } from "../reactivity/proxy";
 /**
  * This file contains utility functions that will be injected in each template,
  * to perform various useful tasks in the compiled code.
  */
 declare function withDefault(value: any, defaultValue: any): any;
 declare function callSlot(ctx: any, parent: any, key: string, name: string, dynamic: boolean, extra: any, defaultContent?: (ctx: any, node: any, key: string) => BDom): BDom;
-declare function capture(ctx: any): any;
 declare function withKey(elem: any, k: string): any;
 declare function prepareList(collection: unknown): [unknown[], unknown[], number, undefined[]];
-declare function setContextValue(ctx: {
-    [key: string]: any;
-}, key: string, value: any): void;
 declare function toNumber(val: string): number | string;
 declare function shallowEqual(l1: any[], l2: any[]): boolean;
 declare class LazyValue {
@@ -28,15 +27,14 @@ declare class LazyValue {
 export declare function safeOutput(value: any, defaultValue?: any): ReturnType<typeof toggler>;
 declare function createRef(ref: any): (el: HTMLElement | null, previousEl: HTMLElement | null) => void;
 declare function modelExpr(value: any): any;
+declare function createComponent<P extends Record<string, any>>(app: App, name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
+declare function callTemplate(subTemplate: string, owner: any, app: App, ctx: any, parent: any, key: any): any;
 export declare const helpers: {
     withDefault: typeof withDefault;
     zero: symbol;
-    isBoundary: symbol;
     callSlot: typeof callSlot;
-    capture: typeof capture;
     withKey: typeof withKey;
     prepareList: typeof prepareList;
-    setContextValue: typeof setContextValue;
     shallowEqual: typeof shallowEqual;
     toNumber: typeof toNumber;
     LazyValue: typeof LazyValue;
@@ -46,5 +44,8 @@ export declare const helpers: {
     OwlError: typeof OwlError;
     createRef: typeof createRef;
     modelExpr: typeof modelExpr;
+    createComponent: typeof createComponent;
+    Portal: typeof Portal;
+    callTemplate: typeof callTemplate;
 };
 export {};

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

@@ -0,0 +1,5 @@
+import { Component } from "./component";
+export declare function suspenseTemplate(app: any, bdom: any, helpers: any): (ctx: any, node: any, key?: string) => any;
+export declare class Suspense extends Component {
+    static template: string;
+}

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

@@ -1,5 +1,4 @@
-import { compile, CustomDirectives, Template, TemplateFunction } from "../compiler";
-import { Portal } from "./portal";
+import { CustomDirectives, Template, TemplateFunction } from "../compiler";
 export interface TemplateSetConfig {
     dev?: boolean;
     translatableAttributes?: string[];
@@ -19,7 +18,6 @@ export declare class TemplateSet {
     getRawTemplate?: (s: string) => Element | Function | string | void;
     translateFn?: (s: string, translationCtx: string) => string;
     translatableAttributes?: string[];
-    Portal: typeof Portal;
     customDirectives: CustomDirectives;
     runtimeUtils: object;
     hasGlobalValues: boolean;
@@ -27,8 +25,7 @@ export declare class TemplateSet {
     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;
+    private _compileTemplate;
 }
 export declare const globalTemplates: {
     [key: string]: string | Element | TemplateFunction;

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

@@ -1,6 +1,6 @@
 import { ReactiveValue } from "./reactivity/computations";
-type Constructor = {
-    new (...args: any[]): any;
+type Constructor<T = any> = {
+    new (...args: any[]): T;
 };
 export type GetOptionalEntries<T> = {
     [K in keyof T as K extends `${infer P}?` ? P : never]?: T[K];
@@ -29,6 +29,7 @@ declare function instanceType<T extends Constructor>(constructor: T): InstanceTy
 declare function intersection<T extends any[]>(types: T): UnionToIntersection<T[number]>;
 type LiteralTypes = number | string | boolean | null | undefined;
 declare function literalType<const T extends LiteralTypes>(literal: T): T;
+declare function literalSelection<const T extends LiteralTypes>(literals: T[]): T;
 declare function objectType(): Record<string, any>;
 declare function objectType<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
 declare function objectType<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
@@ -40,7 +41,10 @@ declare function tuple<const T extends any[]>(types: T): T;
 declare function union<T extends any[]>(types: T): T[number];
 declare function reactiveValueType(): ReactiveValue<any>;
 declare function reactiveValueType<T>(type: T): ReactiveValue<T>;
+declare function ref(): HTMLElement | null;
+declare function ref<T extends Constructor<HTMLElement>>(type: T): InstanceType<T> | null;
 export declare const types: {
+    and: typeof intersection;
     any: any;
     array: typeof arrayType;
     boolean: boolean;
@@ -51,12 +55,13 @@ export declare const types: {
     literal: typeof literalType;
     number: number;
     object: typeof objectType;
+    or: typeof union;
     promise: typeof promiseType;
-    signal: typeof reactiveValueType;
     record: typeof recordType;
+    ref: typeof ref;
+    selection: typeof literalSelection;
+    signal: typeof reactiveValueType;
     string: string;
     tuple: typeof tuple;
-    and: typeof intersection;
-    or: typeof union;
 };
 export {};

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

@@ -1,4 +1,4 @@
-export type Callback = () => void;
+export type Callback = (...args: any[]) => void;
 /**
  * Creates a batched version of a callback so that all calls to it in the same
  * microtick will only call the original callback once.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "3.0.0-alpha.19",
+  "version": "3.0.0-alpha.20",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "module": "dist/owl.es.js",