@lapis-notes/history 0.1.4 → 0.2.2

package/dist/repository/components/repository-status.js

@@ -0,0 +1,227 @@
+import { mount, unmount } from "svelte";
+import { WorkingCopyController } from "../controllers/working-copy-controller.js";
+import { BackgroundWork } from "../controllers/background-work.js";
+import RepositoryWorkingCopyStatus from "./RepositoryWorkingCopyStatus.svelte";
+import RepositoryBackupStatus from "./RepositoryBackupStatus.svelte";
+import { RESTORE_NOTICE } from "./restore-controller.js";
+import { createBackupSettings } from "./backup/backup-settings.js";
+import RepositorySettingsPage from "./backup/RepositorySettingsPage.svelte";
+import { updateRepositoryData } from "../controllers/plugin-data.js";
+import { AUTOMATIC_BACKUP_SETTING, automaticBackup, } from "./repository-backup.js";
+export const WORKING_COPY_SETTING = "repository-history.showWorkingCopyStatus";
+export function showWorkingCopyStatus(stored) {
+    if (!stored || typeof stored !== "object")
+        return true;
+    const value = stored.showWorkingCopyStatus;
+    return typeof value === "boolean" ? value : true;
+}
+/** Settings, contribution and refresh lifetime belong to the enabled plugin. */
+export class RepositoryStatus {
+    plugin;
+    services;
+    #data = {};
+    #controller;
+    #remove;
+    #events;
+    #closed = false;
+    #transition = Promise.resolve();
+    #settings;
+    constructor(plugin, services) {
+        this.plugin = plugin;
+        this.services = services;
+    }
+    async start() {
+        this.#data = (await this.plugin.loadData()) ?? {};
+        if (this.#data.pendingRestore || this.#data.pendingRemoteRestore)
+            this.plugin.app.notifications.notify({
+                id: RESTORE_NOTICE,
+                title: "Restore needs review",
+                message: this.#data.pendingRemoteRestore
+                    ? "Open backup settings to check the interrupted remote restore."
+                    : "Open Repository History to check the interrupted restore.",
+                source: this.plugin.id,
+                severity: "warning",
+                persist: false,
+            });
+        this.#settings = createBackupSettings(this.plugin, this.services);
+        this.plugin.registerSettingsSection({
+            section: {
+                id: "repository-history",
+                title: "Repository History",
+                icon: "git-branch",
+                description: "Automatic local history and backup status.",
+                order: 46,
+                navigationGroupId: "core-plugins",
+                sourcePluginId: this.plugin.id,
+                page: this.#settings ? RepositorySettingsPage : undefined,
+                fields: [
+                    ...(this.services.backup
+                        ? [
+                            {
+                                id: AUTOMATIC_BACKUP_SETTING,
+                                type: "boolean",
+                                title: "Automatic local history",
+                                description: "Keep recoverable versions of saved files while this vault is open.",
+                                default: true,
+                            },
+                        ]
+                        : []),
+                    {
+                        id: WORKING_COPY_SETTING,
+                        type: "boolean",
+                        title: "Show working copy status",
+                        description: "Show repository status in the status bar. Hiding it does not stop automatic backups.",
+                        default: true,
+                    },
+                    ...(this.#settings ? [this.#settings.field] : []),
+                ],
+            },
+            source: {
+                get: (id) => id === AUTOMATIC_BACKUP_SETTING
+                    ? automaticBackup(this.#data)
+                    : showWorkingCopyStatus(this.#data),
+                set: async (id, value) => {
+                    if (![WORKING_COPY_SETTING, AUTOMATIC_BACKUP_SETTING].includes(id) ||
+                        typeof value !== "boolean")
+                        throw new Error("Unknown repository setting");
+                    if (id === AUTOMATIC_BACKUP_SETTING &&
+                        this.services.backup?.setEnabled) {
+                        try {
+                            await this.plugin.backup?.setEnabled(value);
+                        }
+                        finally {
+                            this.#data = (await this.plugin.loadData()) ?? {};
+                            await this.#apply();
+                        }
+                        return;
+                    }
+                    const key = id === AUTOMATIC_BACKUP_SETTING
+                        ? "automaticBackup"
+                        : "showWorkingCopyStatus";
+                    this.#data = await updateRepositoryData(this.plugin, {
+                        [key]: value,
+                    });
+                    if (id === AUTOMATIC_BACKUP_SETTING)
+                        await this.plugin.backup?.setEnabled(value);
+                    await this.#apply();
+                },
+                subscribe: (listener) => {
+                    const ref = this.plugin.app.configuration.on("plugin-data-updated", (event) => {
+                        if (event.pluginId !== this.plugin.id)
+                            return;
+                        this.#data =
+                            event.value && typeof event.value === "object"
+                                ? event.value
+                                : {};
+                        void this.#apply().catch((error) => this.plugin.report(error));
+                        listener();
+                    });
+                    return () => this.plugin.app.configuration.offref(ref);
+                },
+            },
+        });
+        await this.#apply();
+    }
+    #apply() {
+        return (this.#transition = this.#transition.then(async () => {
+            if (!this.#closed)
+                await this.plugin.backup?.reconcile(automaticBackup(this.#data));
+            if (this.#closed || !showWorkingCopyStatus(this.#data)) {
+                await this.#hide();
+                return;
+            }
+            if (this.plugin.backup) {
+                if (this.#remove)
+                    return;
+                const controller = this.plugin.backup.controller;
+                this.#remove = this.plugin.app.statusBar.registerItem({
+                    id: "repository-history:working-copy",
+                    sourcePlugin: this.plugin.id,
+                    alignment: "left",
+                    priority: 15,
+                    mount: (host) => {
+                        const component = mount(RepositoryBackupStatus, {
+                            target: host,
+                            props: {
+                                controller,
+                                upstream: this.plugin.backup?.sync?.controller,
+                                openRevision: (operation, revision) => this.plugin
+                                    .open(operation, revision)
+                                    .catch((error) => this.plugin.report(error)),
+                                copyText: (value) => this.plugin.copyIdentifier(value),
+                            },
+                        });
+                        return () => {
+                            void unmount(component);
+                        };
+                    },
+                });
+                return;
+            }
+            if (this.#controller || !this.services.workingCopy)
+                return;
+            const controller = new WorkingCopyController(this.services.workingCopy, this.plugin.feedback("Working copy status"));
+            this.#controller = controller;
+            const activity = new BackgroundWork(this.plugin.app.notifications, this.plugin.id).follow("Reading working copy status", {
+                subscribe: (listener) => controller.subscribe((state) => listener({ busy: state.busy, phase: state.status })),
+            });
+            this.#remove = this.plugin.app.statusBar.registerItem({
+                id: "repository-history:working-copy",
+                sourcePlugin: this.plugin.id,
+                alignment: "left",
+                priority: 15,
+                mount: (host) => {
+                    const component = mount(RepositoryWorkingCopyStatus, {
+                        target: host,
+                        props: {
+                            controller,
+                            openRevision: (operation, revision) => this.plugin
+                                .open(operation, revision)
+                                .catch((error) => this.plugin.report(error)),
+                            copyText: (value) => this.plugin.copyIdentifier(value),
+                        },
+                    });
+                    return () => {
+                        void unmount(component);
+                    };
+                },
+            });
+            let timer;
+            const changed = () => {
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    void controller.refresh();
+                }, 1000);
+            };
+            const vault = this.plugin.app.vault;
+            const modify = vault.on("modify", changed), create = vault.on("create", changed), remove = vault.on("delete", changed), rename = vault.on("rename", changed);
+            const interval = setInterval(changed, 60_000);
+            this.#events = () => {
+                clearTimeout(timer);
+                clearInterval(interval);
+                vault.offref(modify);
+                vault.offref(create);
+                vault.offref(remove);
+                vault.offref(rename);
+                // Keep progress until the actual read has drained.
+                void controller.close().finally(activity);
+            };
+            void controller.refresh();
+        }));
+    }
+    async #hide() {
+        const controller = this.#controller;
+        this.#controller = undefined;
+        this.#remove?.();
+        this.#remove = undefined;
+        this.#events?.();
+        this.#events = undefined;
+        await controller?.close();
+    }
+    async close() {
+        this.#closed = true;
+        await this.#transition;
+        await this.#hide();
+        await this.#settings?.close();
+    }
+}

