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

package/dist/owl.cjs.js

@@ -284,31 +284,6 @@ function toClassObj(expr) {
             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
 // ---------------------------------------------------------------------------
@@ -341,7 +316,7 @@ function toStyleObj(expr) {
                 }
                 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;
                 }
             }
@@ -359,6 +334,32 @@ function toStyleObj(expr) {
             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;
@@ -370,18 +371,19 @@ function updateStyle(val, oldVal) {
     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");
+    }
 }
 
 /**
@@ -2000,51 +2002,11 @@ function untrack(fn) {
 // 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.
@@ -2056,10 +2018,43 @@ function handleError(params) {
         } 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) {
@@ -2195,7 +2190,7 @@ class Fiber {
                 this.bdom = node.renderFn();
             }
             catch (e) {
-                node.app.handleError({ node, error: e });
+                handleError({ node, error: e });
             }
             setComputation(c);
             root.setCounter(root.counter - 1);
@@ -2265,7 +2260,7 @@ class RootFiber extends Fiber {
                 fiber.node.willUnmount = [];
             }
             this.locked = false;
-            node.app.handleError({ fiber: current || this, error: e });
+            handleError({ fiber: current || this, error: e });
         }
     }
     setCounter(newValue) {
@@ -2321,7 +2316,7 @@ class MountFiber extends RootFiber {
             }
         }
         catch (e) {
-            this.node.app.handleError({ fiber: current, error: e });
+            handleError({ fiber: current, error: e });
         }
     }
 }
@@ -2399,7 +2394,7 @@ class ComponentNode {
             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) {
@@ -2489,7 +2484,7 @@ class ComponentNode {
                 }
             }
             catch (e) {
-                this.app.handleError({ error: e, node: this });
+                handleError({ error: e, node: this });
             }
         }
         for (const computation of this.computations) {
@@ -5672,7 +5667,7 @@ function compile(template, options = {
 }
 
 // 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(() => {
@@ -5870,8 +5865,33 @@ class Scheduler {
             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 */) {
@@ -5880,34 +5900,6 @@ class Scheduler {
         }
         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;
@@ -6007,8 +5999,8 @@ class App extends TemplateSet {
         this.scheduler.processTasks();
         apps.delete(this);
     }
-    handleError(...args) {
-        return handleError(...args);
+    _handleError(error) {
+        throw error;
     }
 }
 async function mount(C, target, config = {}) {
@@ -6066,14 +6058,20 @@ const mainEventHandler = (data, ev, currentTarget) => {
 //  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");
@@ -6331,22 +6329,30 @@ class Registry {
     }
 }
 
-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)) {
@@ -6537,6 +6543,9 @@ function reactiveValueType(type) {
         }
     };
 }
+function componentType() {
+    return constructorType(Component);
+}
 function ref(type) {
     return union([literalType(null), instanceType(type)]);
 }
@@ -6545,6 +6554,7 @@ const types = {
     any: anyType,
     array: arrayType,
     boolean: booleanType,
+    component: componentType,
     constructor: constructorType,
     customValidator: customValidator,
     function: functionType,
@@ -6813,6 +6823,6 @@ exports.whenReady = whenReady;
 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';