Fix initial callbacks suppression on non-Patch full replacements

Author: Aaron-Wrote-This

dash/dash-renderer/src/actions/callbacks.ts

@@ -41,7 +41,7 @@ import {createAction, Action} from 'redux-actions';
 import {addHttpHeaders} from '../actions';
 import {notifyObservers, updateProps} from './index';
 import {CallbackJobPayload} from '../reducers/callbackJobs';
-import {parsePatchProps} from './patch';
+import {isPatch, parsePatchProps} from './patch';
 import {computePaths, getPath} from './paths';
 
 import {requestDependencies} from './requestDependencies';
@@ -826,6 +826,7 @@ export function executeCallback(
                         );
                         // Patch methodology: always run through parsePatchProps for each output
                         const currentLayout = getState().layout;
+                        let wasPatch = false;
                         flatten(outputs).forEach((out: any) => {
                             const propName = cleanOutputProp(out.property);
                             const outputPath = getPath(paths, out.id);
@@ -834,6 +835,9 @@ export function executeCallback(
                             if (outputValue === undefined) {
                                 return;
                             }
+                            if (isPatch(outputValue)) {
+                                wasPatch = true;
+                            }
                             const oldProps =
                                 path(
                                     outputPath.concat(['props']),
@@ -849,7 +853,7 @@ export function executeCallback(
                                 data
                             );
                         });
-                        return {data, payload};
+                        return {data, payload, ...(wasPatch ? {prePatchPaths: paths} : {})};
                     } catch (error: any) {
                         return {error, payload};
                     }
@@ -909,6 +913,7 @@ export function executeCallback(
                         // Layout may have changed.
                         // DRY: Always run through parsePatchProps for each output
                         const currentLayout = getState().layout;
+                        let wasPatch = false;
                         flatten(outputs).forEach((out: any) => {
                             const propName = cleanOutputProp(out.property);
                             const outputPath = getPath(paths, out.id);
@@ -917,6 +922,9 @@ export function executeCallback(
                             if (outputValue === undefined) {
                                 return;
                             }
+                            if (isPatch(outputValue)) {
+                                wasPatch = true;
+                            }
                             const oldProps =
                                 path(
                                     outputPath.concat(['props']),
@@ -941,7 +949,7 @@ export function executeCallback(
                             );
                         }
 
-                        return {data, payload};
+                        return {data, payload, ...(wasPatch ? {prePatchPaths: paths} : {})};
                     } catch (res: any) {
                         lastError = res;
                         if (

dash/dash-renderer/src/actions/dependencies.js

@@ -1311,7 +1311,7 @@ export function getUnfilteredLayoutCallbacks(graphs, paths, layoutChunk, opts) {
         // props that were undefined in both old and new layouts (undefined === undefined).
         if (oldPropValue === undefined) return false;
         const newPropValue = child ? path(['props', property], child) : undefined;
-        return oldPropValue === newPropValue;
+        return equals(oldPropValue, newPropValue);
     }
 
     function handleOneId(id, outIdCallbacks, inIdCallbacks, child) {

dash/dash-renderer/src/observers/executedCallbacks.ts

@@ -93,7 +93,7 @@ const observer: IStoreObserverDefinition<IStoreState> = {
                 return;
             }
 
-            const {data, error, payload} = executionResult;
+            const {data, error, payload, prePatchPaths} = executionResult;
 
             if (data !== undefined) {
                 Object.entries(data).forEach(
@@ -156,12 +156,21 @@ const observer: IStoreObserverDefinition<IStoreState> = {
                             dispatch(setPaths(paths));
 
                             // Get callbacks for new layout (w/ execution group)
+                            // Only pass oldPaths/oldLayout for Patch callbacks:
+                            // isUnchangedOutputProp must only suppress initial
+                            // calls when a Patch carried over existing components.
+                            // For full-replacement callbacks every component is a
+                            // fresh instance and all initial calls must fire.
                             requestedCallbacks = concat(
                                 requestedCallbacks,
                                 getLayoutCallbacks(graphs, paths, children, {
                                     chunkPath: oldChildrenPath,
-                                    oldPaths: oPaths,
-                                    oldLayout: oldLayout,
+                                    ...(prePatchPaths
+                                        ? {
+                                              oldPaths: oPaths,
+                                              oldLayout: oldLayout
+                                          }
+                                        : {}),
                                     filterRoot
                                 }).map(rcb => ({
                                     ...rcb,

dash/dash-renderer/src/types/callbacks.ts

@@ -83,6 +83,7 @@ export type CallbackResult = {
     data?: CallbackResponse;
     error?: Error;
     payload: ICallbackPayload | null;
+    prePatchPaths?: any;
 };
 
 export type BackgroundCallbackInfo = {

tests/integration/callbacks/test_wildcards.py

@@ -709,3 +709,84 @@ def on_value_change(value):
     assert (
         fire_counts[2] == 1
     ), f"New item 2 callback should have fired exactly once, fired {fire_counts[2]}"
+
+
+def test_cbwc010_full_replace_fires_initial_callbacks(dash_duo):
+    """Regression test ensuring full-replacement (non-Patch) outputs still fire
+    initial callbacks for all replaced components.
+
+    When a callback returns a full list (not a Patch), every component in the
+    new layout is a fresh instance. The isUnchangedOutputProp suppression must
+    NOT apply here: prePatchPaths is absent from the execution result, so
+    oldPaths/oldLayout are never passed, and all initial calls must fire.
+    """
+    lock = threading.Lock()
+    fire_counts = {}  # {index: count}
+
+    def make_item(index):
+        return html.Div(
+            [
+                dcc.Input(
+                    id={"type": "fr-input", "index": index},
+                    value=index,
+                    type="number",
+                    className="fr-input",
+                ),
+                html.Div(
+                    "init",
+                    id={"type": "fr-output", "index": index},
+                    className="fr-output",
+                ),
+            ]
+        )
+
+    app = Dash(__name__)
+    app.layout = html.Div(
+        [
+            html.Button("Replace", id="replace-btn", n_clicks=0),
+            html.Div([make_item(0), make_item(1)], id="fr-container"),
+        ]
+    )
+
+    @app.callback(
+        Output("fr-container", "children"),
+        Input("replace-btn", "n_clicks"),
+        prevent_initial_call=True,
+    )
+    def replace_items(_):
+        # Full replacement — returns a plain list, not a Patch
+        return [make_item(10), make_item(11)]
+
+    @app.callback(
+        Output({"type": "fr-output", "index": MATCH}, "children"),
+        Input({"type": "fr-input", "index": MATCH}, "value"),
+    )
+    def on_value_change(value):
+        from dash import ctx
+
+        idx = ctx.outputs_grouping["id"]["index"]
+        with lock:
+            fire_counts[idx] = fire_counts.get(idx, 0) + 1
+            count = fire_counts[idx]
+        return f"fired-{idx}-#{count}"
+
+    dash_duo.start_server(app)
+
+    # Wait for the initial callbacks for items 0 and 1.
+    wait.until(lambda: fire_counts.get(0, 0) >= 1, 5)
+    wait.until(lambda: fire_counts.get(1, 0) >= 1, 5)
+
+    # Trigger a full replacement.
+    dash_duo.find_element("#replace-btn").click()
+
+    # After full replacement, items 10 and 11 are brand-new instances and
+    # MUST have their initial callbacks fire.
+    wait.until(lambda: fire_counts.get(10, 0) >= 1, 5)
+    wait.until(lambda: fire_counts.get(11, 0) >= 1, 5)
+
+    assert (
+        fire_counts[10] >= 1
+    ), f"New item 10 callback should have fired after full replace, got {fire_counts.get(10, 0)}"
+    assert (
+        fire_counts[11] >= 1
+    ), f"New item 11 callback should have fired after full replace, got {fire_counts.get(11, 0)}"