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

package/dist/owl.iife.js

@@ -823,7 +823,7 @@ var owl = (() => {
 ${issueStrings}`);
     }
   }
-  function createContext(issues, value, path, parent) {
+  function createContext(issues, value, path, parent, depthOffset = 1) {
     return {
       issueDepth: 0,
       path,
@@ -844,11 +844,11 @@ ${issueStrings}`);
       validate(type) {
         type(this);
         if (!this.isValid && parent) {
-          parent.issueDepth = this.issueDepth + 1;
+          parent.issueDepth = this.issueDepth + depthOffset;
         }
       },
       withIssues(issues2) {
-        return createContext(issues2, this.value, this.path, this);
+        return createContext(issues2, this.value, this.path, this, 0);
       },
       withKey(key) {
         return createContext(issues, this.value[key], this.path.concat(key), this);
@@ -868,21 +868,7 @@ ${issueStrings}`);
   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) {
+  function makeOptional(type, value) {
     const validate = function validateOptional(context) {
       if (context.value === void 0) {
         return;
@@ -891,14 +877,16 @@ ${issueStrings}`);
     };
     validate[optionalSymbol] = true;
     validate[innerTypeSymbol] = type;
+    if (value !== void 0) {
+      validate[defaultSymbol] = typeof value === "function" ? value : () => value;
+    }
     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);
+    validate.optional = (value) => makeOptional(validate, value);
     return validate;
   }
   function applyDefaults(value, type) {
@@ -1068,7 +1056,7 @@ ${issueStrings}`);
     const missingKeys = [];
     for (const key of keys) {
       if (context.value[key] === void 0) {
-        if (!isOptionalType(shape[key]) && !hasDefaultValue(shape[key])) {
+        if (!isOptionalType(shape[key])) {
           missingKeys.push(key);
         }
         continue;
@@ -1080,8 +1068,7 @@ ${issueStrings}`);
     if (missingKeys.length) {
       context.addIssue({
         message: "object value has missing keys",
-        missingKeys,
-        expectedKeys: keys
+        missingKeys
       });
     }
     if (isStrict) {
@@ -1094,8 +1081,7 @@ ${issueStrings}`);
       if (unknownKeys.length) {
         context.addIssue({
           message: "object value has unknown keys",
-          unknownKeys,
-          expectedKeys: keys
+          unknownKeys
         });
       }
     }
@@ -1543,7 +1529,7 @@ ${issueStrings}`);
   }
 
   // ../owl-runtime/dist/owl-runtime.es.js
-  var version = "3.0.0-alpha.35";
+  var version = "3.0.0-alpha.37";
   var fibersInError = /* @__PURE__ */ new WeakMap();
   var nodeErrorHandlers = /* @__PURE__ */ new WeakMap();
   function invokeErrorHandlers(node, error, finalize, markFibers) {
@@ -3439,6 +3425,11 @@ ${issueStrings}`);
     willPatch = [];
     patched = [];
     signalComputation;
+    // t-ref signals bound to an element hosted by this component, mapped to their
+    // atom (so the element can be read without subscribing). Swept by isConnected
+    // after each patch and after this subtree is removed, to unset a ref pointing
+    // at a bulk-removed element (slot host, enclosing t-if) — see sweepRefs.
+    trackedRefs = null;
     constructor(C, props2, app, parent, parentKey) {
       super(app);
       this.parent = parent;
@@ -3547,9 +3538,15 @@ ${issueStrings}`);
     }
     destroy() {
       let shouldRemove = this.status === STATUS.MOUNTED;
-      this._destroy();
+      removalDepth++;
+      try {
+        this._destroy();
+      } finally {
+        removalDepth--;
+      }
       if (shouldRemove) {
         this.bdom.remove();
+        sweepRemovedRefs();
       }
     }
     _destroy() {
@@ -3559,12 +3556,42 @@ ${issueStrings}`);
           cb.call(component);
         }
       }
+      if (removalDepth && this.trackedRefs) {
+        (removed ||= []).push(this);
+      }
       for (let childKey in this.children) {
         this.children[childKey]._destroy();
       }
       this.finalize((e) => handleError({ error: e, node: this }));
       disposeComputation(this.signalComputation);
     }
+    /**
+     * 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() {
+      const refs = this.trackedRefs;
+      if (!refs) {
+        return;
+      }
+      for (const [ref2, atom] of refs) {
+        const el = atom.value;
+        if (!el) {
+          refs.delete(ref2);
+        } else if (!el.isConnected) {
+          ref2.set(null);
+          refs.delete(ref2);
+        }
+      }
+    }
     /**
      * 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
@@ -3580,7 +3607,14 @@ ${issueStrings}`);
           child.updateDom();
         }
       } else {
-        this.bdom.patch(this.fiber.bdom, false);
+        removalDepth++;
+        try {
+          this.bdom.patch(this.fiber.bdom, false);
+        } finally {
+          removalDepth--;
+        }
+        this.sweepRefs();
+        sweepRemovedRefs();
         this.fiber.appliedToDom = true;
         this.fiber = null;
       }
