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

package/dist/owl.es.js

@@ -569,6 +569,9 @@ function triggerSignal(signal2) {
   }
   onWriteAtom(signal2[atomSymbol]);
 }
+function signalRef() {
+  return buildSignal(null, (atom) => atom.value);
+}
 function signalArray(initialValue) {
   return buildSignal(initialValue, (atom) => proxifyTarget(atom.value, atom));
 }
@@ -585,6 +588,7 @@ function signal(value) {
   return buildSignal(value, (atom) => atom.value);
 }
 signal.trigger = triggerSignal;
+signal.ref = signalRef;
 signal.Array = signalArray;
 signal.Map = signalMap;
 signal.Object = signalObject;
@@ -752,7 +756,7 @@ function createContext(issues, value, path, parent) {
     addIssue(issue) {
       issues.push({
         received: this.value,
-        path: this.path,
+        path: this.path.join(" > "),
         ...issue
       });
     },
@@ -778,33 +782,123 @@ function validateType(value, validation) {
   validation(createContext(issues, value, []));
   return issues;
 }
-function anyType() {
-  return function validateAny() {
+var defaultSymbol = /* @__PURE__ */ Symbol("default");
+var innerTypeSymbol = /* @__PURE__ */ Symbol("innerType");
+var shapeSymbol = /* @__PURE__ */ Symbol("shape");
+var elementTypeSymbol = /* @__PURE__ */ Symbol("elementType");
+var optionalSymbol = /* @__PURE__ */ Symbol("optional");
+function getDefault(type) {
+  return typeof type === "function" ? type[defaultSymbol] : void 0;
+}
+function hasDefaultValue(type) {
+  return typeof type === "function" && defaultSymbol in type;
+}
+function withDefault(type, value) {
+  const validate = function validateWithDefault(context) {
+    if (context.value === void 0) {
+      return;
+    }
+    context.validate(type);
   };
+  validate[defaultSymbol] = typeof value === "function" ? value : () => value;
+  validate[innerTypeSymbol] = type;
+  return validate;
+}
+function makeOptional(type) {
+  const validate = function validateOptional(context) {
+    if (context.value === void 0) {
+      return;
+    }
+    context.validate(type);
+  };
+  validate[optionalSymbol] = true;
+  validate[innerTypeSymbol] = type;
+  return validate;
+}
+function isOptionalType(type) {
+  return typeof type === "function" && optionalSymbol in type;
+}
+function makeType(validate) {
+  validate.default = (value) => withDefault(validate, value);
+  validate.optional = () => makeOptional(validate);
+  return validate;
+}
+function applyDefaults(value, type) {
+  return applyDefaultsRec(value, type);
+}
+function applyDefaultsRec(value, type) {
+  if (typeof type !== "function") {
+    return value;
+  }
+  if (value === void 0) {
+    const factory = type[defaultSymbol];
+    if (!factory) {
+      return value;
+    }
+    value = factory();
+  }
+  const inner = type[innerTypeSymbol] || type;
+  if (typeof inner !== "function" || !value || typeof value !== "object") {
+    return value;
+  }
+  const elementType = inner[elementTypeSymbol];
+  if (elementType && Array.isArray(value)) {
+    let result2 = value;
+    for (let index = 0; index < value.length; index++) {
+      const newValue = applyDefaultsRec(value[index], elementType);
+      if (newValue !== value[index]) {
+        if (result2 === value) {
+          result2 = [...value];
+        }
+        result2[index] = newValue;
+      }
+    }
+    return result2;
+  }
+  const shape = inner[shapeSymbol];
+  if (!shape) {
+    return value;
+  }
+  let result = value;
+  for (const key in shape) {
+    const subValue = result[key];
+    const newValue = applyDefaultsRec(subValue, shape[key]);
+    if (newValue !== subValue) {
+      if (result === value) {
+        result = Array.isArray(value) ? [...value] : { ...value };
+      }
+      result[key] = newValue;
+    }
+  }
+  return result;
+}
+function anyType() {
+  return makeType(function validateAny() {
+  });
 }
 function booleanType() {
-  return function validateBoolean(context) {
+  return makeType(function validateBoolean(context) {
     if (typeof context.value !== "boolean") {
       context.addIssue({ message: "value is not a boolean" });
     }
-  };
+  });
 }
 function numberType() {
-  return function validateNumber(context) {
+  return makeType(function validateNumber(context) {
     if (typeof context.value !== "number") {
       context.addIssue({ message: "value is not a number" });
     }
-  };
+  });
 }
 function stringType() {
-  return function validateString(context) {
+  return makeType(function validateString(context) {
     if (typeof context.value !== "string" && !(context.value instanceof String)) {
       context.addIssue({ message: "value is not a string" });
     }
-  };
+  });
 }
 function arrayType(elementType) {
-  return function validateArray(context) {
+  const validate = makeType(function validateArray(context) {
     if (!Array.isArray(context.value)) {
       context.addIssue({ message: "value is not an array" });
       return;
@@ -815,17 +909,21 @@ function arrayType(elementType) {
     for (let index = 0; index < context.value.length; index++) {
       context.withKey(index).validate(elementType);
     }
-  };
+  });
+  if (elementType) {
+    validate[elementTypeSymbol] = elementType;
+  }
+  return validate;
 }
 function constructorType(constructor) {
-  return function validateConstructor(context) {
+  return makeType(function validateConstructor(context) {
     if (!(typeof context.value === "function") || !(context.value === constructor || context.value.prototype instanceof constructor)) {
       context.addIssue({ message: `value is not '${constructor.name}' or an extension` });
     }
-  };
+  });
 }
 function customValidator(type, validator, errorMessage = "value does not match custom validation") {
-  return function validateCustom(context) {
+  return makeType(function validateCustom(context) {
     context.validate(type);
     if (!context.isValid) {
       return;
@@ -833,37 +931,37 @@ function customValidator(type, validator, errorMessage = "value does not match c
     if (!validator(context.value)) {
       context.addIssue({ message: errorMessage });
     }
-  };
+  });
 }
 function functionType(parameters = [], result = void 0) {
-  return function validateFunction(context) {
+  return makeType(function validateFunction(context) {
     if (typeof context.value !== "function") {
       context.addIssue({ message: "value is not a function" });
     }
-  };
+  });
 }
 function instanceType(constructor) {
-  return function validateInstanceType(context) {
+  return makeType(function validateInstanceType(context) {
     if (!(context.value instanceof constructor)) {
       context.addIssue({ message: `value is not an instance of '${constructor.name}'` });
     }
-  };
+  });
 }
 function intersection(types22) {
-  return function validateIntersection(context) {
+  return makeType(function validateIntersection(context) {
     for (const type of types22) {
       context.validate(type);
     }
-  };
+  });
 }
 function literalType(literal) {
-  return function validateLiteral(context) {
+  return makeType(function validateLiteral(context) {
     if (context.value !== literal) {
       context.addIssue({
         message: `value is not equal to ${typeof literal === "string" ? `'${literal}'` : literal}`
       });
     }
-  };
+  });
 }
 function literalSelection(literals) {
   return union(literals.map(literalType));
@@ -891,15 +989,14 @@ function validateObject(context, schema, isStrict) {
   }
   const missingKeys = [];
   for (const key of keys) {
-    const property = key.endsWith("?") ? key.slice(0, -1) : key;
-    if (context.value[property] === void 0) {
-      if (!key.endsWith("?")) {
-        missingKeys.push(property);
+    if (context.value[key] === void 0) {
+      if (!isOptionalType(shape[key]) && !hasDefaultValue(shape[key])) {
+        missingKeys.push(key);
       }
       continue;
     }
     if (isShape) {
-      context.withKey(property).validate(shape[key]);
+      context.withKey(key).validate(shape[key]);
     }
   }
   if (missingKeys.length) {
@@ -912,7 +1009,7 @@ function validateObject(context, schema, isStrict) {
   if (isStrict) {
     const unknownKeys = [];
     for (const key in context.value) {
-      if (!keys.includes(key) && !(`${key}?` in shape)) {
+      if (!keys.includes(key)) {
         unknownKeys.push(key);
       }
     }
@@ -926,24 +1023,32 @@ function validateObject(context, schema, isStrict) {
   }
 }
 function objectType(schema = {}) {
-  return function validateLooseObject(context) {
+  const validate = makeType(function validateLooseObject(context) {
     validateObject(context, schema, false);
-  };
+  });
+  if (!Array.isArray(schema)) {
+    validate[shapeSymbol] = schema;
+  }
+  return validate;
 }
 function strictObjectType(schema) {
-  return function validateStrictObject(context) {
+  const validate = makeType(function validateStrictObject(context) {
     validateObject(context, schema, true);
-  };
+  });
+  if (!Array.isArray(schema)) {
+    validate[shapeSymbol] = schema;
+  }
+  return validate;
 }
 function promiseType(type) {
-  return function validatePromise(context) {
+  return makeType(function validatePromise(context) {
     if (!(context.value instanceof Promise)) {
       context.addIssue({ message: "value is not a promise" });
     }
-  };
+  });
 }
 function recordType(valueType) {
-  return function validateRecord(context) {
+  return makeType(function validateRecord(context) {
     if (typeof context.value !== "object" || Array.isArray(context.value) || context.value === null) {
       context.addIssue({ message: "value is not an object" });
       return;
@@ -954,10 +1059,10 @@ function recordType(valueType) {
     for (const key in context.value) {
       context.withKey(key).validate(valueType);
     }
-  };
+  });
 }
 function tuple(types22) {
-  return function validateTuple(context) {
+  const validate = makeType(function validateTuple(context) {
     if (!Array.isArray(context.value)) {
       context.addIssue({ message: "value is not an array" });
       return;
@@ -969,10 +1074,12 @@ function tuple(types22) {
     for (let index = 0; index < types22.length; index++) {
       context.withKey(index).validate(types22[index]);
     }
-  };
+  });
+  validate[shapeSymbol] = types22;
+  return validate;
 }
 function union(types22) {
-  return function validateUnion(context) {
+  return makeType(function validateUnion(context) {
     let firstIssueIndex = 0;
     const subIssues = [];
     for (const type of types22) {
@@ -988,17 +1095,20 @@ function union(types22) {
       message: "value does not match union type",
       subIssues
     });
-  };
+  });
 }
 function reactiveValueType(type) {
-  return function validateReactiveValue(context) {
+  return makeType(function validateReactiveValue(context) {
     if (typeof context.value !== "function" || !context.value[atomSymbol]) {
       context.addIssue({ message: "value is not a reactive value" });
     }
-  };
+  });
 }
 function ref(type) {
-  return union([literalType(null), instanceType(type)]);
+  if (typeof HTMLElement === "undefined") {
+    throw new Error("Cannot use ref in a non-DOM environment");
+  }
+  return union([literalType(null), instanceType(type || HTMLElement)]);
 }
 var types = {
   and: intersection,
@@ -1126,6 +1236,13 @@ var Plugin = class {
   static set id(shadowId) {
     this._shadowId = shadowId;
   }
+  // Plugins passed to `startPlugins` are started in batches of equal sequence,
+  // ascending (lower first), like Resource/Registry. Each batch's onWillStart
+  // callbacks fully settle before the next batch is instantiated, so
+  // foundational plugins (low sequence) are ready before later plugins even
+  // run their setup. Explicit `plugin(X)` dependencies bypass batching and
+  // start immediately.
+  static sequence = 50;
   __owl__;
   constructor(manager) {
     this.__owl__ = manager;
@@ -1136,11 +1253,13 @@ var Plugin = class {
 var PluginManager = class extends Scope {
   config;
   plugins;
-  // Resolves once all pending plugin willStart callbacks have settled. The
-  // scope transitions to MOUNTED as the last step of this chain. Consumers
-  // (the root's mount(), providePlugins) await this before treating the
-  // manager as ready. `willStart` itself is inherited from Scope.
+  // Resolves once all batches of plugins have started and their willStart
+  // callbacks have settled. The scope transitions to MOUNTED as the last step
+  // of this chain. Consumers (the root's mount(), providePlugins) await this
+  // before treating the manager as ready. `willStart` itself is inherited
+  // from Scope.
   ready = Promise.resolve();
+  hasPendingReady = false;
   constructor(app, options = {}) {
     super(app);
     this.config = options.config ?? {};
@@ -1181,24 +1300,61 @@ var PluginManager = class extends Scope {
     return plugin2;
   }
   startPlugins(pluginConstructors) {
-    scopeStack.push(this);
-    try {
-      for (const pluginConstructor of pluginConstructors) {
-        this.startPlugin(pluginConstructor);
+    const fresh = pluginConstructors.filter((ctor) => {
+      if (!ctor.id || this.plugins.hasOwnProperty(ctor.id)) {
+        this.startPlugin(ctor);
+        return false;
       }
-    } finally {
-      scopeStack.pop();
+      return true;
+    });
+    if (!fresh.length) {
+      return;
     }
-    const pending = this.willStart.splice(0);
-    if (pending.length) {
-      this.ready = Promise.all(pending.map((fn) => fn())).then(() => {
-        if (this.status < STATUS.MOUNTED) {
-          this.status = STATUS.MOUNTED;
+    fresh.sort((p1, p2) => p1.sequence - p2.sequence);
+    const batches = [];
+    for (const ctor of fresh) {
+      const batch = batches[batches.length - 1];
+      if (batch && batch[0].sequence === ctor.sequence) {
+        batch.push(ctor);
+      } else {
+        batches.push([ctor]);
+      }
+    }
+    const startBatch = (batch) => {
+      scopeStack.push(this);
+      try {
+        for (const ctor of batch) {
+          this.startPlugin(ctor);
         }
-      });
-    } else if (this.status < STATUS.MOUNTED) {
-      this.status = STATUS.MOUNTED;
+      } finally {
+        scopeStack.pop();
+      }
+      const pending = this.willStart.splice(0);
+      return pending.length ? Promise.all(pending.map((fn) => fn())) : null;
+    };
+    let chain = this.hasPendingReady ? this.ready : null;
+    for (const batch of batches) {
+      if (chain) {
+        chain = chain.then(() => startBatch(batch));
+      } else {
+        chain = startBatch(batch);
+      }
     }
+    if (!chain) {
+      if (this.status < STATUS.MOUNTED) {
+        this.status = STATUS.MOUNTED;
+      }
+      return;
+    }
+    this.hasPendingReady = true;
+    const ready = this.ready = chain.then(() => {
+      if (this.status < STATUS.MOUNTED) {
+        this.status = STATUS.MOUNTED;
+      }
+      if (this.ready === ready) {
+        this.hasPendingReady = false;
+      }
+    });
   }
 };
 function startPlugins(manager, plugins) {
@@ -1254,7 +1410,7 @@ function plugin(pluginType) {
   }
   return plugin2;
 }
-function config(key, type, defaultValue) {
+function config(key, type) {
   const scope = useScope();
   if (!(scope instanceof PluginManager)) {
     throw new OwlError("Expected to be in a plugin scope");
@@ -1262,8 +1418,8 @@ function config(key, type, defaultValue) {
   if (scope.app.dev && type) {
     assertType(scope.config, types.object({ [key]: type }), "Config does not match the type");
   }
-  const configValue = scope.config[key.endsWith("?") ? key.slice(0, -1) : key];
-  return configValue === void 0 ? defaultValue : configValue;
+  const configValue = scope.config[key];
+  return configValue === void 0 ? getDefault(type)?.() : configValue;
 }
 var EventBus = class extends EventTarget {
   trigger(name, payload) {
@@ -1309,7 +1465,7 @@ function markup(valueOrStrings, ...placeholders) {
 }
 
 // ../owl-runtime/dist/owl-runtime.es.js
-var version = "3.0.0-alpha.33";
+var version = "3.0.0-alpha.35";
 var fibersInError = /* @__PURE__ */ new WeakMap();
 var nodeErrorHandlers = /* @__PURE__ */ new WeakMap();
 function invokeErrorHandlers(node, error, finalize, markFibers) {
@@ -1589,20 +1745,20 @@ function toClassObj(expr) {
   }
 }
 var CSS_PROP_CACHE = {};
-function toKebabCase(prop2) {
-  if (prop2 in CSS_PROP_CACHE) {
-    return CSS_PROP_CACHE[prop2];
+function toKebabCase(prop) {
+  if (prop in CSS_PROP_CACHE) {
+    return CSS_PROP_CACHE[prop];
   }
-  const result = prop2.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
-  CSS_PROP_CACHE[prop2] = result;
+  const result = prop.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+  CSS_PROP_CACHE[prop] = result;
   return result;
 }
 var IMPORTANT_RE = /\s*!\s*important\s*$/i;
-function setStyleProp(style, prop2, value) {
+function setStyleProp(style, prop, value) {
   if (IMPORTANT_RE.test(value)) {
-    style.setProperty(prop2, value.replace(IMPORTANT_RE, ""), "important");
+    style.setProperty(prop, value.replace(IMPORTANT_RE, ""), "important");
   } else {
-    style.setProperty(prop2, value);
+    style.setProperty(prop, value);
   }
 }
 function toStyleObj(expr) {
@@ -1646,19 +1802,19 @@ function toStyleObj(expr) {
         if (colonIdx === -1) {
           continue;
         }
-        const prop2 = trim.call(part.slice(0, colonIdx));
+        const prop = trim.call(part.slice(0, colonIdx));
         const value = trim.call(part.slice(colonIdx + 1));
-        if (prop2 && value && value !== "undefined") {
-          result[prop2] = value;
+        if (prop && value && value !== "undefined") {
+          result[prop] = value;
         }
       }
       return result;
     }
     case "object":
-      for (let prop2 in expr) {
-        const value = expr[prop2];
+      for (let prop in expr) {
+        const value = expr[prop];
         if (value || value === 0) {
-          result[toKebabCase(prop2)] = String(value);
+          result[toKebabCase(prop)] = String(value);
         }
       }
       return result;
@@ -1689,22 +1845,22 @@ function updateClass(val, oldVal) {
 function setStyle(val) {
   val = val === "" ? {} : toStyleObj(val);
   const style = this.style;
-  for (let prop2 in val) {
-    setStyleProp(style, prop2, val[prop2]);
+  for (let prop in val) {
+    setStyleProp(style, prop, val[prop]);
   }
 }
 function updateStyle(val, oldVal) {
   oldVal = oldVal === "" ? {} : toStyleObj(oldVal);
   val = val === "" ? {} : toStyleObj(val);
   const style = this.style;
-  for (let prop2 in oldVal) {
-    if (!(prop2 in val)) {
-      style.removeProperty(prop2);
+  for (let prop in oldVal) {
+    if (!(prop in val)) {
+      style.removeProperty(prop);
     }
   }
-  for (let prop2 in val) {
-    if (val[prop2] !== oldVal[prop2]) {
-      setStyleProp(style, prop2, val[prop2]);
+  for (let prop in val) {
+    if (val[prop] !== oldVal[prop]) {
+      setStyleProp(style, prop, val[prop]);
     }
   }
   if (!style.cssText) {
@@ -3196,6 +3352,10 @@ var ComponentNode = class extends Scope {
   parent;
   children = /* @__PURE__ */ Object.create(null);
   willUpdateProps = [];
+  // Fired right after `props` is applied to `node.props` on a parent re-render,
+  // so reactive prop notifications happen once the new values are observable
+  // (after user `onWillUpdateProps` hooks, including async ones, have run).
+  propsUpdated = [];
   willUnmount = [];
   mounted = [];
   willPatch = [];
@@ -3496,7 +3656,7 @@ var Component = class {
   }
 };
 var ObjectCreate = Object.create;
-function withDefault(value, defaultValue) {
+function withDefault2(value, defaultValue) {
   return value === void 0 || value === null || value === false ? defaultValue : value;
 }
 function callSlot(ctx, parent, key, name, dynamic, extra, defaultContent) {
@@ -3730,6 +3890,7 @@ function createComponent(app, name, isStatic, hasSlotsProp, hasDynamicPropList,
             () => {
               if (fiber !== node.fiber) return;
               node.props = props2;
+              for (const f of node.propsUpdated) f();
               fiber.render();
             },
             (error) => {
@@ -3738,6 +3899,7 @@ function createComponent(app, name, isStatic, hasSlotsProp, hasDynamicPropList,
           );
         } else {
           node.props = props2;
+          for (const f of node.propsUpdated) f();
           fiber.render();
         }
       }
@@ -3780,7 +3942,7 @@ function callTemplate(subTemplate, owner, app, ctx, parent, key) {
   return toggler(subTemplate, template.call(owner, ctx, parent, key + subTemplate));
 }
 var helpers = {
-  withDefault,
+  withDefault: withDefault2,
   zero: /* @__PURE__ */ Symbol("zero"),
   callSlot,
   withKey,
@@ -4110,56 +4272,89 @@ function onError(callback) {
   }
   handlers.push(callback.bind(scope.component));
 }
-function componentType() {
-  return constructorType(Component);
-}
-var types2 = { ...types, component: componentType };
-function validateDefaults(schema) {
-  const validation = {};
-  if (Array.isArray(schema)) {
-    for (const key of schema) {
-      if (key.endsWith("?")) {
-        validation[key] = types2.any();
-      }
+function staticProp(key, type) {
+  const node = getComponentScope();
+  const defaultFactory = getDefault(type);
+  const propValue = node.props[key];
+  if (node.app.dev) {
+    if (type !== void 0 && (!defaultFactory || propValue !== void 0)) {
+      assertType(propValue, type, `Invalid prop '${key}' in '${node.componentName}'`);
     }
-  } else {
-    for (const key in schema) {
-      if (key.endsWith("?")) {
-        validation[key] = schema[key];
+    node.willUpdateProps.push((nextProps) => {
+      if (nextProps[key] !== node.props[key]) {
+        throw new OwlError(
+          `Prop '${key}' changed in component '${node.componentName}'. Props declared with \`props.static()\` are static and should not change. If the prop is a signal, pass the same signal reference (its inner value may change).`
+        );
       }
-    }
+    });
   }
-  return types2.strictObject(validation);
+  return propValue === void 0 && defaultFactory ? defaultFactory() : propValue;
 }
-function props(type, defaults) {
+function componentType() {
+  return constructorType(Component);
+}
+var types2 = {
+  ...types,
+  component: componentType
+};
+function makeProps(type) {
   const node = getComponentScope();
   const { app, componentName } = node;
+  let defaults = null;
+  if (type && !Array.isArray(type)) {
+    for (const key in type) {
+      const factory = getDefault(type[key]);
+      if (factory) {
+        (defaults ||= {})[key] = factory();
+      }
+    }
+  }
   if (defaults) {
     node.defaultProps = Object.assign(node.defaultProps || {}, defaults);
   }
-  function getProp(key) {
-    if (node.props[key] === void 0 && defaults) {
+  function resolveValue(props2, key) {
+    if (props2[key] === void 0 && defaults && key in defaults) {
       return defaults[key];
     }
-    return node.props[key];
+    return props2[key];
   }
+  const signals = /* @__PURE__ */ Object.create(null);
   const result = /* @__PURE__ */ Object.create(null);
-  function applyPropGetters(keys) {
+  function defineProp(key) {
+    signals[key] = signal(resolveValue(node.props, key));
+    Reflect.defineProperty(result, key, {
+      enumerable: true,
+      configurable: true,
+      get: signals[key]
+    });
+  }
+  function defineProps(keys) {
     for (const key of keys) {
-      Reflect.defineProperty(result, key, {
-        enumerable: true,
-        get: getProp.bind(null, key)
-      });
+      defineProp(key);
+    }
+  }
+  function updateSignals(keys) {
+    for (const key of keys) {
+      signals[key].set(resolveValue(node.props, key));
     }
   }
   if (type) {
-    const keys = (Array.isArray(type) ? type : Object.keys(type)).map(
-      (key) => key.endsWith("?") ? key.slice(0, -1) : key
-    );
-    applyPropGetters(keys);
+    const keys = Array.isArray(type) ? type : Object.keys(type);
+    defineProps(keys);
+    node.propsUpdated.push(() => updateSignals(keys));
     if (app.dev) {
       if (defaults) {
-        assertType(defaults, validateDefaults(type), `Invalid component default props (${componentName})`);
+        const defaultedShape = {};
+        for (const key in type) {
+          if (key in defaults) {
+            defaultedShape[key] = type[key];
+          }
+        }
+        assertType(
+          defaults,
+          types2.object(defaultedShape),
+          `Invalid component default props (${componentName})`
+        );
       }
       const validation = types2.object(type);
       assertType(node.props, validation, `Invalid component props (${componentName})`);
@@ -4175,27 +4370,31 @@ function props(type, defaults) {
           keys2.push(k);
         }
       }
-      if (defaults) {
-        for (const k in defaults) {
-          if (!(k in props2)) {
-            keys2.push(k);
-          }
-        }
-      }
       return keys2;
     };
     let keys = getKeys(node.props);
-    applyPropGetters(keys);
-    node.willUpdateProps.push((np) => {
+    defineProps(keys);
+    node.propsUpdated.push(() => {
+      const nextKeys = getKeys(node.props);
+      const nextKeySet = new Set(nextKeys);
       for (const key of keys) {
-        Reflect.deleteProperty(result, key);
+        if (!nextKeySet.has(key)) {
+          Reflect.deleteProperty(result, key);
+          delete signals[key];
+        }
+      }
+      for (const key of nextKeys) {
+        if (!(key in signals)) {
+          defineProp(key);
+        }
       }
-      keys = getKeys(np);
-      applyPropGetters(keys);
+      updateSignals(nextKeys);
+      keys = nextKeys;
     });
   }
   return result;
 }
+var props = Object.assign(makeProps, { static: staticProp });
 var ErrorBoundary = class extends Component {
   static template = xml`
     <t t-if="this.props.error()">
@@ -4205,7 +4404,7 @@ var ErrorBoundary = class extends Component {
       <t t-call-slot="default"/>
     </t>
   `;
-  props = props({ "error?": types2.signal() }, { error: signal(null) });
+  props = props({ error: types2.signal().default(() => signal(null)) });
   setup() {
     onError((e) => this.props.error.set(e));
   }
@@ -4266,7 +4465,7 @@ var Suspense = class extends Component {
       <t t-call-slot="fallback"/>
     </t>
   `;
-  props = props({ slots: types2.object(["default", "fallback?"]) });
+  props = props({ slots: types2.object({ default: types2.any(), fallback: types2.any().optional() }) });
   prepared = signal(false);
   mounted = signal(false);
   subRootMounted = false;
@@ -4294,24 +4493,6 @@ var Suspense = class extends Component {
     onWillDestroy(() => root.destroy());
   }
 };
-function prop(key, type, ...args) {
-  const node = getComponentScope();
-  const hasDefault = args.length > 0;
-  const propValue = node.props[key];
-  if (node.app.dev) {
-    if (type !== void 0 && (!hasDefault || propValue !== void 0)) {
-      assertType(propValue, type, `Invalid prop '${key}' in '${node.componentName}'`);
-    }
-    node.willUpdateProps.push((nextProps) => {
-      if (nextProps[key] !== node.props[key]) {
-        throw new OwlError(
-          `Prop '${key}' changed in component '${node.componentName}'. Props declared with \`prop()\` are static and should not change. If the prop is a signal, pass the same signal reference (its inner value may change).`
-        );
-      }
-    });
-  }
-  return propValue === void 0 && hasDefault ? args[0] : propValue;
-}
 function providePlugins(pluginConstructors, config3) {
   const node = getComponentScope();
   const manager = new PluginManager(node.app, { parent: node.pluginManager, config: config3 });
@@ -4340,8 +4521,8 @@ var blockDom = {
 };
 var __info__ = {
   version: App.version,
-  date: "2026-05-28T13:29:02.340Z",
-  hash: "fadc22b7",
+  date: "2026-06-11T09:51:14.980Z",
+  hash: "739fc964",
   url: "https://github.com/odoo/owl"
 };
 
@@ -6530,6 +6711,7 @@ export {
   Suspense,
   TemplateSet,
   __info__,
+  applyDefaults,
   assertType,
   asyncComputed,
   batched,
@@ -6537,6 +6719,7 @@ export {
   computed,
   config,
   effect,
+  getDefault,
   getScope,
   globalTemplates,
   htmlEscape,
@@ -6552,12 +6735,12 @@ export {
   onWillUnmount,
   onWillUpdateProps,
   plugin,
-  prop,
   props,
   providePlugins,
   proxy,
   signal,
   status,
+  types2 as t,
   toRaw,
   types2 as types,
   untrack,