@odoo/owl 2.8.1 → 3.0.0-alpha.1

package/dist/owl.es.js

@@ -1592,6 +1592,14 @@ function remove(vnode, withBeforeRemove = false) {
     vnode.remove();
 }
 
+// Reactivity system
+var ComputationState;
+(function (ComputationState) {
+    ComputationState[ComputationState["EXECUTED"] = 0] = "EXECUTED";
+    ComputationState[ComputationState["STALE"] = 1] = "STALE";
+    ComputationState[ComputationState["PENDING"] = 2] = "PENDING";
+})(ComputationState || (ComputationState = {}));
+
 // Maps fibers to thrown errors
 const fibersInError = new WeakMap();
 const nodeErrorHandlers = new WeakMap();
@@ -1654,6 +1662,233 @@ function handleError(params) {
     }
 }
 
+let Effects;
+let CurrentComputation;
+function signal(value, opts) {
+    const atom = {
+        value,
+        observers: new Set(),
+        name: opts === null || opts === void 0 ? void 0 : opts.name,
+    };
+    const read = () => {
+        onReadAtom(atom);
+        return atom.value;
+    };
+    const write = (newValue) => {
+        if (typeof newValue === "function") {
+            newValue = newValue(atom.value);
+        }
+        if (Object.is(atom.value, newValue))
+            return;
+        atom.value = newValue;
+        onWriteAtom(atom);
+    };
+    return {
+        get: read,
+        set: write,
+    };
+}
+function effect(fn, opts) {
+    var _a, _b;
+    const effectComputation = {
+        state: ComputationState.STALE,
+        value: undefined,
+        compute() {
+            // In case the cleanup read an atom.
+            // todo: test it
+            CurrentComputation = undefined;
+            // `removeSources` is made by `runComputation`.
+            unsubscribeEffect(effectComputation);
+            CurrentComputation = effectComputation;
+            return fn();
+        },
+        sources: new Set(),
+        childrenEffect: [],
+        name: opts === null || opts === void 0 ? void 0 : opts.name,
+    };
+    (_b = (_a = CurrentComputation === null || CurrentComputation === void 0 ? void 0 : CurrentComputation.childrenEffect) === null || _a === void 0 ? void 0 : _a.push) === null || _b === void 0 ? void 0 : _b.call(_a, effectComputation);
+    updateComputation(effectComputation);
+    // Remove sources and unsubscribe
+    return () => {
+        // In case the cleanup read an atom.
+        // todo: test it
+        const previousComputation = CurrentComputation;
+        CurrentComputation = undefined;
+        unsubscribeEffect(effectComputation);
+        CurrentComputation = previousComputation;
+    };
+}
+// export function computed<T>(fn: () => T, opts?: Opts) {
+//   // todo: handle cleanup
+//   let computedComputation: Computation = {
+//     state: ComputationState.STALE,
+//     sources: new Set(),
+//     isEager: true,
+//     compute: () => {
+//       return fn();
+//     },
+//     value: undefined,
+//     name: opts?.name,
+//   };
+//   updateComputation(computedComputation);
+// }
+function derived(fn, opts) {
+    // todo: handle cleanup
+    let derivedComputation;
+    return () => {
+        derivedComputation !== null && derivedComputation !== void 0 ? derivedComputation : (derivedComputation = {
+            state: ComputationState.STALE,
+            sources: new Set(),
+            compute: () => {
+                onWriteAtom(derivedComputation);
+                return fn();
+            },
+            isDerived: true,
+            value: undefined,
+            observers: new Set(),
+            name: opts === null || opts === void 0 ? void 0 : opts.name,
+        });
+        updateComputation(derivedComputation);
+        return derivedComputation.value;
+    };
+}
+function onReadAtom(atom) {
+    if (!CurrentComputation)
+        return;
+    CurrentComputation.sources.add(atom);
+    atom.observers.add(CurrentComputation);
+}
+function onWriteAtom(atom) {
+    collectEffects(() => {
+        for (const ctx of atom.observers) {
+            if (ctx.state === ComputationState.EXECUTED) {
+                if (ctx.isDerived)
+                    markDownstream(ctx);
+                else
+                    Effects.push(ctx);
+            }
+            ctx.state = ComputationState.STALE;
+        }
+    });
+    batchProcessEffects();
+}
+function collectEffects(fn) {
+    if (Effects)
+        return fn();
+    Effects = [];
+    try {
+        return fn();
+    }
+    finally {
+    }
+}
+const batchProcessEffects = batched(processEffects);
+function processEffects() {
+    if (!Effects)
+        return;
+    for (const computation of Effects) {
+        updateComputation(computation);
+    }
+    Effects = undefined;
+}
+function withoutReactivity(fn) {
+    return runWithComputation(undefined, fn);
+}
+function getCurrentComputation() {
+    return CurrentComputation;
+}
+function setComputation(computation) {
+    CurrentComputation = computation;
+}
+// todo: should probably use updateComputation instead.
+function runWithComputation(computation, fn) {
+    const previousComputation = CurrentComputation;
+    CurrentComputation = computation;
+    let result;
+    try {
+        result = fn();
+    }
+    finally {
+        CurrentComputation = previousComputation;
+    }
+    return result;
+}
+function updateComputation(computation) {
+    var _a;
+    const state = computation.state;
+    if (computation.isDerived)
+        onReadAtom(computation);
+    if (state === ComputationState.EXECUTED)
+        return;
+    if (state === ComputationState.PENDING) {
+        computeSources(computation);
+        // If the state is still not stale after processing the sources, it means
+        // none of the dependencies have changed.
+        // todo: test it
+        if (computation.state !== ComputationState.STALE) {
+            computation.state = ComputationState.EXECUTED;
+            return;
+        }
+    }
+    // todo: test performance. We might want to avoid removing the atoms to
+    // directly re-add them at compute. Especially as we are making them stale.
+    removeSources(computation);
+    const previousComputation = CurrentComputation;
+    CurrentComputation = computation;
+    computation.value = (_a = computation.compute) === null || _a === void 0 ? void 0 : _a.call(computation);
+    computation.state = ComputationState.EXECUTED;
+    CurrentComputation = previousComputation;
+}
+function removeSources(computation) {
+    const sources = computation.sources;
+    for (const source of sources) {
+        const observers = source.observers;
+        observers.delete(computation);
+        // todo: if source has no effect observer anymore, remove its sources too
+        // todo: test it
+    }
+    sources.clear();
+}
+function unsubscribeEffect(effectComputation) {
+    removeSources(effectComputation);
+    cleanupEffect(effectComputation);
+    for (const children of effectComputation.childrenEffect) {
+        // Consider it executed to avoid it's re-execution
+        // todo: make a test for it
+        children.state = ComputationState.EXECUTED;
+        removeSources(children);
+        unsubscribeEffect(children);
+    }
+    effectComputation.childrenEffect.length = 0;
+}
+function cleanupEffect(computation) {
+    // the computation.value of an effect is a cleanup function
+    const cleanupFn = computation.value;
+    if (cleanupFn && typeof cleanupFn === "function") {
+        cleanupFn();
+        computation.value = undefined;
+    }
+}
+function markDownstream(derived) {
+    for (const observer of derived.observers) {
+        // if the state has already been marked, skip it
+        if (observer.state)
+            continue;
+        observer.state = ComputationState.PENDING;
+        if (observer.isDerived)
+            markDownstream(observer);
+        else
+            Effects.push(observer);
+    }
+}
+function computeSources(derived) {
+    for (const source of derived.sources) {
+        if (!("compute" in source))
+            continue;
+        updateComputation(source);
+    }
+}
+
 function makeChildFiber(node, parent) {
     let current = node.fiber;
     if (current) {
@@ -1775,13 +2010,16 @@ class Fiber {
         const node = this.node;
         const root = this.root;
         if (root) {
-            try {
-                this.bdom = true;
-                this.bdom = node.renderFn();
-            }
-            catch (e) {
-                node.app.handleError({ node, error: e });
-            }
+            // todo: should use updateComputation somewhere else.
+            runWithComputation(node.signalComputation, () => {
+                try {
+                    this.bdom = true;
+                    this.bdom = node.renderFn();
+                }
+                catch (e) {
+                    node.app.handleError({ node, error: e });
+                }
+            });
             root.setCounter(root.counter - 1);
         }
     }
@@ -1913,11 +2151,6 @@ class MountFiber extends RootFiber {
 
 // Special key to subscribe to, to be notified of key creation/deletion
 const KEYCHANGES = Symbol("Key changes");
-// Used to specify the absence of a callback, can be used as WeakMap key but
-// should only be used as a sentinel value and never called.
-const NO_CALLBACK = () => {
-    throw new Error("Called NO_CALLBACK. Owl is broken, please report this to the maintainers.");
-};
 const objectToString = Object.prototype.toString;
 const objectHasOwnProperty = Object.prototype.hasOwnProperty;
 // Use arrays because Array.includes is faster than Set.has for small arrays
@@ -1954,8 +2187,8 @@ function canBeMadeReactive(value) {
  * @param value the value make reactive
  * @returns a reactive for the given object when possible, the original otherwise
  */
-function possiblyReactive(val, cb) {
-    return canBeMadeReactive(val) ? reactive(val, cb) : val;
+function possiblyReactive(val) {
+    return canBeMadeReactive(val) ? reactive(val) : val;
 }
 const skipped = new WeakSet();
 /**
@@ -1977,7 +2210,23 @@ function markRaw(value) {
 function toRaw(value) {
     return targets.has(value) ? targets.get(value) : value;
 }
-const targetToKeysToCallbacks = new WeakMap();
+const targetToKeysToAtomItem = new WeakMap();
+function getTargetKeyAtom(target, key) {
+    let keyToAtomItem = targetToKeysToAtomItem.get(target);
+    if (!keyToAtomItem) {
+        keyToAtomItem = new Map();
+        targetToKeysToAtomItem.set(target, keyToAtomItem);
+    }
+    let atom = keyToAtomItem.get(key);
+    if (!atom) {
+        atom = {
+            value: undefined,
+            observers: new Set(),
+        };
+        keyToAtomItem.set(key, atom);
+    }
+    return atom;
+}
 /**
  * Observes a given key on a target with an callback. The callback will be
  * called when the given key changes on the target.
@@ -1987,22 +2236,8 @@ const targetToKeysToCallbacks = new WeakMap();
  *  or deletion)
  * @param callback the function to call when the key changes
  */
-function observeTargetKey(target, key, callback) {
-    if (callback === NO_CALLBACK) {
-        return;
-    }
-    if (!targetToKeysToCallbacks.get(target)) {
-        targetToKeysToCallbacks.set(target, new Map());
-    }
-    const keyToCallbacks = targetToKeysToCallbacks.get(target);
-    if (!keyToCallbacks.get(key)) {
-        keyToCallbacks.set(key, new Set());
-    }
-    keyToCallbacks.get(key).add(callback);
-    if (!callbacksToTargets.has(callback)) {
-        callbacksToTargets.set(callback, new Set());
-    }
-    callbacksToTargets.get(callback).add(target);
+function onReadTargetKey(target, key) {
+    onReadAtom(getTargetKeyAtom(target, key));
 }
 /**
  * Notify Reactives that are observing a given target that a key has changed on
@@ -2013,60 +2248,16 @@ function observeTargetKey(target, key, callback) {
  * @param key the key that changed (or Symbol `KEYCHANGES` if a key was created
  *   or deleted)
  */
-function notifyReactives(target, key) {
-    const keyToCallbacks = targetToKeysToCallbacks.get(target);
-    if (!keyToCallbacks) {
+function onWriteTargetKey(target, key) {
+    const keyToAtomItem = targetToKeysToAtomItem.get(target);
+    if (!keyToAtomItem) {
         return;
     }
-    const callbacks = keyToCallbacks.get(key);
-    if (!callbacks) {
+    const atom = keyToAtomItem.get(key);
+    if (!atom) {
         return;
     }
-    // Loop on copy because clearReactivesForCallback will modify the set in place
-    for (const callback of [...callbacks]) {
-        clearReactivesForCallback(callback);
-        callback();
-    }
-}
-const callbacksToTargets = new WeakMap();
-/**
- * Clears all subscriptions of the Reactives associated with a given callback.
- *
- * @param callback the callback for which the reactives need to be cleared
- */
-function clearReactivesForCallback(callback) {
-    const targetsToClear = callbacksToTargets.get(callback);
-    if (!targetsToClear) {
-        return;
-    }
-    for (const target of targetsToClear) {
-        const observedKeys = targetToKeysToCallbacks.get(target);
-        if (!observedKeys) {
-            continue;
-        }
-        for (const [key, callbacks] of observedKeys.entries()) {
-            callbacks.delete(callback);
-            if (!callbacks.size) {
-                observedKeys.delete(key);
-            }
-        }
-    }
-    targetsToClear.clear();
-}
-function getSubscriptions(callback) {
-    const targets = callbacksToTargets.get(callback) || [];
-    return [...targets].map((target) => {
-        const keysToCallbacks = targetToKeysToCallbacks.get(target);
-        let keys = [];
-        if (keysToCallbacks) {
-            for (const [key, cbs] of keysToCallbacks) {
-                if (cbs.has(callback)) {
-                    keys.push(key);
-                }
-            }
-        }
-        return { target, keys };
-    });
+    onWriteAtom(atom);
 }
 // Maps reactive objects to the underlying target
 const targets = new WeakMap();
@@ -2098,7 +2289,7 @@ const reactiveCache = new WeakMap();
  *  reactive has changed
  * @returns a proxy that tracks changes to it
  */
-function reactive(target, callback = NO_CALLBACK) {
+function reactive(target) {
     if (!canBeMadeReactive(target)) {
         throw new OwlError(`Cannot make the given value reactive`);
     }
@@ -2107,22 +2298,19 @@ function reactive(target, callback = NO_CALLBACK) {
     }
     if (targets.has(target)) {
         // target is reactive, create a reactive on the underlying object instead
-        return reactive(targets.get(target), callback);
-    }
-    if (!reactiveCache.has(target)) {
-        reactiveCache.set(target, new WeakMap());
-    }
-    const reactivesForTarget = reactiveCache.get(target);
-    if (!reactivesForTarget.has(callback)) {
-        const targetRawType = rawType(target);
-        const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
-            ? collectionsProxyHandler(target, callback, targetRawType)
-            : basicProxyHandler(callback);
-        const proxy = new Proxy(target, handler);
-        reactivesForTarget.set(callback, proxy);
-        targets.set(proxy, target);
+        return target;
     }
-    return reactivesForTarget.get(callback);
+    const reactive = reactiveCache.get(target);
+    if (reactive)
+        return reactive;
+    const targetRawType = rawType(target);
+    const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
+        ? collectionsProxyHandler(target, targetRawType)
+        : basicProxyHandler();
+    const proxy = new Proxy(target, handler);
+    reactiveCache.set(target, proxy);
+    targets.set(proxy, target);
+    return proxy;
 }
 /**
  * Creates a basic proxy handler for regular objects and arrays.
@@ -2130,7 +2318,7 @@ function reactive(target, callback = NO_CALLBACK) {
  * @param callback @see reactive
  * @returns a proxy handler object
  */
-function basicProxyHandler(callback) {
+function basicProxyHandler() {
     return {
         get(target, key, receiver) {
             // non-writable non-configurable properties cannot be made reactive
@@ -2138,41 +2326,41 @@ function basicProxyHandler(callback) {
             if (desc && !desc.writable && !desc.configurable) {
                 return Reflect.get(target, key, receiver);
             }
-            observeTargetKey(target, key, callback);
-            return possiblyReactive(Reflect.get(target, key, receiver), callback);
+            onReadTargetKey(target, key);
+            return possiblyReactive(Reflect.get(target, key, receiver));
         },
         set(target, key, value, receiver) {
             const hadKey = objectHasOwnProperty.call(target, key);
             const originalValue = Reflect.get(target, key, receiver);
             const ret = Reflect.set(target, key, toRaw(value), receiver);
             if (!hadKey && objectHasOwnProperty.call(target, key)) {
-                notifyReactives(target, KEYCHANGES);
+                onWriteTargetKey(target, KEYCHANGES);
             }
             // While Array length may trigger the set trap, it's not actually set by this
             // method but is updated behind the scenes, and the trap is not called with the
             // new value. We disable the "same-value-optimization" for it because of that.
             if (originalValue !== Reflect.get(target, key, receiver) ||
                 (key === "length" && Array.isArray(target))) {
-                notifyReactives(target, key);
+                onWriteTargetKey(target, key);
             }
             return ret;
         },
         deleteProperty(target, key) {
             const ret = Reflect.deleteProperty(target, key);
             // TODO: only notify when something was actually deleted
-            notifyReactives(target, KEYCHANGES);
-            notifyReactives(target, key);
+            onWriteTargetKey(target, KEYCHANGES);
+            onWriteTargetKey(target, key);
             return ret;
         },
         ownKeys(target) {
-            observeTargetKey(target, KEYCHANGES, callback);
+            onReadTargetKey(target, KEYCHANGES);
             return Reflect.ownKeys(target);
         },
         has(target, key) {
             // TODO: this observes all key changes instead of only the presence of the argument key
             // observing the key itself would observe value changes instead of presence changes
             // so we may need a finer grained system to distinguish observing value vs presence.
-            observeTargetKey(target, KEYCHANGES, callback);
+            onReadTargetKey(target, KEYCHANGES);
             return Reflect.has(target, key);
         },
     };
@@ -2185,11 +2373,11 @@ function basicProxyHandler(callback) {
  * @param target @see reactive
  * @param callback @see reactive
  */
-function makeKeyObserver(methodName, target, callback) {
+function makeKeyObserver(methodName, target) {
     return (key) => {
         key = toRaw(key);
-        observeTargetKey(target, key, callback);
-        return possiblyReactive(target[methodName](key), callback);
+        onReadTargetKey(target, key);
+        return possiblyReactive(target[methodName](key));
     };
 }
 /**
@@ -2200,14 +2388,14 @@ function makeKeyObserver(methodName, target, callback) {
  * @param target @see reactive
  * @param callback @see reactive
  */
-function makeIteratorObserver(methodName, target, callback) {
+function makeIteratorObserver(methodName, target) {
     return function* () {
-        observeTargetKey(target, KEYCHANGES, callback);
+        onReadTargetKey(target, KEYCHANGES);
         const keys = target.keys();
         for (const item of target[methodName]()) {
             const key = keys.next().value;
-            observeTargetKey(target, key, callback);
-            yield possiblyReactive(item, callback);
+            onReadTargetKey(target, key);
+            yield possiblyReactive(item);
         }
     };
 }
@@ -2219,12 +2407,12 @@ function makeIteratorObserver(methodName, target, callback) {
  * @param target @see reactive
  * @param callback @see reactive
  */
-function makeForEachObserver(target, callback) {
+function makeForEachObserver(target) {
     return function forEach(forEachCb, thisArg) {
-        observeTargetKey(target, KEYCHANGES, callback);
+        onReadTargetKey(target, KEYCHANGES);
         target.forEach(function (val, key, targetObj) {
-            observeTargetKey(target, key, callback);
-            forEachCb.call(thisArg, possiblyReactive(val, callback), possiblyReactive(key, callback), possiblyReactive(targetObj, callback));
+            onReadTargetKey(target, key);
+            forEachCb.call(thisArg, possiblyReactive(val), possiblyReactive(key), possiblyReactive(targetObj));
         }, thisArg);
     };
 }
@@ -2246,10 +2434,10 @@ function delegateAndNotify(setterName, getterName, target) {
         const ret = target[setterName](key, value);
         const hasKey = target.has(key);
         if (hadKey !== hasKey) {
-            notifyReactives(target, KEYCHANGES);
+            onWriteTargetKey(target, KEYCHANGES);
         }
         if (originalValue !== target[getterName](key)) {
-            notifyReactives(target, key);
+            onWriteTargetKey(target, key);
         }
         return ret;
     };
@@ -2264,9 +2452,9 @@ function makeClearNotifier(target) {
     return () => {
         const allKeys = [...target.keys()];
         target.clear();
-        notifyReactives(target, KEYCHANGES);
+        onWriteTargetKey(target, KEYCHANGES);
         for (const key of allKeys) {
-            notifyReactives(target, key);
+            onWriteTargetKey(target, key);
         }
     };
 }
@@ -2278,40 +2466,40 @@ function makeClearNotifier(target) {
  * reactives that the key which is being added or deleted has been modified.
  */
 const rawTypeToFuncHandlers = {
-    Set: (target, callback) => ({
-        has: makeKeyObserver("has", target, callback),
+    Set: (target) => ({
+        has: makeKeyObserver("has", target),
         add: delegateAndNotify("add", "has", target),
         delete: delegateAndNotify("delete", "has", target),
-        keys: makeIteratorObserver("keys", target, callback),
-        values: makeIteratorObserver("values", target, callback),
-        entries: makeIteratorObserver("entries", target, callback),
-        [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
-        forEach: makeForEachObserver(target, callback),
+        keys: makeIteratorObserver("keys", target),
+        values: makeIteratorObserver("values", target),
+        entries: makeIteratorObserver("entries", target),
+        [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target),
+        forEach: makeForEachObserver(target),
         clear: makeClearNotifier(target),
         get size() {
-            observeTargetKey(target, KEYCHANGES, callback);
+            onReadTargetKey(target, KEYCHANGES);
             return target.size;
         },
     }),
-    Map: (target, callback) => ({
-        has: makeKeyObserver("has", target, callback),
-        get: makeKeyObserver("get", target, callback),
+    Map: (target) => ({
+        has: makeKeyObserver("has", target),
+        get: makeKeyObserver("get", target),
         set: delegateAndNotify("set", "get", target),
         delete: delegateAndNotify("delete", "has", target),
-        keys: makeIteratorObserver("keys", target, callback),
-        values: makeIteratorObserver("values", target, callback),
-        entries: makeIteratorObserver("entries", target, callback),
-        [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
-        forEach: makeForEachObserver(target, callback),
+        keys: makeIteratorObserver("keys", target),
+        values: makeIteratorObserver("values", target),
+        entries: makeIteratorObserver("entries", target),
+        [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target),
+        forEach: makeForEachObserver(target),
         clear: makeClearNotifier(target),
         get size() {
-            observeTargetKey(target, KEYCHANGES, callback);
+            onReadTargetKey(target, KEYCHANGES);
             return target.size;
         },
     }),
-    WeakMap: (target, callback) => ({
-        has: makeKeyObserver("has", target, callback),
-        get: makeKeyObserver("get", target, callback),
+    WeakMap: (target) => ({
+        has: makeKeyObserver("has", target),
+        get: makeKeyObserver("get", target),
         set: delegateAndNotify("set", "get", target),
         delete: delegateAndNotify("delete", "has", target),
     }),
@@ -2323,18 +2511,18 @@ const rawTypeToFuncHandlers = {
  * @param target @see reactive
  * @returns a proxy handler object
  */
-function collectionsProxyHandler(target, callback, targetRawType) {
+function collectionsProxyHandler(target, targetRawType) {
     // TODO: if performance is an issue we can create the special handlers lazily when each
     // property is read.
-    const specialHandlers = rawTypeToFuncHandlers[targetRawType](target, callback);
-    return Object.assign(basicProxyHandler(callback), {
+    const specialHandlers = rawTypeToFuncHandlers[targetRawType](target);
+    return Object.assign(basicProxyHandler(), {
         // FIXME: probably broken when part of prototype chain since we ignore the receiver
         get(target, key) {
             if (objectHasOwnProperty.call(specialHandlers, key)) {
                 return specialHandlers[key];
             }
-            observeTargetKey(target, key, callback);
-            return possiblyReactive(target[key], callback);
+            onReadTargetKey(target, key);
+            return possiblyReactive(target[key]);
         },
     });
 }
@@ -2368,7 +2556,6 @@ function applyDefaultProps(props, defaultProps) {
 // -----------------------------------------------------------------------------
 // Integration with reactivity system (useState)
 // -----------------------------------------------------------------------------
-const batchedRenderFunctions = new WeakMap();
 /**
  * Creates a reactive object that will be observed by the current component.
  * Reading data from the returned object (eg during rendering) will cause the
@@ -2380,15 +2567,7 @@ const batchedRenderFunctions = new WeakMap();
  * @see reactive
  */
 function useState(state) {
-    const node = getCurrent();
-    let render = batchedRenderFunctions.get(node);
-    if (!render) {
-        render = batched(node.render.bind(node, false));
-        batchedRenderFunctions.set(node, render);
-        // manual implementation of onWillDestroy to break cyclic dependency
-        node.willDestroy.push(clearReactivesForCallback.bind(null, render));
-    }
-    return reactive(state, render);
+    return reactive(state);
 }
 class ComponentNode {
     constructor(C, props, app, parent, parentKey) {
@@ -2411,6 +2590,13 @@ class ComponentNode {
         this.parent = parent;
         this.props = props;
         this.parentKey = parentKey;
+        this.pluginManager = parent ? parent.pluginManager : app.pluginManager;
+        this.signalComputation = {
+            value: undefined,
+            compute: () => this.render(false),
+            sources: new Set(),
+            state: ComputationState.EXECUTED,
+        };
         const defaultProps = C.defaultProps;
         props = Object.assign({}, props);
         if (defaultProps) {
@@ -2418,16 +2604,13 @@ class ComponentNode {
         }
         const env = (parent && parent.childEnv) || app.env;
         this.childEnv = env;
-        for (const key in props) {
-            const prop = props[key];
-            if (prop && typeof prop === "object" && targets.has(prop)) {
-                props[key] = useState(prop);
-            }
-        }
+        const previousComputation = getCurrentComputation();
+        setComputation(this.signalComputation);
         this.component = new C(props, env, this);
         const ctx = Object.assign(Object.create(this.component), { this: this.component });
         this.renderFn = app.getTemplate(C.template).bind(this.component, ctx, this);
         this.component.setup();
+        setComputation(previousComputation);
         currentNode = null;
     }
     mountComponent(target, options) {
@@ -2442,7 +2625,11 @@ class ComponentNode {
         }
         const component = this.component;
         try {
-            await Promise.all(this.willStart.map((f) => f.call(component)));
+            let prom;
+            withoutReactivity(() => {
+                prom = Promise.all(this.willStart.map((f) => f.call(component)));
+            });
+            await prom;
         }
         catch (e) {
             this.app.handleError({ node: this, error: e });
@@ -2551,15 +2738,10 @@ class ComponentNode {
         if (defaultProps) {
             applyDefaultProps(props, defaultProps);
         }
-        currentNode = this;
-        for (const key in props) {
-            const prop = props[key];
-            if (prop && typeof prop === "object" && targets.has(prop)) {
-                props[key] = useState(prop);
-            }
-        }
-        currentNode = null;
-        const prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
+        let prom;
+        withoutReactivity(() => {
+            prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
+        });
         await prom;
         if (fiber !== this.fiber) {
             return;
@@ -2667,10 +2849,6 @@ class ComponentNode {
     get name() {
         return this.component.constructor.name;
     }
-    get subscriptions() {
-        const render = batchedRenderFunctions.get(this);
-        return render ? getSubscriptions(render) : [];
-    }
 }
 
 const TIMEOUT = Symbol("timeout");
@@ -2792,6 +2970,9 @@ class Component {
         this.env = env;
         this.__owl__ = node;
     }
+    get plugins() {
+        return this.__owl__.pluginManager.plugins;
+    }
     setup() { }
     render(deep = false) {
         this.__owl__.render(deep === true);
@@ -5907,6 +6088,171 @@ class Scheduler {
 // interactions with other code, such as test frameworks that override them
 Scheduler.requestAnimationFrame = window.requestAnimationFrame.bind(window);
 
+// import { PluginCtor } from "./component";
+class Plugin {
+    constructor() {
+        this.plugins = {};
+        this.resources = {};
+        this.__meta__ = { isDestroyed: false };
+        // getResource(name: string) {
+        //   // todo
+        // }
+        // dispatchTo(resourceName, ...args) {
+        //   for (let handler of this.getResource(name)) {
+        //     if (typeof handler === "function") {
+        //       handler(...args);
+        //     } else {
+        //       throw new Error("resource value should be a function")
+        //     }
+        //   }
+        // }
+    }
+    setup() { }
+    destroy() { }
+    get isDestroyed() {
+        return this.__meta__.isDestroyed;
+    }
+}
+Plugin.id = "";
+Plugin.dependencies = [];
+// can act and replace another plugin
+// static replaceOtherPlugin: null | string = null;
+// can define the type of resources, and some information, such as, is the
+// resource global or not
+Plugin.resources = {};
+class PluginManager {
+    constructor(parent, Plugins) {
+        this._children = [];
+        this._parent = parent;
+        parent === null || parent === void 0 ? void 0 : parent._children.push(this);
+        this.plugins = parent ? Object.create(parent.plugins) : {};
+        this.resources = parent ? Object.create(parent.resources) : {};
+        // instantiate all plugins
+        const plugins = [];
+        const PLUGINS = Array.isArray(Plugins) ? Plugins : Plugins();
+        for (let P of toposort(PLUGINS, this.plugins)) {
+            if (P.resources) {
+                for (let r in P.resources) {
+                    const sources = reactive({});
+                    const fn = derived(() => {
+                        const result = [];
+                        for (let name in sources) {
+                            const plugin = sources[name];
+                            const value = plugin.resources[r];
+                            if (Array.isArray(value)) {
+                                result.push(...value);
+                            }
+                            else {
+                                result.push(value);
+                            }
+                        }
+                        return result;
+                    });
+                    this.resources[r] = { sources, fn };
+                }
+            }
+            const p = new P();
+            plugins.push(p);
+            this.plugins[P.id] = p;
+            for (let dep of P.dependencies) {
+                p.plugins[dep] = this.plugins[dep];
+            }
+        }
+        // aggregate resources
+        for (let name in this.plugins) {
+            const p = this.plugins[name];
+            for (let r in p.resources) {
+                this.resources[r].sources[name] = p;
+                //     const value = p.resources[r];
+                //     if (Array.isArray(value)) {
+                //       this.resources[r].push(...value);
+                //     } else {
+                //       this.resources[r].push(value);
+                // }
+            }
+        }
+        // setup phase
+        for (let p of plugins) {
+            p.setup();
+        }
+    }
+    destroy() {
+        for (let children of this._children) {
+            children.destroy();
+        }
+        const plugins = [];
+        for (let id in this.plugins) {
+            if (this.plugins.hasOwnProperty(id)) {
+                const plugin = this.plugins[id];
+                // resources
+                for (let r in plugin.resources) {
+                    delete this.resources[r].sources[id];
+                }
+                plugins.push(this.plugins[id]);
+                delete this.plugins[id];
+            }
+        }
+        while (plugins.length) {
+            const plugin = plugins.pop();
+            plugin.destroy();
+            plugin.__meta__.isDestroyed = true;
+        }
+    }
+    getPlugin(name) {
+        return this.plugins[name] || null;
+    }
+    getResource(name) {
+        return this.resources[name].fn();
+    }
+}
+function toposort(Plugins, plugins) {
+    const visited = new Set();
+    const temp = new Set();
+    const sorted = [];
+    const mapping = {};
+    for (const P of Plugins) {
+        if (!P.id.length) {
+            throw new Error(`Plugin ${P.name} has no id`);
+        }
+        if (P.id in mapping) {
+            throw new Error("A plugin with the same ID is already defined");
+        }
+        mapping[P.id] = P;
+    }
+    const visit = (P) => {
+        if (visited.has(P.id))
+            return;
+        if (temp.has(P.id)) {
+            throw new Error(`Circular dependency: ${P.id}`);
+        }
+        temp.add(P.id);
+        for (const dep of P.dependencies || []) {
+            const Dep = mapping[dep];
+            if (Dep) {
+                visit(Dep);
+            }
+            else {
+                if (!(dep in plugins)) {
+                    throw new Error(`Missing dependency "${dep}" for plugin "${P.id}"`);
+                }
+            }
+        }
+        temp.delete(P.id);
+        visited.add(P.id);
+        sorted.push(P);
+    };
+    for (const P of Plugins) {
+        visit(P);
+    }
+    return sorted;
+}
+function usePlugins(Plugins) {
+    const node = getCurrent();
+    const manager = new PluginManager(node.pluginManager, Plugins);
+    node.pluginManager = manager;
+    onWillDestroy(() => manager.destroy());
+}
+
 let hasBeenLogged = false;
 const apps = new Set();
 window.__OWL_DEVTOOLS__ || (window.__OWL_DEVTOOLS__ = { apps, Fiber, RootFiber, toRaw, reactive });
@@ -5919,6 +6265,7 @@ class App extends TemplateSet {
         this.name = config.name || "";
         this.Root = Root;
         apps.add(this);
+        this.pluginManager = new PluginManager(null, config.Plugins || []);
         if (config.test) {
             this.dev = true;
         }
@@ -6134,6 +6481,43 @@ const mainEventHandler = (data, ev, currentTarget) => {
     return stopped;
 };
 
+class Registry {
+    constructor(name, schema) {
+        this._map = reactive(Object.create(null));
+        this._name = name || "registry";
+        this._schema = schema;
+        const entries = derived(() => {
+            return Object.entries(this._map)
+                .sort((el1, el2) => el1[1][0] - el2[1][0])
+                .map(([str, elem]) => [str, elem[1]]);
+        });
+        const items = derived(() => entries().map((e) => e[1]));
+        Object.defineProperty(this, "items", {
+            get() {
+                return items;
+            },
+        });
+        Object.defineProperty(this, "entries", {
+            get() {
+                return entries;
+            },
+        });
+    }
+    set(key, value, sequence = 50) {
+        if (this._schema) {
+            validate(value, this._schema);
+        }
+        this._map[key] = [sequence, value];
+    }
+    get(key, defaultValue) {
+        const hasKey = key in this._map;
+        if (!hasKey && arguments.length < 2) {
+            throw new Error(`KeyNotFoundError: Cannot find key "${key}" in this registry`);
+        }
+        return hasKey ? this._map[key][1] : defaultValue;
+    }
+}
+
 function status(component) {
     switch (component.__owl__.status) {
         case 0 /* NEW */:
@@ -6207,21 +6591,26 @@ function useChildSubEnv(envExtension) {
  *      NaN !== NaN, which will cause the effect to rerun on every patch.
  */
 function useEffect(effect, computeDependencies = () => [NaN]) {
+    const context = getCurrent().component.__owl__.signalComputation;
     let cleanup;
     let dependencies;
-    onMounted(() => {
-        dependencies = computeDependencies();
+    const runEffect = () => runWithComputation(context, () => {
         cleanup = effect(...dependencies);
     });
+    const computeDependenciesWithContext = () => runWithComputation(context, computeDependencies);
+    onMounted(() => {
+        dependencies = computeDependenciesWithContext();
+        runEffect();
+    });
     onPatched(() => {
-        const newDeps = computeDependencies();
+        const newDeps = computeDependenciesWithContext();
         const shouldReapply = newDeps.some((val, i) => val !== dependencies[i]);
         if (shouldReapply) {
             dependencies = newDeps;
             if (cleanup) {
                 cleanup();
             }
-            cleanup = effect(...dependencies);
+            runEffect();
         }
     });
     onWillUnmount(() => cleanup && cleanup());
@@ -6281,9 +6670,9 @@ TemplateSet.prototype._compileTemplate = function _compileTemplate(name, templat
     });
 };
 
-export { App, Component, EventBus, OwlError, __info__, batched, blockDom, htmlEscape, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, useRef, useState, useSubEnv, validate, validateType, whenReady, xml };
+export { App, Component, EventBus, OwlError, Plugin, PluginManager, Registry, __info__, batched, blockDom, derived, effect, htmlEscape, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, signal, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, usePlugins, useRef, useState, useSubEnv, validate, validateType, whenReady, withoutReactivity, xml };
 
 
-__info__.date = '2025-09-23T07:17:45.055Z';
-__info__.hash = '5211116';
+__info__.date = '2025-11-21T12:26:21.756Z';
+__info__.hash = '938f3f6';
 __info__.url = 'https://github.com/odoo/owl';