Track upstream value across renders even when in sync

`useCachedValue`'s during-render reset only updated
`previousValue.current` inside the branch that observes an external
value change. After a debounced save echoed the local edit back as
the new upstream value, the ref stayed pointing at the pre-save
value. The next local edit then made the next render look like an
external change (`previousValue.current !== value` while
`value !== cachedValue`), which fired `onReset` and discarded the
edit.

Restore the post-render effect that unconditionally syncs
`previousValue.current` to the latest committed `value`, so a local
edit following a debounced save reaches `cachedValue` instead of
being reset back.

REDMINE-21261

Author: tf

entry_types/scrolled/package/spec/frontend/inlineEditing/useCachedValue-spec.js

@@ -79,6 +79,26 @@ describe('useCachedValue', () => {
     expect(listener).not.toHaveBeenCalled();
   });
 
+  it('does not reset a follow-up local edit after passed value caught up to a previous one', () => {
+    const listener = jest.fn();
+    const {result, rerender} = renderHook(
+      ({value}) => useCachedValue(value, {
+        onReset: listener
+      }),
+      {initialProps: {value: 'value'}}
+    );
+
+    let [, setValue] = result.current;
+    act(() => setValue('new value'));
+    rerender({value: 'new value'});
+    [, setValue] = result.current;
+    act(() => setValue('newer value'));
+
+    const [cachedValue] = result.current;
+    expect(cachedValue).toBe('newer value');
+    expect(listener).not.toHaveBeenCalled();
+  });
+
   it('calls onDebouncedChange after value has not been set for given delay', () => {
     const listener = jest.fn();
     const {result} = renderHook(() => useCachedValue('value', {

entry_types/scrolled/package/src/frontend/inlineEditing/useCachedValue.js

@@ -20,6 +20,17 @@ export function useCachedValue(value, {
     previousValue.current = value;
   }
 
+  // Track the upstream value across renders. The branch above only
+  // assigns when an external change is observed; without this effect,
+  // a render that sees `value` already in sync with `cachedValue` (a
+  // local edit echoed back via `onDebouncedChange`) would leave
+  // `previousValue.current` stale. The next local edit would then
+  // misread that stale value as an external change and overwrite the
+  // edit with `onReset`.
+  useEffect(() => {
+    previousValue.current = value;
+  });
+
   const debouncedHandler = useDebouncedCallback(onDebouncedChange, delay);
 
   const setValue = useCallback(value => {