@odoo/owl 3.0.0-alpha.21 → 3.0.0-alpha.23

package/dist/owl.iife.js

@@ -285,31 +285,6 @@
                 return { [expr]: true };
         }
     }
-    function setClass(val) {
-        val = val === "" ? {} : toClassObj(val);
-        // add classes
-        const cl = this.classList;
-        for (let c in val) {
-            tokenListAdd.call(cl, c);
-        }
-    }
-    function updateClass(val, oldVal) {
-        oldVal = oldVal === "" ? {} : toClassObj(oldVal);
-        val = val === "" ? {} : toClassObj(val);
-        const cl = this.classList;
-        // remove classes
-        for (let c in oldVal) {
-            if (!(c in val)) {
-                tokenListRemove.call(cl, c);
-            }
-        }
-        // add classes
-        for (let c in val) {
-            if (!(c in oldVal)) {
-                tokenListAdd.call(cl, c);
-            }
-        }
-    }
     // ---------------------------------------------------------------------------
     // Style
     // ---------------------------------------------------------------------------
@@ -342,7 +317,7 @@
                     }
                     const prop = trim.call(part.slice(0, colonIdx));
                     const value = trim.call(part.slice(colonIdx + 1));
-                    if (prop && value) {
+                    if (prop && value && value !== "undefined") {
                         result[prop] = value;
                     }
                 }
@@ -360,6 +335,32 @@
                 return {};
         }
     }
