@odoo/owl 3.0.0-alpha.22 → 3.0.0-alpha.24

package/dist/owl.iife.js

@@ -2003,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.
@@ -2059,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) {
@@ -2183,13 +2176,9 @@
                 current = current.parent;
             }
             // there are no current rendering from above => we can render
-            this._render();
-        }
-        _render() {
             const node = this.node;
             const root = this.root;
             if (root) {
-                // todo: should use updateComputation somewhere else.
                 const c = getCurrentComputation();
                 removeSources(node.signalComputation);
                 setComputation(node.signalComputation);
@@ -2198,10 +2187,14 @@
                     this.bdom = node.renderFn();
                 }
                 catch (e) {
-                    node.app.handleError({ node, error: e });
+                    handleError({ node, error: e });
                 }
                 setComputation(c);
-                root.setCounter(root.counter - 1);
+                const newCounter = root.counter - 1;
+                root.counter = newCounter;
+                if (newCounter === 0) {
+                    this.node.app.scheduler.flush();
+                }
             }
         }
     }
@@ -2268,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) {
@@ -2324,7 +2317,7 @@
                 }
             }
             catch (e) {
-                this.node.app.handleError({ fiber: current, error: e });
+                handleError({ fiber: current, error: e });
             }
         }
     }
@@ -2402,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) {
@@ -2492,7 +2485,7 @@
                     }
                 }
                 catch (e) {
-                    this.app.handleError({ error: e, node: this });
+                    handleError({ error: e, node: this });
                 }
             }
             for (const computation of this.computations) {
@@ -3211,7 +3204,17 @@
                 }
                 node = new ComponentNode(C, props, app, ctx, key);
                 children[key] = node;
-                initiateRender.call(node, new Fiber(node, parentFiber));
+                const fiber = new Fiber(node, parentFiber);
+                if (node.willStart.length) {
+                    initiateRender.call(node, fiber);
+                }
+                else {
+                    node.fiber = fiber;
+                    if (node.mounted.length) {
+                        fiber.root.mounted.push(fiber);
+                    }
+                    fiber.render();
+                }
             }
             parentFiber.childrenMap[key] = node;
             return node;
@@ -3882,6 +3885,9 @@
             this.dev = options.dev || false;
             this.ast = ast;
             this.templateName = options.name;
+            if (options.name && !options.name.startsWith("__")) {
+                this.target.name = `template_${options.name.replace(/\./g, "_")}`;
+            }
             if (options.hasGlobalValues) {
                 this.helpers.add("__globals__");
             }
@@ -5675,7 +5681,7 @@
     }
 
     // do not modify manually. This file is generated by the release script.
-    const version = "3.0.0-alpha.22";
+    const version = "3.0.0-alpha.24";
 
     function effect(fn) {
         const computation = createComputation(() => {
@@ -5835,6 +5841,7 @@
         processing = false;
         constructor() {
             this.requestAnimationFrame = Scheduler.requestAnimationFrame;
+            this.processTasks = this.processTasks.bind(this);
         }
         addFiber(fiber) {
             this.tasks.add(fiber.root);
@@ -5842,7 +5849,7 @@
         scheduleDestroy(node) {
             this.cancelledNodes.add(node);
             if (this.frame === 0) {
-                this.frame = this.requestAnimationFrame(() => this.processTasks());
+                this.frame = this.requestAnimationFrame(this.processTasks);
             }
         }
         /**
@@ -5860,7 +5867,7 @@
                 }
             }
             if (this.frame === 0) {
-                this.frame = this.requestAnimationFrame(() => this.processTasks());
+                this.frame = this.requestAnimationFrame(this.processTasks);
             }
         }
         processTasks() {
@@ -5873,8 +5880,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 */) {
@@ -5883,34 +5915,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;
@@ -6010,8 +6014,8 @@
             this.scheduler.processTasks();
             apps.delete(this);
         }
-        handleError(...args) {
-            return handleError(...args);
+        _handleError(error) {
+            throw error;
         }
     }
     async function mount(C, target, config = {}) {
@@ -6069,14 +6073,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](...args) {
+                    return f.call(component, ...args);
+                },
+            };
+            return wrapper[name];
         }
-        return result;
+        return f.bind(node.component);
     }
     function onWillStart(fn) {
         const { node } = getContext("component");
@@ -6334,22 +6344,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)) {
@@ -6540,6 +6558,9 @@
             }
         };
     }
+    function componentType() {
+        return constructorType(Component);
+    }
     function ref(type) {
         return union([literalType(null), instanceType(type)]);
     }
@@ -6548,6 +6569,7 @@
         any: anyType,
         array: arrayType,
         boolean: booleanType,
+        component: componentType,
         constructor: constructorType,
         customValidator: customValidator,
         function: functionType,
@@ -6816,8 +6838,8 @@
     exports.xml = xml;
 
 
-    __info__.date = '2026-04-08T13:31:02.500Z';
-    __info__.hash = '2e9164e';
+    __info__.date = '2026-04-10T09:24:05.169Z';
+    __info__.hash = 'd325807';
     __info__.url = 'https://github.com/odoo/owl';