package/dist/repository/components/repository-sync.d.ts

@@ -0,0 +1,13 @@
+import type { RepositoryPlugin } from "./repository-plugin.js";
+import type { RepositoryServices } from "../controllers/history-reader.js";
+import { SyncController } from "../controllers/sync-controller.js";
+/** Open-vault lifetime; independent of settings and status visibility. */
+export declare class RepositorySync {
+    #private;
+    readonly plugin: RepositoryPlugin;
+    readonly controller: SyncController;
+    constructor(plugin: RepositoryPlugin, services: RepositoryServices);
+    start(): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    close(): void;
+}

package/dist/repository/components/repository-sync.js

@@ -0,0 +1,93 @@
+import { guardTranscriptReplacement } from "../controllers/transcript-writers.js";
+import { SyncController } from "../controllers/sync-controller.js";
+import { syncRecovery } from "../controllers/sync-recovery.js";
+import { updateRepositoryData } from "../controllers/plugin-data.js";
+import { BackgroundWork } from "../controllers/background-work.js";
+/** Open-vault lifetime; independent of settings and status visibility. */
+export class RepositorySync {
+    plugin;
+    controller;
+    #stops = [];
+    #timer;
+    #closed = false;
+    #enabled = true;
+    #ready = false;
+    #attempt = 0;
+    #checkpoint;
+    #failed = false;
+    #busy = false;
+    #retryAfter = 0;
+    constructor(plugin, services) {
+        this.plugin = plugin;
+        this.controller = new SyncController(services.remote, services.sync, (action) => guardTranscriptReplacement(plugin.app, undefined, action), plugin.feedback("Vault synchronization", "repository-history:sync"), syncRecovery(plugin));
+        plugin.addCommand({
+            id: "synchronize-backup",
+            name: "Synchronize vault backup",
+            callback: () => this.controller.run(),
+        });
+    }
+    async start() {
+        this.#enabled = (await this.plugin.loadData())?.automaticSync !== false;
+        if (this.#closed)
+            return;
+        this.#stops.push(this.plugin.backup.controller.subscribe((status) => {
+            this.#ready = status.phase === "ready";
+            if (status.phase === "closed")
+                this.controller.setEnabled(false);
+            else if (this.#ready) {
+                this.controller.setEnabled(this.#enabled);
+                if (status.checkpoint?.commit !== this.#checkpoint) {
+                    this.#checkpoint = status.checkpoint?.commit;
+                    this.#schedule(5000);
+                }
+            }
+        }));
+        const progress = new BackgroundWork(this.plugin.app.notifications, this.plugin.id).follow("Synchronizing vault backup", {
+            subscribe: (listener) => this.controller.subscribe((state) => listener({ busy: state.busy, phase: state.phase })),
+        });
+        this.#stops.push(this.controller.subscribe((snapshot) => {
+            this.#failed = snapshot.phase === "attention";
+            this.#busy = snapshot.busy;
+        }));
+        this.#stops.push(() => {
+            void this.controller.drained().finally(progress);
+        });
+        this.#schedule(1000);
+    }
+    #schedule(delay) {
+        if (this.#closed)
+            return;
+        if (this.#timer)
+            clearTimeout(this.#timer);
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            if (this.#ready && this.#enabled && !this.#busy) {
+                void this.controller.run().finally(() => {
+                    this.#attempt = this.#failed ? Math.min(this.#attempt + 1, 4) : 0;
+                    const delay = 60_000 * 2 ** this.#attempt;
+                    this.#retryAfter = this.#failed ? Date.now() + delay : 0;
+                    this.#schedule(delay);
+                });
+            }
+            else
+                this.#schedule(this.#busy ? 5000 : 60_000);
+        }, Math.max(delay, this.#retryAfter - Date.now()));
+    }
+    async setEnabled(enabled) {
+        await updateRepositoryData(this.plugin, { automaticSync: enabled });
+        this.#enabled = enabled;
+        this.controller.setEnabled(enabled && this.#ready);
+        this.#attempt = 0;
+        this.#retryAfter = 0;
+        this.#schedule(1000);
+    }
+    close() {
+        this.#closed = true;
+        if (this.#timer)
+            clearTimeout(this.#timer);
+        this.controller.close();
+        for (const stop of this.#stops)
+            stop();
+        this.#stops = [];
+    }
+}

package/dist/repository/components/repository-tools.d.ts

@@ -0,0 +1,3 @@
+import type { RepositoryPlugin } from "./repository-plugin.js";
+import type { RepositoryServices } from "../controllers/history-reader.js";
+export declare function registerRepositoryTools(plugin: RepositoryPlugin, services: RepositoryServices): () => Promise<void>;

package/dist/repository/components/repository-tools.js

@@ -0,0 +1,13 @@
+import { registerHistoryResultProvider } from "./search/search-provider.js";
+import { nativeIndexedHistory } from "../controllers/native-indexed-search.js";
+export function registerRepositoryTools(plugin, services) {
+    const indexed = plugin.app.nativeHistoryIndex
+        ? nativeIndexedHistory(plugin.app.nativeHistoryIndex)
+        : services.search?.indexed;
+    const search = indexed
+        ? registerHistoryResultProvider(plugin, indexed)
+        : async () => { };
+    return async () => {
+        await search();
+    };
+}

package/dist/repository/components/repository-view.d.ts

@@ -0,0 +1,16 @@
+import { View, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { RepositoryPlugin } from "./repository-plugin.js";
+export declare class RepositoryView extends View {
+    #private;
+    private readonly plugin;
+    constructor(leaf: WorkspaceLeaf, plugin: RepositoryPlugin);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    getState(): Record<string, unknown>;
+    setState(state: Record<string, unknown>): Promise<void>;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    onunload(): void;
+}

package/dist/repository/components/repository-view.js

@@ -0,0 +1,140 @@
+import { historySource, } from "../controllers/history-source.js";
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import RepositoryPanel from "./RepositoryPanel.svelte";
+import { openHistoryRevision } from "../controllers/open-history-revision.js";
+import { RestoreController } from "../controllers/restore.js";
+import { createRestoreController } from "./restore-controller.js";
+import { BackgroundWork } from "../controllers/background-work.js";
+import { followBackup } from "../controllers/backup-follow.js";
+export class RepositoryView extends View {
+    plugin;
+    #controller;
+    #component;
+    #source = "backup";
+    #operation;
+    #revision;
+    #unsubscribe;
+    #initialLoad;
+    #stateRequest = 0;
+    #restore;
+    #restoreActivity;
+    #live;
+    constructor(leaf, plugin) {
+        super(leaf);
+        this.plugin = plugin;
+    }
+    getViewType() {
+        return "repository-history";
+    }
+    getDisplayText() {
+        return this.#source === "original"
+            ? "Original repository history"
+            : "Repository history";
+    }
+    getIcon() {
+        return "git-branch";
+    }
+    getState() {
+        return this.#controller
+            ? {
+                source: this.#source,
+                operation: this.#controller.pinned
+                    ? this.#controller.state.operation
+                    : undefined,
+                revision: this.#controller.state.revision?.id,
+            }
+            : {
+                source: this.#source,
+                operation: this.#operation,
+                revision: this.#revision,
+            };
+    }
+    async setState(state) {
+        const source = historySource(state);
+        if (this.#controller && source !== this.#source)
+            throw new Error("Open a separate tab to change history source");
+        this.#source = source;
+        const request = ++this.#stateRequest;
+        const operation = (this.#operation =
+            typeof state.operation === "string" ? state.operation : undefined);
+        const revision = (this.#revision =
+            typeof state.revision === "string" ? state.revision : undefined);
+        const controller = this.#controller;
+        if (controller) {
+            await this.#initialLoad;
+            if (request !== this.#stateRequest)
+                return;
+            if (operation && operation !== controller.state.operation)
+                await controller.selectOperation(operation);
+            if (request !== this.#stateRequest)
+                return;
+            if (revision)
+                await openHistoryRevision(controller, revision);
+        }
+        await super.setState(state);
+    }
+    async onOpen() { }
+    async onClose() { }
+    onload() {
+        this.#controller = this.plugin.createController(this.#source);
+        if (this.#source === "backup" && this.plugin.restoreService) {
+            this.#restore = createRestoreController(this.plugin);
+            this.#restoreActivity = new BackgroundWork(this.app.notifications, this.plugin.id).follow("Restoring file history", {
+                subscribe: (listener) => this.#restore.subscribe((state) => listener({
+                    busy: state.busy,
+                    phase: state.open ? "restoring" : "ready",
+                })),
+            });
+        }
+        this.#unsubscribe = this.#controller.subscribe((state) => {
+            if (state.operation !== undefined &&
+                state.operation !== this.#operation) {
+                this.#operation = state.operation;
+                this.app.workspace.requestSaveLayout({
+                    source: "api",
+                    operation: "repository-history",
+                });
+            }
+        });
+        this.#initialLoad = this.#controller.refresh(this.#operation);
+        void this.#initialLoad.then(() => {
+            if (this.#controller)
+                this.#live = followBackup(this.#source === "backup"
+                    ? this.plugin.backup?.controller
+                    : undefined, this.#controller);
+        });
+        this.#component = mount(RepositoryPanel, {
+            target: this.containerEl,
+            props: {
+                controller: this.#controller,
+                sources: this.plugin.sourcePicker(this.#source, (source) => {
+                    void this.plugin
+                        .open(undefined, undefined, source)
+                        .catch((error) => this.plugin.report(error));
+                }),
+                restore: this.#restore,
+                initialOperation: this.#operation,
+                initialRevision: this.#revision,
+                initialLoad: this.#initialLoad,
+                copyText: (value) => this.plugin.copyIdentifier(value),
+            },
+        });
+    }
+    onunload() {
+        this.#live?.();
+        this.#restore?.close();
+        this.#restoreActivity?.();
+        this.#stateRequest++;
+        this.#unsubscribe?.();
+        if (this.#component)
+            void unmount(this.#component);
+        this.#component = undefined;
+        if (this.#controller)
+            void this.plugin
+                .release(this.#controller)
+                .catch((error) => this.plugin.report(error));
+        this.#controller = undefined;
+        this.#initialLoad = undefined;
+    }
+}

package/dist/repository/components/restore-controller.d.ts

@@ -0,0 +1,9 @@
+import { RestoreController } from "../controllers/restore.js";
+import type { RepositoryPlugin } from "./repository-plugin.js";
+import type { RestoreService } from "../controllers/restore.js";
+export declare const RESTORE_NOTICE = "repository-history:pending-restore";
+export declare function createRestoreController(plugin: RepositoryPlugin, options?: {
+    service?: RestoreService;
+    key?: "pendingRestore" | "pendingRemoteRestore";
+    title?: string;
+}): RestoreController | undefined;

package/dist/repository/components/restore-controller.js

@@ -0,0 +1,44 @@
+import { guardTranscriptReplacement } from "../controllers/transcript-writers.js";
+import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
+import { RestoreController } from "../controllers/restore.js";
+import { restoreRecovery } from "../controllers/restore-recovery.js";
+import { updateRepositoryData } from "../controllers/plugin-data.js";
+export const RESTORE_NOTICE = "repository-history:pending-restore";
+export function createRestoreController(plugin, options = {}) {
+    const key = options.key ?? "pendingRestore";
+    let original;
+    const service = options.service ?? plugin.restoreService;
+    if (!service)
+        return;
+    const feedback = plugin.feedback(options.title ?? "Restore history", key === "pendingRestore"
+        ? "repository-history:restore"
+        : "repository-history:remote-restore");
+    const controller = new RestoreController(service, (path, action) => guardTranscriptReplacement(plugin.app, path, action), feedback, async (pending) => {
+        if (pending)
+            original = pending.request.request_id;
+        const own = original;
+        const saved = await updateRepositoryData(plugin, (current) => {
+            if (pending)
+                return { [key]: pending };
+            const retained = restoreRecovery(current[key]);
+            return own && retained?.request.request_id === own
+                ? { [key]: null }
+                : {};
+        });
+        if (!saved.pendingRestore && !saved.pendingRemoteRestore) {
+            getWorkspaceHostBinding(plugin.app.workspace).controller.notifications.dismiss(RESTORE_NOTICE);
+            await plugin.app.notifications.clear(RESTORE_NOTICE);
+        }
+    });
+    void plugin
+        .loadData()
+        .then((data) => {
+        const pending = restoreRecovery(data?.[key]);
+        if (pending) {
+            original ??= pending.request.request_id;
+            controller.recover(pending);
+        }
+    })
+        .catch((error) => feedback.report(error));
+    return controller;
+}

package/dist/repository/components/search/search-provider.d.ts

@@ -0,0 +1,3 @@
+import type { IndexedHistoryService } from "../../controllers/indexed-search.js";
+import type { RepositoryPlugin } from "../repository-plugin.js";
+export declare function registerHistoryResultProvider(plugin: RepositoryPlugin, service: IndexedHistoryService): () => Promise<void>;