@odoo/owl 3.0.0-alpha.35 → 3.0.0-alpha.37

package/dist/types/owl.d.ts

@@ -156,21 +156,19 @@ export type Optional<T> = T & {
 declare const typeBrand: unique symbol;
 export type Type<T> = T & {
 	[typeBrand]: T;
-	/**
-	 * Attaches a default value to the type. A defaulted value is implicitly
-	 * optional: `undefined` passes validation (the default is meant to fill
-	 * it). 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.
-	 */
-	default(value: T extends Function ? () => T : T | (() => T)): WithDefault<T>;
 	/**
 	 * Marks the type as optional: `undefined` passes validation, and an object
-	 * key with an optional type may be omitted. A type with a default is
-	 * already implicitly optional, so `.optional()` and `.default()` do not
-	 * need to be combined (and cannot be chained).
+	 * 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 {
@@ -192,9 +190,7 @@ export type StripBrands<T> = StripType<StripDefault<StripOptional<T>>>;
 export type StripBrandsAll<T extends any[]> = {
 	[K in keyof T]: StripBrands<T[K]>;
 };
-export type GetDefaultedEntries<T> = {
-	[K in keyof T as HasDefault<T[K]> extends true ? K : never]: 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]>;
 };
@@ -205,6 +201,11 @@ 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;
 };
@@ -212,8 +213,8 @@ export type ResolveShapedObject<T extends {}> = PrettifyShape<ResolveOptionalEnt
 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 `.default()`, if
- * any. This is how consumers (props, config, ...) resolve defaults at
+ * 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.
  */
@@ -238,9 +239,9 @@ 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 functionType<const P extends unknown[]>(parameters: P): Type<(...parameters: StripBrandsAll<P>) => void>;
+declare function functionType<const P extends unknown[], R>(): Type<(...parameters: P) => R>;
+declare function functionType<const P extends unknown[], 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;
@@ -256,8 +257,8 @@ 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 tuple<const T extends unknown[]>(types: T): Type<StripBrandsAll<T>>;
+declare function union<T extends unknown[]>(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>>>;
@@ -637,6 +638,11 @@ declare class ComponentNode extends Scope implements VNode<ComponentNode> {
 	willPatch: LifecycleHook[];
 	patched: LifecycleHook[];
 	signalComputation: ComputationAtom;
+	trackedRefs: Map<{
+		set(v: null): void;
+	}, {
+		value: HTMLElement | null;
+	}> | null;
 	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>;
@@ -645,6 +651,19 @@ declare class ComponentNode extends Scope implements VNode<ComponentNode> {
 	_cancel(): void;
 	destroy(): void;
 	_destroy(): void;
+	/**
+	 * Unset any tracked t-ref whose element is no longer in the document, and stop
+	 * tracking it (createRef re-registers it on the next render if the element
+	 * comes back). `isConnected` is the discriminator: a ref the block's own
+	 * remove() failed to clear (bulk removal) points at a detached element and is
+	 * cleared, while a ref a surviving sibling just took over (t-if/t-else with a
+	 * shared signal) points at a still-connected element and is left alone.
+	 *
+	 * Called after this component's dom settles: at the tail of `_patch` (before
+	 * user `onPatched`), so an element removed in place is caught, and — for the
+	 * nodes collected during `_destroy` — after a removed subtree is detached.
+	 */
+	sweepRefs(): 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
@@ -655,6 +674,16 @@ declare class ComponentNode extends Scope implements VNode<ComponentNode> {
 	mount(parent: HTMLElement, anchor: ChildNode): void;
 	moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
 	moveBeforeVNode(other: ComponentNode | null, afterNode: Node | null): void;
+	/**
+	 * Register a t-ref signal bound to an element this component hosts, so its
+	 * lifecycle can clear it (see sweepRefs / _destroy). Idempotent — re-tracking
+	 * the same signal on each render just refreshes its atom.
+	 */
+	trackRef(ref: {
+		set(v: null): void;
+	}, atom: {
+		value: HTMLElement | null;
+	}): void;
 	patch(): void;
 	_patch(): void;
 	beforeRemove(): void;
@@ -680,22 +709,31 @@ 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 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>>;
-	<Shape extends {}>(shape: Shape): Props<WithDefaults<ResolveObjectType<Shape>, GetDefaultedEntries<Shape>>>;
+	<Shape extends {}>(shape: Shape): ResolveProps<Shape>;
 	static: typeof staticProp;
 }
 export declare const props: PropsFunction;
@@ -789,41 +827,29 @@ 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;
-	}, GetDefaultedEntries<{
-		error: WithDefault<ReactiveValue<any, any>>;
-	}>>>;
+	props: PropsWithDefaults<{
+		error: ReactiveValue<any, any>;
+	}, "error">;
 	setup(): void;
 }
 export declare class Portal extends Component {
 	static template: string;
-	props: Props<WithDefaults<{
+	props: Props<{
 		slots: {
 			default: any;
 		};
-		target: any;
-	}, GetDefaultedEntries<{
-		slots: Type<{
-			default: any;
-		}>;
-		target: any;
-	}>>>;
+		target: string | HTMLElement | ReactiveValue<HTMLElement, HTMLElement>;
+	}>;
 	setup(): void;
 }
 export declare class Suspense extends Component {
 	static template: string;
-	props: Props<WithDefaults<{
+	props: Props<{
 		slots: {
 			default: any;
 			fallback: any;
 		};
-	}, GetDefaultedEntries<{
-		slots: Type<{
-			default: any;
-			fallback: any;
-		}>;
-	}>>>;
+	}>;
 	private prepared;
 	private mounted;
 	private subRootMounted;

package/package.json

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