@odoo/owl 3.0.0-alpha.32 → 3.0.0-alpha.34

package/dist/types/owl.d.ts

@@ -142,6 +142,54 @@ export interface ComputationAtom<T = any> extends Atom<T> {
 	state: ComputationState;
 }
 export declare function untrack<T>(fn: (...args: any[]) => T): T;
+export interface ResourceOptions<T> {
+	name?: string;
+	validation?: T;
+}
+export interface ResourceAddOptions {
+	sequence?: number;
+}
+export declare class Resource<T> {
+	private _items;
+	private _name?;
+	private _validation?;
+	constructor(options?: ResourceOptions<T>);
+	items: ReactiveValue<T[], T[]>;
+	add(item: T, options?: ResourceAddOptions): Resource<T>;
+	delete(item: T): Resource<T>;
+	has(item: T): boolean;
+	use(item: T, options?: ResourceAddOptions): Resource<T>;
+}
+export interface PluginConstructor {
+	new (...args: any[]): Plugin$1;
+	id: string;
+	sequence: number;
+}
+declare class Plugin$1 {
+	private static _shadowId;
+	static get id(): string;
+	static set id(shadowId: string);
+	static sequence: number;
+	__owl__: PluginManager;
+	constructor(manager: PluginManager);
+	setup(): void;
+}
+export interface PluginManagerOptions {
+	parent?: PluginManager | null;
+	config?: Record<string, any>;
+}
+declare class PluginManager extends Scope {
+	config: Record<string, any>;
+	plugins: Record<string, Plugin$1>;
+	ready: Promise<void>;
+	private hasPendingReady;
+	constructor(app: any, options?: PluginManagerOptions);
+	destroy(): void;
+	getPluginById<T extends Plugin$1>(id: string): T | null;
+	getPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
+	startPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
+	startPlugins(pluginConstructors: PluginConstructor[]): void;
+}
 /**
  * Returns the active scope. Throws if no scope is active — use this inside
  * hooks and setup functions where the caller is expected to be in a scope.
@@ -149,6 +197,7 @@ export declare function untrack<T>(fn: (...args: any[]) => T): T;
 export declare function useScope(): Scope;
 export declare abstract class Scope {
 	app: any;
+	pluginManager: PluginManager;
 	status: StatusValue;
 	computations: ComputationAtom[];
 	willStart: Array<() => any>;
@@ -226,31 +275,24 @@ export declare function markRaw<T extends Target>(value: T): T;
  */
 export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
 /**
- * Creates a reactive proxy for an object. Reading data on the proxy 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.
+ * Wraps an object so it behaves like a signal, but with the familiar
+ * property-access API: instead of `count()` / `count.set(n)`, you write
+ * `state.count` and `state.count = n`. Reading and writing the proxy
+ * transparently looks and feels like reading and writing the original object.
  *
- * 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.
+ * Reactivity is nested: reading a property that holds another object/array
+ * returns a proxy for that value too, recursively. Arrays, Maps, Sets, and
+ * WeakMaps are also wrapped, so `state.items.push(x)` or `state.map.set(k, v)`
+ * notify subscribers the same way property writes do.
  *
- * Subscriptions:
- * + Reading a property on an object will subscribe you to changes in the value
- *    of that property.
- * + Accessing an object's 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.
+ * Subscriptions are only created when a read happens *while a computation is
+ * active* — i.e. inside a component's render, or inside an `effect`,
+ * `computed`, or `asyncComputed`. Reading the proxy from a plain function
+ * with no surrounding computation just returns the value without subscribing
+ * anything.
  *
- * @param target the object for which to create a proxy proxy
- * @param callback the function to call when an observed property of the
- *  proxy has changed
- * @returns a proxy that tracks changes to it
+ * @param target the object to make reactive
+ * @returns a proxy that tracks reads/writes against `target`
  */
 export declare function proxy<T extends Target>(target: T): T;
 export interface Signal<T> extends ReactiveValue<T> {
@@ -311,7 +353,7 @@ export interface AsyncComputed<T> {
 export declare function asyncComputed<T>(fetcher: (ctx: AsyncComputedContext) => Promise<T>, options?: AsyncComputedOptions<T>): AsyncComputed<T>;
 export interface ValidationIssue {
 	message: string;
-	path?: PropertyKey[];
+	path?: string;
 	received?: any;
 	[K: string]: any;
 }
@@ -338,24 +380,6 @@ export type ResolveObjectType<T extends {}> = ResolveShapedObject<T extends stri
 export type UnionToIntersection<U> = (U extends any ? (_: U) => any : never) extends (_: infer I) => void ? I : never;
 declare function constructorType<T extends Constructor>(constructor: T): T;
 export type LiteralTypes = number | string | boolean | null | undefined;
-export interface ResourceOptions<T> {
-	name?: string;
-	validation?: T;
-}
-export interface ResourceAddOptions {
-	sequence?: number;
-}
-export declare class Resource<T> {
-	private _items;
-	private _name?;
-	private _validation?;
-	constructor(options?: ResourceOptions<T>);
-	items: ReactiveValue<T[], T[]>;
-	add(item: T, options?: ResourceAddOptions): Resource<T>;
-	delete(item: T): Resource<T>;
-	has(item: T): boolean;
-	use(item: T, options?: ResourceAddOptions): Resource<T>;
-}
 export interface RegistryOptions<T> {
 	name?: string;
 	validation?: T;
@@ -388,33 +412,43 @@ export declare class Registry<T> {
 		id: string;
 	} & T>(item: U, options?: RegistryAddOptions): Registry<T>;
 }
-export interface PluginConstructor {
-	new (...args: any[]): Plugin$1;
-	id: string;
-}
-declare class Plugin$1 {
-	private static _shadowId;
-	static get id(): string;
-	static set id(shadowId: string);
-	__owl__: PluginManager;
-	constructor(manager: PluginManager);
-	setup(): void;
-}
-export interface PluginManagerOptions {
-	parent?: PluginManager | null;
-	config?: Record<string, any>;
+/**
+ * Creates a reactive effect bound to the surrounding component or plugin.
+ * Equivalent to `onWillDestroy(effect(fn))`: the effect runs once immediately,
+ * re-runs whenever any reactive value (signal, computed, proxy property) read
+ * during its execution changes, and is disposed when the owning scope is
+ * destroyed. If the callback returns a function, that function is called as
+ * cleanup before each re-run and on disposal.
+ */
+export declare function useEffect(fn: Parameters<typeof effect>[0]): void;
+/**
+ * Adds an event listener to a target and automatically removes it when the
+ * surrounding component or plugin is destroyed.
+ *
+ * `target` can be either an `EventTarget` (the listener is attached
+ * immediately) or a `Signal<EventTarget | null>` such as a `t-ref` (the
+ * listener is attached through a `useEffect` and re-attaches when the signal's
+ * value changes; nothing is attached while the signal is null).
+ *
+ * Example — close a menu when the user clicks anywhere on `window`:
+ *   useListener(window, "click", () => this.close());
+ */
+export declare function useListener(target: EventTarget | Signal<EventTarget | null>, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
+export declare function onWillStart(fn: (scope: Scope) => Promise<void> | void | any): void;
+export declare function onWillDestroy(fn: (scope: Scope) => void | any): void;
+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>(key: string): T;
+export declare function config<T>(key: string, type: T): T;
+export declare function config<T>(key: string, type: T, defaultValue: T): T;
+export declare class EventBus extends EventTarget {
+	trigger(name: string, payload?: any): void;
 }
-declare class PluginManager extends Scope {
-	config: Record<string, any>;
-	plugins: Record<string, Plugin$1>;
-	ready: Promise<void>;
-	constructor(app: any, options?: PluginManagerOptions);
-	destroy(): void;
-	getPluginById<T extends Plugin$1>(id: string): T | null;
-	getPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
-	startPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
-	startPlugins(pluginConstructors: PluginConstructor[]): void;
+declare class Markup extends String {
 }
+export declare function htmlEscape(str: any): Markup;
+export declare function markup(strings: TemplateStringsArray, ...placeholders: unknown[]): Markup;
+export declare function markup(value: string): Markup;
 declare class Fiber {
 	node: ComponentNode;
 	bdom: BDom | null;
@@ -468,12 +502,12 @@ declare class ComponentNode extends Scope implements VNode<ComponentNode> {
 		[key: string]: ComponentNode;
 	};
 	willUpdateProps: LifecycleHook[];
+	propsUpdated: LifecycleHook[];
 	willUnmount: LifecycleHook[];
 	mounted: LifecycleHook[];
 	willPatch: LifecycleHook[];
 	patched: LifecycleHook[];
 	signalComputation: ComputationAtom;
-	pluginManager: PluginManager;
 	constructor(C: ComponentConstructor, props: Record<string, any>, app: App, parent: ComponentNode | null, parentKey: string | null);
 	decorate(f: Function, hookName: string): Function;
 	initiateRender(fiber: Fiber | MountFiber): Promise<void>;
@@ -512,6 +546,9 @@ export declare class Component {
 	constructor(node: ComponentNode);
 	setup(): void;
 }
+declare function staticProp<T = any>(key: string): T;
+declare function staticProp<T>(key: string, type: T): T;
+declare function staticProp<T>(key: string, type: T, defaultValue: T): T;
 declare const isProps: unique symbol;
 export type WithDefaults<T, D> = T & Required<D>;
 export type Props<T extends {}> = T & {
@@ -526,11 +563,15 @@ export type GetProps<T> = {
 }[keyof T] extends (x: infer I) => void ? {
 	[K in keyof I]: I[K];
 } : never;
-export declare function props(): Props<Record<string, any>>;
-export declare function props<const Keys extends string[]>(keys: Keys): Props<ResolveObjectType<Keys>>;
-export declare function props<const Keys extends string[], Defaults>(keys: Keys, defaults: Defaults & GetPropsDefaults<KeyedObject<Keys>>): Props<WithDefaults<ResolveObjectType<Keys>, Defaults>>;
-export declare function props<Shape extends {}>(shape: Shape): Props<ResolveObjectType<Shape>>;
-export declare function props<Shape extends {}, Defaults>(shape: Shape, defaults: Defaults & GetPropsDefaults<Shape>): Props<WithDefaults<ResolveObjectType<Shape>, Defaults>>;
+export interface PropsFunction {
+	(): Props<Record<string, any>>;
+	<const Keys extends string[]>(keys: Keys): Props<ResolveObjectType<Keys>>;
+	<const Keys extends string[], Defaults>(keys: Keys, defaults: Defaults & GetPropsDefaults<KeyedObject<Keys>>): Props<WithDefaults<ResolveObjectType<Keys>, Defaults>>;
+	<Shape extends {}>(shape: Shape): Props<ResolveObjectType<Shape>>;
+	<Shape extends {}, Defaults>(shape: Shape, defaults: Defaults & GetPropsDefaults<Shape>): Props<WithDefaults<ResolveObjectType<Shape>, Defaults>>;
+	static: typeof staticProp;
+}
+export declare const props: PropsFunction;
 declare class Scheduler {
 	static requestAnimationFrame: (callback: FrameRequestCallback) => number;
 	tasks: Set<RootFiber>;
@@ -586,15 +627,7 @@ export declare namespace xml {
 	var nextId: number;
 }
 declare function validateTarget(target: HTMLElement | ShadowRoot): void;
-export declare class EventBus extends EventTarget {
-	trigger(name: string, payload?: any): void;
-}
 export declare function whenReady(fn?: any): Promise<void>;
-declare class Markup extends String {
-}
-export declare function htmlEscape(str: any): Markup;
-export declare function markup(strings: TemplateStringsArray, ...placeholders: unknown[]): Markup;
-export declare function markup(value: string): Markup;
 export type ComponentInstance<C extends ComponentConstructor> = C extends new (...args: any) => infer T ? T : never;
 export interface RootConfig<P> {
 	props?: P;
@@ -642,7 +675,7 @@ export declare class Portal extends Component {
 		slots: {
 			default: any;
 		};
-		target: string | HTMLElement | ReactiveValue<HTMLElement, HTMLElement>;
+		target: any;
 	}>;
 	setup(): void;
 }
@@ -659,47 +692,14 @@ export declare class Suspense extends Component {
 	private subRootMounted;
 	setup(): void;
 }
-export declare function prop(key: string): any;
-export declare function prop<T>(key: string, type: T): T;
-export declare function prop<T>(key: string, type: T, defaultValue: T): T;
 export type STATUS_DESCR = "new" | "started" | "mounted" | "cancelled" | "destroyed";
 declare function status$1(entity: Component | Plugin$1): STATUS_DESCR;
-/**
- * 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.
- *
- * @template T
- * @param {Effect<T>} effect the effect to run on component mount and/or patch
- * @param {()=>[...T]} [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.
- */
-export declare function useEffect(fn: Parameters<typeof effect>[0]): void;
-/**
- * When a component needs to listen to DOM Events on element(s) that are not
- * part of his hierarchy, we can use the `useListener` hook.
- * It will immediately add the listener, and remove it whenever the plugin or
- * component is destroyed.
- *
- * 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,
- *  `useListener(window, 'click', () => this._doSomething());`
- * */
-export declare function useListener(target: EventTarget | Signal<EventTarget | null>, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
-export declare function useApp(): App;
-export declare function onWillStart(fn: (scope: Scope) => Promise<void> | void | any): void;
+export declare const useApp: () => App;
 export declare function onWillUpdateProps(fn: (nextProps: any, scope: ComponentNode) => Promise<void> | void | any): void;
 export declare function onMounted(fn: (scope: ComponentNode) => void | any): void;
 export declare function onWillPatch(fn: (scope: ComponentNode) => any | void): void;
 export declare function onPatched(fn: (scope: ComponentNode) => void | any): void;
 export declare function onWillUnmount(fn: (scope: ComponentNode) => void | any): void;
-export declare function onWillDestroy(fn: (scope: Scope) => void | any): void;
 export type OnErrorCallback = (error: any) => void | any;
 export declare function onError(callback: OnErrorCallback): void;
 declare function componentType(): typeof Component;
@@ -709,6 +709,7 @@ export declare const types: {
 	any: () => any;
 	array: {
 		(): any[];
+		<T>(): T[];
 		<T>(elementType: T): T[];
 	};
 	boolean: () => boolean;
@@ -717,14 +718,16 @@ export declare const types: {
 	function: {
 		(): (...parameters: any[]) => any;
 		<const P extends any[]>(parameters: P): (...parameters: P) => void;
+		<const P extends any[], R>(): (...parameters: P) => R;
 		<const P extends any[], R>(parameters: P, result: R): (...parameters: P) => R;
 	};
 	instanceOf: <T extends Constructor>(constructor: T) => InstanceType<T>;
 	literal: <const T extends LiteralTypes>(literal: T) => T;
-	number: () => number;
+	number: <T extends number = number>() => T;
 	object: {
 		(): Record<string, any>;
 		<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
+		<Shape extends {}>(): ResolveOptionalEntries<Shape>;
 		<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
 	};
 	or: <T extends any[]>(types: T) => T[number];
@@ -743,18 +746,16 @@ export declare const types: {
 	selection: <const T extends LiteralTypes>(literals: T[]) => T;
 	signal: {
 		(): ReactiveValue<any>;
+		<T>(): ReactiveValue<T>;
 		<T>(type: T): ReactiveValue<T>;
 	};
 	strictObject: {
 		<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
 		<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
 	};
-	string: () => string;
+	string: <T extends string = string>() => T;
 	tuple: <const T extends any[]>(types: T) => T;
 };
-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(pluginConstructors: PluginConstructor[] | Resource<PluginConstructor>, config?: Record<string, any>): void;
 export declare const blockDom: {
 	config: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "3.0.0-alpha.32",
+  "version": "3.0.0-alpha.34",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "module": "dist/owl.es.js",
@@ -43,9 +43,9 @@
   },
   "homepage": "https://github.com/odoo/owl#readme",
   "devDependencies": {
-    "@odoo/owl-compiler": "3.0.0-alpha.32",
-    "@odoo/owl-core": "3.0.0-alpha.32",
-    "@odoo/owl-runtime": "3.0.0-alpha.32",
+    "@odoo/owl-compiler": "3.0.0-alpha.34",
+    "@odoo/owl-core": "3.0.0-alpha.34",
+    "@odoo/owl-runtime": "3.0.0-alpha.34",
     "jsdom": "^25.0.1"
   }
 }