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

package/dist/compile_templates.mjs

@@ -554,6 +554,9 @@ class CodeGenerator {
         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__");
         }

package/dist/owl.cjs.js

@@ -2002,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.
@@ -2058,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) {
@@ -2182,13 +2175,9 @@ class Fiber {
             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);
@@ -2197,10 +2186,14 @@ 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);
+            const newCounter = root.counter - 1;
+            root.counter = newCounter;
+            if (newCounter === 0) {
+                this.node.app.scheduler.flush();
+            }
         }
     }
 }
@@ -2267,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) {
@@ -2323,7 +2316,7 @@ class MountFiber extends RootFiber {
             }
         }
         catch (e) {
-            this.node.app.handleError({ fiber: current, error: e });
+            handleError({ fiber: current, error: e });
         }
     }
 }
@@ -2401,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) {
@@ -2491,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) {
@@ -3210,7 +3203,17 @@ function createComponent(app, name, isStatic, hasSlotsProp, hasDynamicPropList,
             }
             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;
@@ -3881,6 +3884,9 @@ class CodeGenerator {
         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__");
         }
@@ -5674,7 +5680,7 @@ function compile(template, options = {
 }
 
 // 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(() => {
@@ -5834,6 +5840,7 @@ class Scheduler {
     processing = false;
     constructor() {
         this.requestAnimationFrame = Scheduler.requestAnimationFrame;
+        this.processTasks = this.processTasks.bind(this);
     }
     addFiber(fiber) {
         this.tasks.add(fiber.root);
@@ -5841,7 +5848,7 @@ class Scheduler {
     scheduleDestroy(node) {
         this.cancelledNodes.add(node);
         if (this.frame === 0) {
-            this.frame = this.requestAnimationFrame(() => this.processTasks());
+            this.frame = this.requestAnimationFrame(this.processTasks);
         }
     }
     /**
@@ -5859,7 +5866,7 @@ class Scheduler {
             }
         }
         if (this.frame === 0) {
-            this.frame = this.requestAnimationFrame(() => this.processTasks());
+            this.frame = this.requestAnimationFrame(this.processTasks);
         }
     }
     processTasks() {
@@ -5872,8 +5879,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 */) {
@@ -5882,34 +5914,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;
@@ -6009,8 +6013,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 = {}) {
@@ -6068,14 +6072,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](...args) {
+                return f.call(component, ...args);
+            },
+        };
+        return wrapper[name];
     }
-    return result;
+    return f.bind(node.component);
 }
 function onWillStart(fn) {
     const { node } = getContext("component");
@@ -6333,22 +6343,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)) {
@@ -6539,6 +6557,9 @@ function reactiveValueType(type) {
         }
     };
 }
+function componentType() {
+    return constructorType(Component);
+}
 function ref(type) {
     return union([literalType(null), instanceType(type)]);
 }
@@ -6547,6 +6568,7 @@ const types = {
     any: anyType,
     array: arrayType,
     boolean: booleanType,
+    component: componentType,
     constructor: constructorType,
     customValidator: customValidator,
     function: functionType,
@@ -6815,6 +6837,6 @@ exports.whenReady = whenReady;
 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';