+    // ---------------------------------------------------------------------------
+    // Class
+    // ---------------------------------------------------------------------------
+    function setClass(val) {
+        val = val === "" ? {} : toClassObj(val);
+        for (let k in val) {
+            tokenListAdd.call(this.classList, k);
+        }
+    }
+    function updateClass(val, oldVal) {
+        oldVal = oldVal === "" ? {} : toClassObj(oldVal);
+        val = val === "" ? {} : toClassObj(val);
+        for (let k in oldVal) {
+            if (!(k in val)) {
+                tokenListRemove.call(this.classList, k);
+            }
+        }
+        for (let k in val) {
+            if (val[k] !== oldVal[k]) {
+                tokenListAdd.call(this.classList, k);
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Style setters
+    // ---------------------------------------------------------------------------
     function setStyle(val) {
         val = val === "" ? {} : toStyleObj(val);
         const style = this.style;
@@ -371,18 +372,19 @@
         oldVal = oldVal === "" ? {} : toStyleObj(oldVal);
         val = val === "" ? {} : toStyleObj(val);
         const style = this.style;
-        // remove old styles
         for (let prop in oldVal) {
             if (!(prop in val)) {
                 style.removeProperty(prop);
             }
         }
-        // set new/changed styles
         for (let prop in val) {
             if (val[prop] !== oldVal[prop]) {
                 style.setProperty(prop, val[prop]);
             }
         }
+        if (!style.cssText) {
+            removeAttribute.call(this, "style");
+        }
     }
 
     /**
@@ -2001,51 +2003,11 @@
     // Maps fibers to thrown errors
     const fibersInError = new WeakMap();
     const nodeErrorHandlers = new WeakMap();
-    function destroyApp(app, error) {
-        try {
-            app.destroy();
-        }
-        catch (e) {
-            // mute all errors here because we are in a corrupted state anyway
-        }
-        const e = Object.assign(new OwlError(`[Owl] Unhandled error. Destroying the root component`), {
-            cause: error,
-        });
-        return e;
-    }
-    function _handleError(node, error) {
-        if (!node) {
-            return false;
-        }
-        const fiber = node.fiber;
-        if (fiber) {
-            fibersInError.set(fiber, error);
-        }
-        const errorHandlers = nodeErrorHandlers.get(node);
-        if (errorHandlers) {
-            let handled = false;
-            // execute in the opposite order
-            const finalize = () => destroyApp(node.app, error);
-            for (let i = errorHandlers.length - 1; i >= 0; i--) {
-                try {
-                    errorHandlers[i](error, finalize);
-                    handled = true;
-                    break;
-                }
-                catch (e) {
-                    error = e;
-                }
-            }
-            if (handled) {
-                return true;
-            }
-        }
-        return _handleError(node.parent, error);
-    }
     function handleError(params) {
         let { error } = params;
-        const node = "node" in params ? params.node : params.fiber.node;
+        let node = "node" in params ? params.node : params.fiber.node;
         const fiber = "fiber" in params ? params.fiber : node.fiber;
+        const app = node.app;
         if (fiber) {
             // resets the fibers on components if possible. This is important so that
             // new renderings can be properly included in the initial one, if any.
@@ -2057,10 +2019,43 @@
             } while (current);
             fibersInError.set(fiber.root, error);
         }
-        const handled = _handleError(node, error);
-        if (!handled) {
-            throw destroyApp(node.app, error);
+        const finalize = () => {
+            try {
+                app.destroy();
+            }
+            catch (e) {
+                // mute all errors here because we are in a corrupted state anyway
+            }
+            return Object.assign(new OwlError(`[Owl] Unhandled error. Destroying the root component`), {
+                cause: error,
+            });
+        };
+        // Walk up the component tree looking for error handlers
+        while (node) {
+            const nodeFiber = node.fiber;
+            if (nodeFiber) {
+                fibersInError.set(nodeFiber, error);
+            }
+            const errorHandlers = nodeErrorHandlers.get(node);
+            if (errorHandlers) {
+                // execute in the opposite order
+                for (let i = errorHandlers.length - 1; i >= 0; i--) {
+                    try {
+                        errorHandlers[i](error, finalize);
+                        return; // handled
+                    }
+                    catch (e) {
+                        error = e;
+                    }
+                }
+            }
+            node = node.parent;
         }
+        // No handler found — create the OwlError, then let the app handle it.
+        // app._handleError is called after error creation, so it doesn't appear
+        // in the error's .stack property.
+        const owlError = finalize();
+        app._handleError(owlError);
     }
 
     function makeChildFiber(node, parent) {
@@ -2196,7 +2191,7 @@
                     this.bdom = node.renderFn();
                 }
                 catch (e) {
-                    node.app.handleError({ node, error: e });
+                    handleError({ node, error: e });
                 }
                 setComputation(c);
                 root.setCounter(root.counter - 1);
@@ -2266,7 +2261,7 @@
                     fiber.node.willUnmount = [];
                 }
                 this.locked = false;
-                node.app.handleError({ fiber: current || this, error: e });
+                handleError({ fiber: current || this, error: e });
             }
         }
         setCounter(newValue) {
@@ -2322,7 +2317,7 @@
                 }
             }
             catch (e) {
-                this.node.app.handleError({ fiber: current, error: e });
+                handleError({ fiber: current, error: e });
             }
         }
     }
@@ -2400,7 +2395,7 @@
                 await Promise.all(promises);
             }
             catch (e) {
-                this.app.handleError({ node: this, error: e });
+                handleError({ node: this, error: e });
                 return;
             }
             if (this.status === 0 /* STATUS.NEW */ && this.fiber === fiber) {
@@ -2490,7 +2485,7 @@
                     }
                 }
                 catch (e) {
-                    this.app.handleError({ error: e, node: this });
+                    handleError({ error: e, node: this });
                 }
             }
             for (const computation of this.computations) {
@@ -5673,7 +5668,7 @@
     }
 
     // do not modify manually. This file is generated by the release script.
