@startsimpli/ui 0.4.137 → 0.4.138

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/ui",
-  "version": "0.4.137",
+  "version": "0.4.138",
   "description": "Shared UI components package for StartSimpli applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -49,8 +49,8 @@
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "@startsimpli/auth": "^0.4.38",
-    "@startsimpli/i18n": "^0.1.3",
-    "@startsimpli/api": "^0.5.66"
+    "@startsimpli/api": "^0.5.66",
+    "@startsimpli/i18n": "^0.1.3"
   },
   "peerDependenciesMeta": {
     "@startsimpli/api": {

package/src/components/history/__tests__/use-conditional-save.test.tsx

@@ -385,3 +385,63 @@ describe('resolving is a deliberate act', () => {
     expect(result.current.version).toBe(2);
   });
 });
+
+describe('a resolution cannot be raced', () => {
+  // The dialog disables these while busy, but the HOOK is exported on its own
+  // and a consumer wires its own controls (bd startsim-j19hf does exactly that).
+  it('ignores acceptTheirs mid-keepMine so the two cannot interleave', async () => {
+    let release: (v: ConditionalWriteOutcome) => void = () => {};
+    const second = new Promise<ConditionalWriteOutcome>((r) => {
+      release = r;
+    });
+    let call = 0;
+    const write = jest.fn(async () => {
+      call += 1;
+      return call === 1 ? REFUSAL : second;
+    });
+    const { result } = renderHook(() => useConditionalSave({ client: { write }, version: 2 }));
+
+    await act(async () => {
+      await result.current.save({ data: { blog: 'mine' } });
+    });
+
+    let inflight!: Promise<unknown>;
+    act(() => {
+      inflight = result.current.keepMine();
+    });
+    expect(result.current.resolving).toBe(true);
+
+    // The user hits "discard mine" while the overwrite is still in the air.
+    act(() => result.current.acceptTheirs());
+    // IGNORED, so the two never interleave: the conflict is still the one
+    // keepMine is resolving, not a half-cleared state.
+    expect(result.current.conflict?.currentVersion).toBe(3);
+    expect(result.current.version).toBe(2);
+
+    await act(async () => {
+      release({ status: 412, body: { detail: 'again', current_version: 9 } });
+      await inflight;
+    });
+
+    // One writer decided the outcome — keepMine's — rather than two racing.
+    expect(result.current.conflict?.currentVersion).toBe(9);
+    expect(result.current.conflict?.refusedBody).toEqual({ data: { blog: 'mine' } });
+    expect(result.current.paused).toBe(true);
+    expect(result.current.version).toBe(2);
+  });
+
+  it('does not fire two overwrites on a double click', async () => {
+    const { client, sent } = writer([REFUSAL, { status: 200, body: { version: 4 } }]);
+    const { result } = renderHook(() => useConditionalSave({ client, version: 2 }));
+
+    await act(async () => {
+      await result.current.save({ data: { blog: 'mine' } });
+    });
+    await act(async () => {
+      await Promise.all([result.current.keepMine(), result.current.keepMine()]);
+    });
+
+    // One refused save + exactly one overwrite.
+    expect(sent).toHaveLength(2);
+  });
+});

package/src/components/history/useConditionalSave.ts

@@ -171,6 +171,9 @@ export function useConditionalSave({
   const [conflict, setConflict] = useState<StaleSaveConflict | null>(null);
   const [dismissed, setDismissed] = useState(false);
   const [resolving, setResolving] = useState(false);
+  /** The synchronous twin of {@link resolving}. State lands a render too late to
+   *  stop a second click; this does not. */
+  const resolvingRef = useRef(false);
   const [lastError, setLastError] = useState<unknown>(null);
 
   // Read inside `save` so a stale closure cannot send a version the hook has
@@ -301,6 +304,13 @@ export function useConditionalSave({
   const keepMine = useCallback(async (): Promise<ConditionalSaveResult> => {
     const current = conflictRef.current;
     if (!current) return { status: 'paused' };
+    // RE-ENTRANCY IS GUARDED ON A REF, NOT ON `resolving`, AND THAT IS THE WHOLE
+    // POINT. `setResolving(true)` only reaches the DOM after a re-render, so a
+    // double click on "Save mine" lands both handlers before the button is
+    // disabled — and sends the overwrite TWICE. Measured, not theorised: the
+    // test below counted three writes where two were correct.
+    if (resolvingRef.current) return { status: 'paused' };
+    resolvingRef.current = true;
     // Adopting `current_version` is legitimate HERE and nowhere else: a person
     // has been told what changed and has chosen to replace it.
     const target = isVersion(current.currentVersion) ? current.currentVersion : undefined;
@@ -311,11 +321,17 @@ export function useConditionalSave({
     try {
       return await attempt(current.refusedBody, target);
     } finally {
+      resolvingRef.current = false;
       if (alive.current) setResolving(false);
     }
   }, [attempt]);
 
   const acceptTheirs = useCallback(() => {
+    // IGNORED MID-OVERWRITE, same posture as `save`. Discarding while a
+    // `keepMine` is in the air lets the two interleave, and the refusal of a
+    // save the reviewer has ALREADY ABANDONED then raises a fresh dialog about
+    // it — a conflict about text that no longer exists anywhere.
+    if (resolvingRef.current) return;
     const current = conflictRef.current;
     setVersionState(isVersion(current?.currentVersion) ? current!.currentVersion : undefined);
     setConflict(null);