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

package/dist/types/owl.d.ts

@@ -142,6 +142,150 @@ export interface ComputationAtom<T = any> extends Atom<T> {
 	state: ComputationState;
 }
 export declare function untrack<T>(fn: (...args: any[]) => T): T;
+export type Constructor<T = any> = {
+	new (...args: any[]): T;
+};
+declare const hasDefault: unique symbol;
+export type WithDefault<T> = T & {
+	[hasDefault]: T;
+};
+declare const isOptional: unique symbol;
+export type Optional<T> = T & {
+	[isOptional]: T;
+};
+declare const typeBrand: unique symbol;
+export type Type<T> = T & {
+	[typeBrand]: T;
+	/**
+	 * Marks the type as optional: `undefined` passes validation, and an object
+	 * key with an optional type may be omitted.
+	 */
+	optional(): Optional<T>;
+	/**
+	 * Marks the type as optional, with a default value to fill it: the reader
+	 * of the value always gets one (the default replaces an omitted value). The
+	 * default can be given as a factory (`() => value`), which is called once
+	 * per consumer, so mutable defaults ([], {}) are not shared. A default for
+	 * a function type must use the factory form.
+	 */
+	optional(value: T extends Function ? () => T : T | (() => T)): WithDefault<T>;
+};
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type HasDefault<T> = IsAny<T> extends true ? false : T extends {
+	[hasDefault]: any;
+} ? true : false;
+export type IsOptional<T> = IsAny<T> extends true ? false : T extends {
+	[isOptional]: any;
+} ? true : false;
+export type StripDefault<T> = T extends {
+	[hasDefault]: infer U;
+} ? U : T;
+export type StripOptional<T> = T extends {
+	[isOptional]: infer U;
+} ? U | undefined : T;
+export type StripType<T> = T extends {
+	[typeBrand]: infer U;
+} ? U : T;
+export type StripBrands<T> = StripType<StripDefault<StripOptional<T>>>;
+export type StripBrandsAll<T extends any[]> = {
+	[K in keyof T]: StripBrands<T[K]>;
+};
+export type GetDefaultedKeys<T> = keyof T extends infer K ? K extends keyof T ? HasDefault<T[K]> extends true ? K : never : never : never;
+export type GetOptionalEntries<T> = {
+	[K in keyof T as IsOptional<T[K]> extends true ? K : HasDefault<T[K]> extends true ? K : never]?: StripBrands<T[K]>;
+};
+export type GetRequiredEntries<T> = {
+	[K in keyof T as IsOptional<T[K]> extends true ? never : HasDefault<T[K]> extends true ? never : K]: StripBrands<T[K]>;
+};
+export type PrettifyShape<T> = T extends Function ? T : {
+	[K in keyof T]: T[K];
+};
+export type ResolveOptionalEntries<T> = PrettifyShape<GetRequiredEntries<T> & GetOptionalEntries<T>>;
+export type ResolveReaderObjectType<T> = PrettifyShape<{
+	[K in keyof T as IsOptional<T[K]> extends true ? never : K]: StripBrands<T[K]>;
+} & {
+	[K in keyof T as IsOptional<T[K]> extends true ? K : never]?: StripBrands<T[K]>;
+}>;
+export type KeyedObject<K extends string[]> = {
+	[P in K[number]]: any;
+};
+export type ResolveShapedObject<T extends {}> = PrettifyShape<ResolveOptionalEntries<T>>;
+export type ResolveObjectType<T extends {}> = ResolveShapedObject<T extends string[] ? KeyedObject<T> : T>;
+export type UnionToIntersection<U> = (U extends any ? (_: U) => any : never) extends (_: infer I) => void ? I : never;
+/**
+ * Returns the default value factory attached to a type by `.optional(value)`,
+ * if any. This is how consumers (props, config, ...) resolve defaults at
+ * runtime: validation only runs in dev mode, so defaults are metadata on the
+ * schema, not a validation side-effect.
+ */
+export declare function getDefault(type: any): (() => any) | undefined;
+/**
+ * Returns `value` with defaults from the schema filled in, at any depth: a
+ * default fires when the value at its schema position is `undefined`. The
+ * input is never mutated; objects are copied along the changed paths only, so
+ * if nothing is filled in, `value` is returned as is.
+ *
+ * Note that this only recurses through object shapes, tuples and arrays
+ * (unions are ambiguous, records have no fixed keys).
+ */
+export declare function applyDefaults<T>(value: unknown, type: T): StripBrands<T>;
+declare function anyType(): Type<any>;
+declare function booleanType(): Type<boolean>;
+declare function numberType<T extends number = number>(): Type<T>;
+declare function stringType<T extends string = string>(): Type<T>;
+declare function arrayType(): Type<any[]>;
+declare function arrayType<T>(): Type<T[]>;
+declare function arrayType<T>(elementType: T): Type<StripBrands<T>[]>;
+declare function constructorType<T extends Constructor>(constructor: T): Type<T>;
+declare function customValidator<T>(type: T, validator: (value: StripBrands<T>) => boolean, errorMessage?: string): Type<StripBrands<T>>;
+declare function functionType(): Type<(...parameters: any[]) => any>;
+declare function functionType<const P extends any[]>(parameters: P): Type<(...parameters: StripBrandsAll<P>) => void>;
+declare function functionType<const P extends any[], R>(): Type<(...parameters: P) => R>;
+declare function functionType<const P extends any[], R>(parameters: P, result: R): Type<(...parameters: StripBrandsAll<P>) => StripBrands<R>>;
+declare function instanceType<T extends Constructor>(constructor: T): Type<InstanceType<T>>;
+declare function intersection<T extends any[]>(types: T): Type<UnionToIntersection<StripBrands<T[number]>>>;
+export type LiteralTypes = number | string | boolean | null | undefined;
+declare function literalType<const T extends LiteralTypes>(literal: T): Type<T>;
+declare function literalSelection<const T extends LiteralTypes>(literals: T[]): Type<T>;
+declare function objectType(): Type<Record<string, any>>;
+declare function objectType<const Keys extends string[]>(keys: Keys): Type<ResolveOptionalEntries<KeyedObject<Keys>>>;
+declare function objectType<Shape extends {}>(): Type<ResolveOptionalEntries<Shape>>;
+declare function objectType<Shape extends {}>(shape: Shape): Type<ResolveOptionalEntries<Shape>>;
+declare function strictObjectType<const Keys extends string[]>(keys: Keys): Type<ResolveOptionalEntries<KeyedObject<Keys>>>;
+declare function strictObjectType<Shape extends {}>(shape: Shape): Type<ResolveOptionalEntries<Shape>>;
+declare function promiseType(): Type<Promise<void>>;
+declare function promiseType<T>(type: T): Type<Promise<StripBrands<T>>>;
+declare function recordType(): Type<Record<PropertyKey, any>>;
+declare function recordType<V>(valueType: V): Type<Record<PropertyKey, StripBrands<V>>>;
+declare function tuple<const T extends any[]>(types: T): Type<StripBrandsAll<T>>;
+declare function union<T extends any[]>(types: T): Type<StripBrands<T[number]>>;
+declare function reactiveValueType(): Type<ReactiveValue<any>>;
+declare function reactiveValueType<T>(): Type<ReactiveValue<T>>;
+declare function reactiveValueType<T>(type: T): Type<ReactiveValue<StripBrands<T>>>;
+declare function ref(): Type<HTMLElement | null>;
+declare function ref<T extends Constructor<HTMLElement>>(type: T): Type<InstanceType<T> | null>;
+declare const types: {
+	and: typeof intersection;
+	any: typeof anyType;
+	array: typeof arrayType;
+	boolean: typeof booleanType;
+	constructor: typeof constructorType;
+	customValidator: typeof customValidator;
+	function: typeof functionType;
+	instanceOf: typeof instanceType;
+	literal: typeof literalType;
+	number: typeof numberType;
+	object: typeof objectType;
+	or: typeof union;
+	promise: typeof promiseType;
+	record: typeof recordType;
+	ref: typeof ref;
+	selection: typeof literalSelection;
+	signal: typeof reactiveValueType;
+	strictObject: typeof strictObjectType;
+	string: typeof stringType;
+	tuple: typeof tuple;
+};
 export interface ResourceOptions<T> {
 	name?: string;
 	validation?: T;
@@ -149,16 +293,17 @@ export interface ResourceOptions<T> {
 export interface ResourceAddOptions {
 	sequence?: number;
 }
+export type Item<T> = StripBrands<T>;
 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>;
+	items: ReactiveValue<Item<T>[]>;
+	add(item: Item<T>, options?: ResourceAddOptions): Resource<T>;
+	delete(item: Item<T>): Resource<T>;
+	has(item: Item<T>): boolean;
+	use(item: Item<T>, options?: ResourceAddOptions): Resource<T>;
 }
 export interface PluginConstructor {
 	new (...args: any[]): Plugin$1;
@@ -307,6 +452,8 @@ export interface SignalOptions<T> {
 	type?: T;
 }
 declare function triggerSignal(signal: Signal<any>): void;
+declare function signalRef(): Signal<HTMLElement | null>;
+declare function signalRef<T extends Constructor<HTMLElement>>(type: T): Signal<InstanceType<T> | null>;
 declare function signalArray<T>(initialValue: T[]): Signal<T[]>;
 declare function signalArray<T>(initialValue: NoInfer<T>[], options: SignalOptions<T>): Signal<T[]>;
 declare function signalObject<T extends Record<PropertyKey, any>>(initialValue: T): Signal<T>;
@@ -324,6 +471,7 @@ export declare function signal<T>(value: T): Signal<T>;
 export declare function signal<T>(value: NoInfer<T>, options: SignalOptions<T>): Signal<T>;
 export declare namespace signal {
 	var trigger: typeof triggerSignal;
+	var ref: typeof signalRef;
 	var Array: typeof signalArray;
 	var Map: typeof signalMap;
 	var Object: typeof signalObject;
@@ -359,27 +507,6 @@ export interface ValidationIssue {
 }
 export declare function assertType(value: any, validation: any, errorMessage?: string): void;
 export declare function validateType(value: any, validation: any): ValidationIssue[];
-export 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];
-};
-export type GetRequiredEntries<T> = {
-	[K in keyof T as K extends `${string}?` ? never : K]: T[K];
-};
-export type PrettifyShape<T> = T extends Function ? T : {
-	[K in keyof T]: T[K];
-};
-export type ResolveOptionalEntries<T> = PrettifyShape<GetRequiredEntries<T> & GetOptionalEntries<T>>;
-export type KeyedObject<K extends string[]> = {
-	[P in K[number]]: any;
-};
-export type ResolveShapedObject<T extends {}> = PrettifyShape<ResolveOptionalEntries<T>>;
-export type ResolveObjectType<T extends {}> = ResolveShapedObject<T extends string[] ? KeyedObject<T> : T>;
-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 RegistryOptions<T> {
 	name?: string;
 	validation?: T;
@@ -387,6 +514,7 @@ export interface RegistryOptions<T> {
 export interface RegistryAddOptions extends ResourceAddOptions {
 	force?: boolean;
 }
+type Item$1<T> = StripBrands<T>;
 export declare class Registry<T> {
 	private _map;
 	private _name;
@@ -394,23 +522,20 @@ export declare class Registry<T> {
 	constructor(options?: RegistryOptions<T>);
 	entries: ReactiveValue<[
 		string,
-		T
-	][], [
-		string,
-		T
+		Item$1<T>
 	][]>;
-	items: ReactiveValue<T[], T[]>;
+	items: ReactiveValue<Item$1<T>[]>;
 	addById<U extends {
 		id: string;
-	} & T>(item: U, options?: RegistryAddOptions): Registry<T>;
-	add(key: string, value: T, options?: RegistryAddOptions): Registry<T>;
-	get(key: string, defaultValue?: T): T;
+	} & Item$1<T>>(item: U, options?: RegistryAddOptions): Registry<T>;
+	add(key: string, value: Item$1<T>, options?: RegistryAddOptions): Registry<T>;
+	get(key: string, defaultValue?: Item$1<T>): Item$1<T>;
 	delete(key: string): void;
 	has(key: string): boolean;
-	use(key: string, value: T, options?: RegistryAddOptions): Registry<T>;
+	use(key: string, value: Item$1<T>, options?: RegistryAddOptions): Registry<T>;
 	useById<U extends {
 		id: string;
-	} & T>(item: U, options?: RegistryAddOptions): Registry<T>;
+	} & Item$1<T>>(item: U, options?: RegistryAddOptions): Registry<T>;
 }
 /**
  * Creates a reactive effect bound to the surrounding component or plugin.
@@ -430,6 +555,10 @@ export declare function useEffect(fn: Parameters<typeof effect>[0]): void;
  * listener is attached through a `useEffect` and re-attaches when the signal's
  * value changes; nothing is attached while the signal is null).
  *
+ * The handler is not bound: it is passed as-is to `addEventListener`, so inside
+ * it `this` is the event target, not the calling component. Wrap a method in an
+ * arrow function (or bind it) if it relies on `this`.
+ *
  * Example — close a menu when the user clicks anywhere on `window`:
  *   useListener(window, "click", () => this.close());
  */
@@ -439,8 +568,9 @@ 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 function config<T>(key: string, type: WithDefault<T>): T;
+export declare function config<T>(key: string, type: Optional<T>): T | undefined;
+export declare function config<T>(key: string, type: T): StripBrands<T>;
 export declare class EventBus extends EventTarget {
 	trigger(name: string, payload?: any): void;
 }
@@ -547,28 +677,35 @@ export declare class Component {
 	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 function staticProp<T>(key: string, type: WithDefault<T>): T;
+declare function staticProp<T>(key: string, type: Optional<T>): T | undefined;
+declare function staticProp<T>(key: string, type: T): StripBrands<T>;
 declare const isProps: unique symbol;
-export type WithDefaults<T, D> = T & Required<D>;
 export type Props<T extends {}> = T & {
-	[isProps]: true;
+	[isProps]: never;
+};
+export type PropsWithDefaults<T extends {}, DK extends PropertyKey> = T & {
+	[isProps]: DK;
 };
-export type GetPropsDefaults<T extends object> = PrettifyShape<GetOptionalEntries<T>>;
-export type GetPropsWithOptionals<T> = T extends Props<infer P> ? (P extends WithDefaults<infer R, any> ? R : P) : never;
+export type GetPropsWithOptionals<T> = T extends {
+	[isProps]: infer DK extends PropertyKey;
+} ? Omit<T, typeof isProps | (DK & keyof T)> & Partial<Pick<T, DK & keyof T>> : never;
 export type GetProps<T> = {
 	[K in keyof T]: T[K] extends {
-		[isProps]: true;
+		[isProps]: PropertyKey;
 	} ? (x: GetPropsWithOptionals<T[K]>) => void : never;
 }[keyof T] extends (x: infer I) => void ? {
 	[K in keyof I]: I[K];
 } : never;
+export type ResolveProps<Shape> = [
+	GetDefaultedKeys<Shape>
+] extends [
+	never
+] ? Props<ResolveReaderObjectType<Shape>> : PropsWithDefaults<ResolveReaderObjectType<Shape>, GetDefaultedKeys<Shape> & PropertyKey>;
 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>>;
+	<Shape extends {}>(shape: Shape): ResolveProps<Shape>;
 	static: typeof staticProp;
 }
 export declare const props: PropsFunction;
@@ -662,11 +799,9 @@ export declare class App extends TemplateSet {
 declare function mount$1<T extends ComponentConstructor>(C: T, target: MountTarget, config?: AppConfig & RootConfig<GetProps<ComponentInstance<T>>> & MountOptions): Promise<ComponentInstance<T>>;
 export declare class ErrorBoundary extends Component {
 	static template: string;
-	props: Props<WithDefaults<{
-		error?: ReactiveValue<any, any> | undefined;
-	}, {
-		error: Signal<any>;
-	}>>;
+	props: PropsWithDefaults<{
+		error: ReactiveValue<any, any>;
+	}, "error">;
 	setup(): void;
 }
 export declare class Portal extends Component {
@@ -684,7 +819,7 @@ export declare class Suspense extends Component {
 	props: Props<{
 		slots: {
 			default: any;
-			fallback?: any;
+			fallback: any;
 		};
 	}>;
 	private prepared;
@@ -702,59 +837,8 @@ export declare function onPatched(fn: (scope: ComponentNode) => void | any): voi
 export declare function onWillUnmount(fn: (scope: ComponentNode) => void | any): void;
 export type OnErrorCallback = (error: any) => void | any;
 export declare function onError(callback: OnErrorCallback): void;
-declare function componentType(): typeof Component;
-export declare const types: {
-	component: typeof componentType;
-	and: <T extends any[]>(types: T) => UnionToIntersection<T[number]>;
-	any: () => any;
-	array: {
-		(): any[];
-		<T>(): T[];
-		<T>(elementType: T): T[];
-	};
-	boolean: () => boolean;
-	constructor: typeof constructorType;
-	customValidator: <T>(type: T, validator: (value: T) => boolean, errorMessage?: string) => T;
-	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: <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];
-	promise: {
-		(): Promise<void>;
-		<T>(type: T): Promise<T>;
-	};
-	record: {
-		(): Record<PropertyKey, any>;
-		<V>(valueType: V): Record<PropertyKey, V>;
-	};
-	ref: {
-		(): HTMLElement | null;
-		<T extends Constructor<HTMLElement>>(type: T): InstanceType<T> | null;
-	};
-	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: <T extends string = string>() => T;
-	tuple: <const T extends any[]>(types: T) => T;
+declare const types$1: typeof types & {
+	component: () => Type<typeof Component>;
 };
 export declare function providePlugins(pluginConstructors: PluginConstructor[] | Resource<PluginConstructor>, config?: Record<string, any>): void;
 export declare const blockDom: {
@@ -778,6 +862,8 @@ export {
 	Plugin$1 as Plugin,
 	mount$1 as mount,
 	status$1 as status,
+	types$1 as t,
+	types$1 as types,
 };
 
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "3.0.0-alpha.34",
+  "version": "3.0.0-alpha.36",
   "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.34",
-    "@odoo/owl-core": "3.0.0-alpha.34",
-    "@odoo/owl-runtime": "3.0.0-alpha.34",
+    "@odoo/owl-compiler": "3.0.0-alpha.36",
+    "@odoo/owl-core": "3.0.0-alpha.36",
+    "@odoo/owl-runtime": "3.0.0-alpha.36",
     "jsdom": "^25.0.1"
   }
 }