-    const version = "3.0.0-alpha.21";
+    const version = "3.0.0-alpha.23";
 
     function effect(fn) {
         const computation = createComputation(() => {
@@ -5871,8 +5866,33 @@
                 node._destroy();
             }
             this.cancelledNodes.clear();
-            for (let task of this.tasks) {
-                this.processFiber(task);
+            for (let fiber of this.tasks) {
+                if (fiber.root !== fiber) {
+                    this.tasks.delete(fiber);
+                    continue;
+                }
+                const hasError = fibersInError.has(fiber);
+                if (hasError && fiber.counter !== 0) {
+                    this.tasks.delete(fiber);
+                    continue;
+                }
+                if (fiber.node.status === 3 /* STATUS.DESTROYED */) {
+                    this.tasks.delete(fiber);
+                    continue;
+                }
+                if (fiber.counter === 0) {
+                    if (!hasError) {
+                        fiber.complete();
+                    }
+                    // at this point, the fiber should have been applied to the DOM, so we can
+                    // remove it from the task list. If it is not the case, it means that there
+                    // was an error and an error handler triggered a new rendering that recycled
+                    // the fiber, so in that case, we actually want to keep the fiber around,
+                    // otherwise it will just be ignored.
+                    if (fiber.appliedToDom) {
+                        this.tasks.delete(fiber);
+                    }
+                }
             }
             for (let task of this.tasks) {
                 if (task.node.status === 3 /* STATUS.DESTROYED */) {
@@ -5881,34 +5901,6 @@
             }
             this.processing = false;
         }
-        processFiber(fiber) {
-            if (fiber.root !== fiber) {
-                this.tasks.delete(fiber);
-                return;
-            }
-            const hasError = fibersInError.has(fiber);
-            if (hasError && fiber.counter !== 0) {
-                this.tasks.delete(fiber);
-                return;
-            }
-            if (fiber.node.status === 3 /* STATUS.DESTROYED */) {
-                this.tasks.delete(fiber);
-                return;
-            }
-            if (fiber.counter === 0) {
-                if (!hasError) {
-                    fiber.complete();
-                }
-                // at this point, the fiber should have been applied to the DOM, so we can
-                // remove it from the task list. If it is not the case, it means that there
-                // was an error and an error handler triggered a new rendering that recycled
-                // the fiber, so in that case, we actually want to keep the fiber around,
-                // otherwise it will just be ignored.
-                if (fiber.appliedToDom) {
-                    this.tasks.delete(fiber);
-                }
-            }
-        }
     }
 
     let hasBeenLogged = false;
@@ -6008,8 +6000,8 @@
             this.scheduler.processTasks();
             apps.delete(this);
         }
-        handleError(...args) {
-            return handleError(...args);
+        _handleError(error) {
+            throw error;
         }
     }
     async function mount(C, target, config = {}) {
@@ -6067,14 +6059,20 @@
     //  hooks
     // -----------------------------------------------------------------------------
     function decorate(node, f, hookName) {
-        const result = f.bind(node.component);
         if (node.app.dev) {
-            const suffix = f.name ? ` <${f.name}>` : "";
-            Reflect.defineProperty(result, "name", {
-                value: hookName + suffix,
-            });
+            const component = node.component;
+            const componentName = component ? component.constructor.name : "Component";
+            const name = `${componentName}.${hookName}`;
+            // Create a named wrapper so the name appears in stack traces.
+            // V8 uses computed property keys as inferred function names.
+            const wrapper = {
+                [name]() {
+                    return f.call(component);
+                },
+            };
+            return wrapper[name];
         }
-        return result;
+        return f.bind(node.component);
     }
     function onWillStart(fn) {
         const { node } = getContext("component");
@@ -6332,22 +6330,30 @@
         }
     }
 
-    const anyType = function validateAny() { };
-    const booleanType = function validateBoolean(context) {
-        if (typeof context.value !== "boolean") {
-            context.addIssue({ message: "value is not a boolean" });
-        }
-    };
-    const numberType = function validateNumber(context) {
-        if (typeof context.value !== "number") {
-            context.addIssue({ message: "value is not a number" });
-        }
-    };
-    const stringType = function validateString(context) {
-        if (typeof context.value !== "string") {
-            context.addIssue({ message: "value is not a string" });
-        }
-    };
+    function anyType() {
+        return function validateAny() { };
+    }
+    function booleanType() {
+        return function validateBoolean(context) {
+            if (typeof context.value !== "boolean") {
+                context.addIssue({ message: "value is not a boolean" });
+            }
+        };
+    }
+    function numberType() {
+        return function validateNumber(context) {
+            if (typeof context.value !== "number") {
+                context.addIssue({ message: "value is not a number" });
+            }
+        };
+    }
+    function stringType() {
+        return function validateString(context) {
+            if (typeof context.value !== "string") {
+                context.addIssue({ message: "value is not a string" });
+            }
+        };
+    }
     function arrayType(elementType) {
         return function validateArray(context) {
             if (!Array.isArray(context.value)) {
@@ -6538,6 +6544,9 @@
             }
         };
     }
+    function componentType() {
+        return constructorType(Component);
+    }
     function ref(type) {
         return union([literalType(null), instanceType(type)]);
     }
@@ -6546,6 +6555,7 @@
         any: anyType,
         array: arrayType,
         boolean: booleanType,
+        component: componentType,
         constructor: constructorType,
         customValidator: customValidator,
         function: functionType,
@@ -6814,8 +6824,8 @@
     exports.xml = xml;
 
 
-    __info__.date = '2026-04-02T11:14:58.432Z';
-    __info__.hash = '9ca35d8';
+    __info__.date = '2026-04-10T07:28:23.029Z';
+    __info__.hash = 'e5e6d92';
     __info__.url = 'https://github.com/odoo/owl';