@lapis-notes/history 0.1.2 → 0.2.0

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

@@ -0,0 +1,33 @@
+import type { HistorySource, HistorySourcePicker } from "../controllers/history-source.js";
+import { Plugin, type App } from "@lapis-notes/api";
+import { HistoryController } from "../controllers/history-controller.js";
+import { OperationController } from "../controllers/operation-controller.js";
+import { FileHistoryController } from "../controllers/file-history-controller.js";
+import { BlameController } from "../controllers/blame-controller.js";
+import { RepositoryBackup } from "./repository-backup.js";
+type RepositoryController = HistoryController | OperationController | FileHistoryController | BlameController;
+export declare class RepositoryPlugin extends Plugin {
+    #private;
+    backup?: RepositoryBackup;
+    get restoreService(): import("../controllers/restore.js").RestoreService | undefined;
+    constructor(app: App);
+    feedback(title?: string, identity?: string): {
+        report: (error: unknown) => import("@lapis-notes/api").AppDatabaseNotificationRecord;
+        recovered: () => void;
+    };
+    reader(source: HistorySource): import("../index.js").HistoryReader;
+    sourcePicker(source: HistorySource, select: HistorySourcePicker["select"]): HistorySourcePicker | undefined;
+    createController(source?: HistorySource): HistoryController;
+    createOperationController(source?: HistorySource): OperationController;
+    release(controller: RepositoryController): Promise<void>;
+    createFileHistoryController(): FileHistoryController;
+    onload(): Promise<void>;
+    copyIdentifier(value: string): Promise<void>;
+    report(error: unknown): void;
+    open(operation?: string, revision?: string, source?: HistorySource): Promise<void>;
+    openOperations(source?: HistorySource): Promise<void>;
+    createBlameController(source?: HistorySource): BlameController;
+    openBlame(operation: string, commit: string, path: string, source?: HistorySource): Promise<void>;
+    onunload(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,191 @@
+import { repositoryFeedback, copyRepositoryIdentifier, reportRepositoryError, } from "./repository-feedback.js";
+import { openRepositoryView } from "./repository-navigation.js";
+import { Plugin } from "@lapis-notes/api";
+import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
+import { HistoryController } from "../controllers/history-controller.js";
+import { ownedRepository, repositoryLeaveMode, } from "../controllers/services.js";
+import { OperationController } from "../controllers/operation-controller.js";
+import { OperationView } from "./operation-view.js";
+import { RepositoryView } from "./repository-view.js";
+import { BackgroundWork } from "../controllers/background-work.js";
+import { FileHistoryController } from "../controllers/file-history-controller.js";
+import { registerFileHistoryView } from "./file-history-view.js";
+import { BlameController } from "../controllers/blame-controller.js";
+import { BlameView } from "./blame/blame-view.js";
+import { registerBlameEditorActions } from "./blame/editor-actions.js";
+import { RepositoryStatus } from "./repository-status.js";
+import { RepositoryBackup } from "./repository-backup.js";
+import { registerRepositoryTools } from "./repository-tools.js";
+import { bindAiHistory } from "../controllers/ai-history.js";
+import { guardTranscriptReplacement } from "../controllers/transcript-writers.js";
+export class RepositoryPlugin extends Plugin {
+    backup;
+    get restoreService() {
+        return this.#services?.restore;
+    }
+    #services;
+    #status;
+    #closeTools;
+    #closeAiHistory;
+    #controllers = new Set();
+    #activities = new Map();
+    #closing;
+    constructor(app) {
+        super(app, {
+            id: "repository-history",
+            name: "Repository History",
+            version: "0.1.0",
+            minAppVersion: "0.0.1",
+            author: "Lapis Notes",
+            description: "Read pinned JJ history and compare revisions in the vault.",
+        });
+    }
+    feedback(title = "Repository history", identity) {
+        if (!this.#services || this.#closing)
+            throw new Error("Repository history is closed");
+        return repositoryFeedback(this.app, title, identity);
+    }
+    reader(source) {
+        const reader = source === "backup" ? this.#services?.reader : this.#services?.original;
+        if (!reader)
+            throw new Error("This history source is unavailable");
+        return reader;
+    }
+    sourcePicker(source, select) {
+        if (!this.#services?.sources)
+            return;
+        return {
+            selected: source,
+            load: this.#services.sources,
+            select,
+            report: (error) => this.report(error),
+        };
+    }
+    createController(source = "backup") {
+        const feedback = this.feedback();
+        const controller = new HistoryController(this.reader(source), feedback);
+        this.#controllers.add(controller);
+        this.#activities.set(controller, new BackgroundWork(this.app.notifications, "repository-history").follow("Loading JJ Log", controller));
+        return controller;
+    }
+    createOperationController(source = "backup") {
+        const feedback = this.feedback("Repository operation log");
+        const controller = new OperationController(this.reader(source), feedback);
+        this.#controllers.add(controller);
+        this.#activities.set(controller, new BackgroundWork(this.app.notifications, "repository-history").follow("Loading Op Log", controller));
+        return controller;
+    }
+    async release(controller) {
+        await controller.close();
+        this.#activities.get(controller)?.();
+        this.#activities.delete(controller);
+        this.#controllers.delete(controller);
+    }
+    createFileHistoryController() {
+        const controller = new FileHistoryController(this.#services.reader, this.feedback("File history"));
+        this.#controllers.add(controller);
+        this.#activities.set(controller, new BackgroundWork(this.app.notifications, "repository-history").follow("Loading file history", controller));
+        return controller;
+    }
+    async onload() {
+        this.#closing = undefined;
+        this.#services = ownedRepository(this.app);
+        if (this.#services.backup) {
+            this.backup = new RepositoryBackup(this, this.#services);
+            await this.backup.start();
+        }
+        this.#closeTools = registerRepositoryTools(this, this.#services);
+        if (this.#services.aiHistory)
+            this.#closeAiHistory = bindAiHistory(this.app, {
+                service: this.#services.aiHistory,
+                reader: this.#services.reader,
+                enabled: () => !!this.backup?.enabled && !this.#closing,
+                guard: (action) => guardTranscriptReplacement(this.app, undefined, action),
+                reveal: (record) => this.open(record.after?.operation ?? record.before.operation, record.after?.commit ?? record.before.commit),
+            });
+        registerFileHistoryView(this);
+        registerBlameEditorActions(this);
+        this.registerView("repository-file-blame", (leaf) => new BlameView(leaf, this));
+        this.registerView("repository-history", (leaf) => new RepositoryView(leaf, this), {
+            kind: "command",
+            command: {
+                id: "open-history",
+                name: "Open Repository History",
+                callback: () => {
+                    void this.open().catch((error) => this.report(error));
+                },
+            },
+        });
+        this.registerView("repository-oplog", (leaf) => new OperationView(leaf, this), {
+            kind: "command",
+            command: {
+                id: "open-oplog",
+                name: "Open Repository Op Log",
+                callback: () => {
+                    void this.openOperations().catch((error) => this.report(error));
+                },
+            },
+        });
+        this.addRibbonIcon("git-pull-request-arrow", "Repository Op Log", () => {
+            void this.openOperations().catch((error) => this.report(error));
+        });
+        this.addRibbonIcon("git-branch", "Repository History", () => {
+            void this.open().catch((error) => this.report(error));
+        });
+        this.#status = new RepositoryStatus(this, this.#services);
+        await this.#status.start();
+    }
+    async copyIdentifier(value) {
+        return copyRepositoryIdentifier(this.app, value);
+    }
+    report(error) {
+        reportRepositoryError(this.app, error);
+    }
+    async open(operation, revision, source = "backup") {
+        await openRepositoryView(getWorkspaceHostBinding(this.app.workspace).controller.workspace, "repository-history", source, operation ? { operation, revision } : {});
+    }
+    async openOperations(source = "backup") {
+        await openRepositoryView(getWorkspaceHostBinding(this.app.workspace).controller.workspace, "repository-oplog", source);
+    }
+    createBlameController(source = "backup") {
+        const controller = new BlameController(this.reader(source), this.feedback("File blame"));
+        this.#controllers.add(controller);
+        this.#activities.set(controller, new BackgroundWork(this.app.notifications, "repository-history").follow("Loading file blame", {
+            subscribe: (listener) => controller.subscribe((state) => listener({
+                busy: state.busy,
+                phase: state.status === "failed" ? "unavailable" : state.status,
+            })),
+        }));
+        return controller;
+    }
+    async openBlame(operation, commit, path, source = "backup") {
+        await openRepositoryView(getWorkspaceHostBinding(this.app.workspace).controller.workspace, "repository-file-blame", source, {
+            operation,
+            commit,
+            path,
+        });
+    }
+    async onunload() {
+        return (this.#closing ??= (async () => {
+            this.#closeAiHistory?.();
+            this.#closeAiHistory = undefined;
+            await this.#closeTools?.();
+            this.#closeTools = undefined;
+            await this.#status?.close();
+            await this.backup?.close();
+            this.backup = undefined;
+            this.#status = undefined;
+            await Promise.allSettled([...this.#controllers].map((controller) => controller.close()));
+            // Full native release proves closure even after an unknown per-handle outcome.
+            await this.#services?.close(repositoryLeaveMode(this.app));
+            for (const dispose of this.#activities.values())
+                dispose();
+            this.#activities.clear();
+            this.#controllers.clear();
+            this.#services = undefined;
+        })().catch((error) => {
+            this.#closing = undefined;
+            throw error;
+        }));
+    }
+}

package/dist/repository/components/repository-review-identifiers.css

@@ -0,0 +1,50 @@
+/* Source-style presentation for application-owned ID controls.
+ * jj-store revision-graph-ids.css + CommunityChip inline/square/muted at 5b119667.
+ */
+:is(.repository-shell, .repository-review-identifier-surface)
+  .repository-identifiers__split-button {
+  align-items: center;
+  justify-content: center;
+  line-height: 1rem;
+}
+:is(.repository-shell, .repository-review-identifier-surface)
+  .repository-identifiers__split-button
+  code {
+  height: 1rem;
+  line-height: 1rem;
+  text-align: center;
+}
+:is(.repository-shell, .repository-review-identifier-surface)
+  .repository-identifiers__split-button[data-side="change"] {
+  color: color-mix(in srgb, var(--primary) 40%, var(--foreground));
+}
+:is(.repository-shell, .repository-review-identifier-surface)
+  .repository-id-chip {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  width: fit-content;
+  max-width: 100%;
+  height: 1rem;
+  min-height: 0;
+  gap: 0.22em;
+  border: 0;
+  border-radius: 0.28rem;
+  padding: 0 0.25em;
+  color: inherit;
+  background: color-mix(in srgb, currentcolor 7%, transparent);
+  box-decoration-break: clone;
+  -webkit-box-decoration-break: clone;
+  font: inherit;
+  font-family: var(--font-mono, monospace);
+  font-weight: 600;
+  line-height: 1rem;
+  text-align: center;
+  vertical-align: middle;
+}
+:is(.repository-shell, .repository-review-identifier-surface)
+  .repository-identifiers__split-button[data-copied] {
+  color: color-mix(in srgb, #16a34a 50%, var(--foreground));
+  background: color-mix(in srgb, #16a34a 14%, var(--background));
+}

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

@@ -0,0 +1,13 @@
+import type { RepositoryServices } from "../controllers/history-reader.js";
+import type { RepositoryPlugin } from "./repository-plugin.js";
+export declare const WORKING_COPY_SETTING = "repository-history.showWorkingCopyStatus";
+export declare function showWorkingCopyStatus(stored: unknown): boolean;
+/** Settings, contribution and refresh lifetime belong to the enabled plugin. */
+export declare class RepositoryStatus {
+    #private;
+    private readonly plugin;
+    private readonly services;
+    constructor(plugin: RepositoryPlugin, services: RepositoryServices);
+    start(): Promise<void>;
+    close(): Promise<void>;
+}

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;
+}