@@ -3607,6 +3641,14 @@ ${issueStrings}`);
     moveBeforeVNode(other, afterNode) {
       this.bdom.moveBeforeVNode(other ? other.bdom : null, afterNode);
     }
+    /**
+     * 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(ref2, atom) {
+      (this.trackedRefs ||= /* @__PURE__ */ new Map()).set(ref2, atom);
+    }
     patch() {
       if (this.fiber && this.fiber.parent) {
         this._patch();
@@ -3620,7 +3662,14 @@ ${issueStrings}`);
       }
       const fiber = this.fiber;
       this.children = fiber.childrenMap;
-      this.bdom.patch(fiber.bdom, hasChildren);
+      removalDepth++;
+      try {
+        this.bdom.patch(fiber.bdom, hasChildren);
+      } finally {
+        removalDepth--;
+      }
+      this.sweepRefs();
+      sweepRemovedRefs();
       fiber.appliedToDom = true;
       this.fiber = null;
     }
@@ -3631,6 +3680,17 @@ ${issueStrings}`);
       this.bdom.remove();
     }
   };
+  var removalDepth = 0;
+  var removed = null;
+  function sweepRemovedRefs() {
+    if (removalDepth === 0 && removed) {
+      const nodes = removed;
+      removed = null;
+      for (let i = 0; i < nodes.length; i++) {
+        nodes[i].sweepRefs();
+      }
+    }
+  }
   function getComponentScope() {
     const scope = useScope();
     if (!(scope instanceof ComponentNode)) {
@@ -3734,7 +3794,7 @@ ${issueStrings}`);
     }
   };
   var ObjectCreate = Object.create;
-  function withDefault2(value, defaultValue) {
+  function withDefault(value, defaultValue) {
     return value === void 0 || value === null || value === false ? defaultValue : value;
   }
   function callSlot(ctx, parent, key, name, dynamic, extra, defaultContent) {
@@ -3833,7 +3893,7 @@ ${issueStrings}`);
     }
     return toggler(safeKey, block);
   }
-  function createRef(ref2) {
+  function createRef(ref2, node) {
     if (!ref2) {
       throw new OwlError(`Ref is undefined or null`);
     }
@@ -3848,6 +3908,9 @@ ${issueStrings}`);
       remove2 = atom ? (prevEl) => {
         if (atom.value === prevEl) ref2.set(null);
       } : () => ref2.set(null);
+      if (atom) {
+        node.trackRef(ref2, atom);
+      }
     } else {
       throw new OwlError(
         `Ref should implement either a 'set' function or 'add' and 'delete' functions`
@@ -4020,7 +4083,7 @@ ${issueStrings}`);
     return toggler(subTemplate, template.call(owner, ctx, parent, key + subTemplate));
   }
   var helpers = {
-    withDefault: withDefault2,
+    withDefault,
     zero: /* @__PURE__ */ Symbol("zero"),
     callSlot,
     withKey,
@@ -4482,7 +4545,7 @@ ${issueStrings}`);
       <t t-call-slot="default"/>
     </t>
   `;
-    props = props({ error: types2.signal().default(() => signal(null)) });
+    props = props({ error: types2.signal().optional(() => signal(null)) });
     setup() {
       onError((e) => this.props.error.set(e));
     }
@@ -4599,8 +4662,8 @@ ${issueStrings}`);
   };
   var __info__ = {
     version: App.version,
-    date: "2026-06-11T09:51:14.980Z",
-    hash: "739fc964",
+    date: "2026-06-19T13:15:04.793Z",
+    hash: "18550141",
     url: "https://github.com/odoo/owl"
   };
 
@@ -6131,7 +6194,7 @@ ${code}`;
       if (ast.ref) {
         const refExpr = compileExpr(ast.ref);
         this.helpers.add("createRef");
-        const setRefStr = `createRef(${refExpr})`;
+        const setRefStr = `createRef(${refExpr}, node)`;
         const idx = block.insertData(setRefStr, "ref");
         attrs["block-ref"] = String(idx);
       }