Improve postponed conflict resolution handling

Keep unresolved conflicts visible after Not now, reopen them only on explicit requests, and clear stale warning and dialogue state when a replicated resolution arrives. Add typed provisional English messages, revision-tree regressions, specifications, and a focused Real Obsidian E2E.

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -2,10 +2,12 @@ import { App, Modal } from "@/deps.ts";
 import { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT } from "diff-match-patch";
 import { CANCELLED, LEAVE_TO_SUBSEQUENT, type diff_result } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { delay } from "@vrtmrz/livesync-commonlib/compat/common/utils";
-import { eventHub } from "@/common/events.ts";
+import { EVENT_CONFLICT_CANCELLED, eventHub } from "@/common/events.ts";
 import { globalSlipBoard } from "@vrtmrz/livesync-commonlib/compat/bureau/bureau";
 
-export type MergeDialogResult = typeof CANCELLED | typeof LEAVE_TO_SUBSEQUENT | string;
+export const POSTPONED = Symbol("postponed");
+
+export type MergeDialogResult = typeof CANCELLED | typeof POSTPONED | typeof LEAVE_TO_SUBSEQUENT | string;
 
 declare global {
     interface Slips {
@@ -100,7 +102,7 @@ export class ConflictResolveModal extends Modal {
         if (this.offEvent) {
             this.offEvent();
         }
-        this.offEvent = eventHub.onEvent("conflict-cancelled", (path) => {
+        this.offEvent = eventHub.onEvent(EVENT_CONFLICT_CANCELLED, (path) => {
             if (path === this.filename) {
                 this.sendResponse(CANCELLED);
             }
@@ -169,7 +171,7 @@ export class ConflictResolveModal extends Modal {
         }
         contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
             e.addClass("conflict-action-button");
-            e.addEventListener("click", () => this.sendResponse(CANCELLED));
+            e.addEventListener("click", () => this.sendResponse(this.pluginPickMode ? CANCELLED : POSTPONED));
         });
         if (diffLength > 100 * 1024) {
             this.diffView.empty();

src/modules/features/ModuleInteractiveConflictResolver.ts

@@ -9,15 +9,67 @@ import {
     type FilePathWithPrefix,
     type diff_result,
 } from "@vrtmrz/livesync-commonlib/compat/common/types";
-import { ConflictResolveModal } from "./InteractiveConflictResolving/ConflictResolveModal.ts";
+import { ConflictResolveModal, POSTPONED } from "./InteractiveConflictResolving/ConflictResolveModal.ts";
 import { AbstractObsidianModule } from "@/modules/AbstractObsidianModule.ts";
 import { displayRev } from "@/common/utils.ts";
 import { fireAndForget } from "octagonal-wheels/promises";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import type { LiveSyncCore } from "@/main.ts";
+import { EVENT_CONFLICT_CANCELLED, EVENT_ON_UNRESOLVED_ERROR, eventHub } from "@/common/events.ts";
+import { $msg } from "@/common/translation.ts";
+import type { Editor, MarkdownFileInfo, MarkdownView } from "@/deps.ts";
 
 export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
+    private postponedConflictEpisodes = new Set<FilePathWithPrefix>();
+
+    private async isConflicted(filename: FilePathWithPrefix): Promise<boolean | undefined> {
+        try {
+            return (await this.core.databaseFileAccess.getConflictedRevs(filename)).length > 0;
+        } catch (error) {
+            this._log(`Could not inspect the conflict state of ${filename}`, LOG_LEVEL_VERBOSE);
+            this._log(error, LOG_LEVEL_VERBOSE);
+            return undefined;
+        }
+    }
+
+    private async getActiveConflictMessages(): Promise<string[]> {
+        const filename = this.services.vault.getActiveFilePath();
+        if (!filename) return [];
+        const conflicted = await this.isConflicted(filename);
+        if (conflicted === false) {
+            this.postponedConflictEpisodes.delete(filename);
+            return [];
+        }
+        if (conflicted === true || this.postponedConflictEpisodes.has(filename)) {
+            return [$msg("This file has unresolved conflicts.")];
+        }
+        return [];
+    }
+
+    private async refreshConflictState(filename: FilePathWithPrefix): Promise<void> {
+        if ((await this.isConflicted(filename)) === false) {
+            this.postponedConflictEpisodes.delete(filename);
+        }
+        eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+    }
+
+    private async requestConflictResolution(filename: FilePathWithPrefix): Promise<void> {
+        this.postponedConflictEpisodes.delete(filename);
+        eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+        await this.services.conflict.queueCheckFor(filename);
+        await this.services.conflict.ensureAllProcessed();
+    }
+
     _everyOnloadStart(): Promise<boolean> {
+        this.addCommand({
+            id: "livesync-checkdoc-conflicted",
+            name: "Resolve if conflicted.",
+            editorCallback: (editor: Editor, view: MarkdownView | MarkdownFileInfo) => {
+                const file = view.file;
+                if (!file) return;
+                void this.requestConflictResolution(file.path as FilePathWithPrefix);
+            },
+        });
         this.addCommand({
             id: "livesync-conflictcheck",
             name: "Pick a file to resolve conflict",
@@ -38,10 +90,21 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
     async _anyResolveConflictByUI(filename: FilePathWithPrefix, conflictCheckResult: diff_result): Promise<boolean> {
         // UI for resolving conflicts should one-by-one.
         return await serialized(`conflict-resolve-ui`, async () => {
+            if (this.postponedConflictEpisodes.has(filename)) {
+                this._log(`Merge: Postponed ${filename}`, LOG_LEVEL_VERBOSE);
+                eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+                return false;
+            }
             this._log("Merge:open conflict dialog", LOG_LEVEL_VERBOSE);
             const dialog = new ConflictResolveModal(this.app, filename, conflictCheckResult);
             dialog.open();
             const selected = await dialog.waitForResult();
+            if (selected === POSTPONED) {
+                this.postponedConflictEpisodes.add(filename);
+                eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+                this._log(`Merge: Postponed ${filename}`, LOG_LEVEL_INFO);
+                return false;
+            }
             if (selected === CANCELLED) {
                 // Cancelled by UI, or another conflict.
                 this._log(`Merge: Cancelled ${filename}`, LOG_LEVEL_INFO);
@@ -126,8 +189,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
         const target = await this.core.confirm.askSelectString("File to resolve conflict", notesList);
         if (target) {
             const targetItem = notes.find((e) => e.dispPath == target)!;
-            await this.services.conflict.queueCheckFor(targetItem.path);
-            await this.services.conflict.ensureAllProcessed();
+            await this.requestConflictResolution(targetItem.path);
             return true;
         }
         return false;
@@ -172,6 +234,10 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
     override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
         services.appLifecycle.onScanningStartupIssues.addHandler(this._allScanStat.bind(this));
         services.appLifecycle.onInitialise.addHandler(this._everyOnloadStart.bind(this));
+        services.appLifecycle.getUnresolvedMessages.addHandler(this.getActiveConflictMessages.bind(this));
         services.conflict.resolveByUserInteraction.addHandler(this._anyResolveConflictByUI.bind(this));
+        eventHub.onEvent(EVENT_CONFLICT_CANCELLED, (filename) => {
+            fireAndForget(() => this.refreshConflictState(filename));
+        });
     }
 }

src/modules/features/ModuleInteractiveConflictResolver.unit.spec.ts

@@ -0,0 +1,161 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+    CANCELLED,
+    DEFAULT_SETTINGS,
+    type FilePathWithPrefix,
+    type diff_result,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+
+const modalState = vi.hoisted(() => ({
+    constructed: 0,
+    result: undefined as unknown,
+    postponed: Symbol("postponed"),
+}));
+
+vi.mock("@/common/utils.ts", () => ({
+    displayRev: (revision: string) => revision,
+}));
+
+vi.mock("./InteractiveConflictResolving/ConflictResolveModal.ts", () => ({
+    POSTPONED: modalState.postponed,
+    ConflictResolveModal: class ConflictResolveModal {
+        constructor() {
+            modalState.constructed++;
+        }
+
+        open() {}
+
+        async waitForResult() {
+            return modalState.result;
+        }
+    },
+}));
+
+import { ModuleInteractiveConflictResolver } from "./ModuleInteractiveConflictResolver.ts";
+
+const path = "note.md" as FilePathWithPrefix;
+const conflict: diff_result = {
+    left: { rev: "2-left", data: "left", ctime: 1, mtime: 2 },
+    right: { rev: "2-right", data: "right", ctime: 1, mtime: 2 },
+    diff: [],
+};
+
+function createModule(conflictedRevisions: string[] = ["2-right"]) {
+    const handlers = {
+        unresolvedMessages: undefined as undefined | (() => Promise<string[]>),
+    };
+    const services = {
+        API: {
+            addLog: vi.fn(),
+            addCommand: vi.fn(),
+            registerWindow: vi.fn(),
+            addRibbonIcon: vi.fn(),
+            registerProtocolHandler: vi.fn(),
+        },
+        appLifecycle: {
+            getUnresolvedMessages: {
+                addHandler: vi.fn((handler: () => Promise<string[]>) => {
+                    handlers.unresolvedMessages = handler;
+                }),
+            },
+            onScanningStartupIssues: { addHandler: vi.fn() },
+            onInitialise: { addHandler: vi.fn() },
+            isSuspended: vi.fn(() => false),
+        },
+        conflict: {
+            resolveByUserInteraction: { addHandler: vi.fn() },
+            resolveByDeletingRevision: vi.fn(),
+            queueCheckFor: vi.fn(async () => undefined),
+            ensureAllProcessed: vi.fn(async () => true),
+        },
+        replication: { replicateByEvent: vi.fn(async () => true) },
+        vault: { getActiveFilePath: vi.fn(() => path) },
+        path: { getPath: vi.fn(), getPathWithoutPrefix: vi.fn() },
+    };
+    const core = {
+        _services: services,
+        services,
+        settings: { ...DEFAULT_SETTINGS, syncAfterMerge: false },
+        localDatabase: {
+            getDBEntry: vi.fn(async () => false),
+            findAllDocs: vi.fn(),
+        },
+        databaseFileAccess: {
+            getConflictedRevs: vi.fn(async () => conflictedRevisions),
+        },
+    };
+    const plugin = { app: {} };
+    const module = new ModuleInteractiveConflictResolver(plugin as never, core as never);
+    module._log = vi.fn();
+    return { core, handlers, module, services };
+}
+
+describe("ModuleInteractiveConflictResolver postponement", () => {
+    beforeEach(() => {
+        modalState.constructed = 0;
+        modalState.result = modalState.postponed;
+    });
+
+    it("does not reopen an unchanged conflict after the user chooses Not now", async () => {
+        const { module } = createModule();
+
+        await module._anyResolveConflictByUI(path, conflict);
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(modalState.constructed).toBe(1);
+    });
+
+    it("does not treat cancellation by another conflict dialogue as Not now", async () => {
+        const { module } = createModule();
+        modalState.result = CANCELLED;
+
+        await module._anyResolveConflictByUI(path, conflict);
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(modalState.constructed).toBe(2);
+    });
+
+    it("allows an explicit resolution request to reopen a postponed conflict", async () => {
+        const { module, services } = createModule();
+
+        await module._anyResolveConflictByUI(path, conflict);
+        await (module as any).requestConflictResolution(path);
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(services.conflict.queueCheckFor).toHaveBeenCalledWith(path);
+        expect(services.conflict.ensureAllProcessed).toHaveBeenCalledOnce();
+        expect(modalState.constructed).toBe(2);
+    });
+
+    it("opens a later conflict after the postponed conflict episode has resolved", async () => {
+        const conflictedRevisions = ["2-right"];
+        const { module } = createModule(conflictedRevisions);
+
+        await module._anyResolveConflictByUI(path, conflict);
+        conflictedRevisions.splice(0);
+        await (module as any).refreshConflictState(path);
+        conflictedRevisions.push("4-later");
+        await module._anyResolveConflictByUI(path, conflict);
+
+        expect(modalState.constructed).toBe(2);
+    });
+
+    it("contributes the active conflict to the existing unresolved-message display", async () => {
+        const { core, handlers, module, services } = createModule();
+
+        module.onBindFunction(core as never, services as never);
+
+        expect(services.appLifecycle.getUnresolvedMessages.addHandler).toHaveBeenCalledOnce();
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual(["This file has unresolved conflicts."]);
+    });
+
+    it("removes the active warning once the conflict has resolved", async () => {
+        const conflictedRevisions = ["2-right"];
+        const { core, handlers, module, services } = createModule(conflictedRevisions);
+        module.onBindFunction(core as never, services as never);
+
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual(["This file has unresolved conflicts."]);
+        conflictedRevisions.splice(0);
+        await expect(handlers.unresolvedMessages?.()).resolves.toEqual([]);
+    });
+});