@lapis-notes/history 0.1.0

package/dist/history-plugin.js

@@ -0,0 +1,435 @@
+import { dirname, md5, normalizePath, Plugin, TFile, } from "@lapis-notes/api";
+import { consumeSuppressedHash, shouldReplaceLatestModify, } from "./history-capture";
+import { mergeHistorySettings, patchHistorySettings, } from "./history-settings";
+import { HistorySettingsTab } from "./history-settings-tab";
+import { registerHistorySettings } from "./register-history-settings";
+import { isHistoryTrackedFile } from "./history-tracking";
+import { HistoryCompareView } from "./history-compare-view";
+import { HistoryView } from "./history-view";
+import { HistoryCompareViewType, HistoryViewType, } from "./history-view-type";
+import manifestSpec from "../../manifest.json";
+export const HISTORY_PLUGIN_ID = "history";
+function orderNewestFirst(revisions) {
+    return [...revisions].sort((left, right) => right.createdAt - left.createdAt);
+}
+function toPluginHistory(history) {
+    if (!history)
+        return null;
+    return {
+        file: {
+            id: history.file.fileId,
+            path: history.file.currentPath,
+            deleted: history.file.deleted,
+        },
+        revisions: orderNewestFirst(history.revisions.map((revision) => ({
+            revisionId: revision.revisionId,
+            path: revision.currentPath,
+            previousPath: revision.eventType === "rename" ? revision.capturedPath : undefined,
+            eventType: revision.eventType,
+            createdAt: revision.createdAt,
+            sourceMtime: revision.sourceMtime,
+            sourceSize: revision.sourceSize,
+            contentHash: revision.contentHash,
+            content: revision.content,
+        }))),
+    };
+}
+export class HistoryPlugin extends Plugin {
+    settings = mergeHistorySettings(null);
+    currentFilePath = null;
+    compareAnchor = null;
+    pendingCaptures = new Map();
+    lastModifyStoredAt = new Map();
+    suppressedHashes = new Map();
+    listeners = new Set();
+    constructor(app, manifest = manifestSpec) {
+        super(app, manifest);
+    }
+    async onload() {
+        this.settings = mergeHistorySettings(await this.loadData());
+        this.addSettingTab(new HistorySettingsTab(this.app, this));
+        registerHistorySettings(this);
+        this.registerSidebarView(HistoryViewType, (leaf) => new HistoryView(leaf), { side: "right", title: "History", icon: "history" }, {
+            kind: "command",
+            command: {
+                id: "open-file-history",
+                name: "Open file history",
+                callback: () => void this.openHistoryView(),
+            },
+        });
+        this.registerView(HistoryCompareViewType, (leaf) => new HistoryCompareView(this, leaf), { kind: "internal" });
+        this.registerEvent(this.app.workspace.on("file-open", (file) => {
+            if (file instanceof TFile) {
+                this.setCurrentFilePath(file.path);
+                void this.ensureBaselineForFile(file);
+            }
+        }));
+        this.registerEvent(this.app.workspace.on("active-leaf-change", () => {
+            const file = this.getFocusedFile();
+            if (file)
+                this.setCurrentFilePath(file.path);
+        }));
+        this.registerEvent(this.app.vault.on("create", (file) => {
+            if (file instanceof TFile)
+                this.scheduleCapture(file, "create");
+        }));
+        this.registerEvent(this.app.vault.on("modify", (file) => {
+            if (file instanceof TFile)
+                this.scheduleCapture(file, "modify");
+        }));
+        this.registerEvent(this.app.vault.on("rename", (file, oldPath) => {
+            if (!(file instanceof TFile))
+                return;
+            if (this.currentFilePath === oldPath)
+                this.setCurrentFilePath(file.path);
+            if (this.compareAnchor?.filePath === oldPath) {
+                this.compareAnchor = {
+                    filePath: file.path,
+                    revisionId: this.compareAnchor.revisionId,
+                };
+            }
+            void this.captureRename(file, oldPath);
+        }));
+        this.registerEvent(this.app.vault.on("delete", (file) => {
+            if (file instanceof TFile)
+                void this.captureDelete(file);
+        }));
+        const initialFile = this.getFocusedFile();
+        if (initialFile) {
+            this.setCurrentFilePath(initialFile.path);
+            void this.ensureBaselineForFile(initialFile);
+        }
+        this.register(() => {
+            for (const timer of this.pendingCaptures.values())
+                clearTimeout(timer);
+            this.pendingCaptures.clear();
+        });
+    }
+    getSettings() {
+        return mergeHistorySettings(this.settings);
+    }
+    async updateSettings(patch) {
+        this.settings = patchHistorySettings(this.settings, patch);
+        await this.saveData(this.settings);
+        this.notify();
+    }
+    onHistoryChanged(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getCompareAnchor() {
+        return this.compareAnchor;
+    }
+    setCompareAnchor(anchor) {
+        this.compareAnchor = anchor;
+        this.notify();
+    }
+    toggleCompareAnchor(filePath, revisionId) {
+        if (this.compareAnchor?.filePath === filePath &&
+            this.compareAnchor.revisionId === revisionId) {
+            this.setCompareAnchor(null);
+            return;
+        }
+        this.setCompareAnchor({ filePath, revisionId });
+    }
+    async openHistoryView(filePath) {
+        const file = filePath
+            ? this.app.vault.getFileByPath(normalizePath(filePath))
+            : this.getFocusedFile();
+        if (file instanceof TFile) {
+            this.setCurrentFilePath(file.path);
+            await this.ensureBaselineForFile(file);
+        }
+        else if (filePath) {
+            this.setCurrentFilePath(filePath);
+        }
+        const existing = this.app.workspace.getLeavesOfType(HistoryViewType)[0];
+        const leaf = existing ?? this.app.workspace.ensureSideLeaf(HistoryViewType, "right");
+        await leaf.setViewState({ type: HistoryViewType });
+        this.app.workspace.activateLeaf(leaf, {
+            focusRootHost: false,
+            source: "api",
+            operation: "open-file-history",
+        });
+        await this.app.workspace.revealLeaf(leaf);
+    }
+    async openHistoryCompareView(state) {
+        const leaves = this.app.workspace.getLeavesOfType(HistoryCompareViewType);
+        const leaf = leaves[0] ?? this.app.workspace.getLeaf("tab");
+        await leaf.setViewState({
+            type: HistoryCompareViewType,
+            state: {
+                ...state,
+                sourceLeafId: state.sourceLeafId ?? this.app.workspace.activeLeaf?.id ?? undefined,
+            },
+        });
+        this.app.workspace.activateLeaf(leaf, {
+            focusRootHost: false,
+            source: "api",
+            operation: "open-history-compare",
+        });
+        await this.app.workspace.revealLeaf(leaf);
+    }
+    closeHistoryCompareView(sourceLeafId) {
+        const sourceLeaf = sourceLeafId
+            ? this.app.workspace.getLeafById(sourceLeafId)
+            : null;
+        if (sourceLeaf) {
+            this.app.workspace.activateLeaf(sourceLeaf, {
+                focusRootHost: false,
+                source: "api",
+                operation: "close-history-compare",
+            });
+            void this.app.workspace.revealLeaf(sourceLeaf);
+        }
+        this.app.workspace.getLeavesOfType(HistoryCompareViewType)[0]?.detach();
+    }
+    async getHistoryViewModel() {
+        const file = this.getFocusedFile();
+        if (file) {
+            this.setCurrentFilePath(file.path);
+            await this.ensureBaselineForFile(file);
+            const [rawHistory, currentContent] = await Promise.all([
+                this.app.appDatabase.getFileHistory(file.path),
+                this.app.vault.cachedRead(file).catch(() => ""),
+            ]);
+            return {
+                filePath: file.path,
+                history: toPluginHistory(rawHistory),
+                currentContent,
+                fileExists: true,
+            };
+        }
+        if (!this.currentFilePath) {
+            return {
+                filePath: null,
+                history: null,
+                currentContent: "",
+                fileExists: false,
+            };
+        }
+        return {
+            filePath: this.currentFilePath,
+            history: toPluginHistory(await this.app.appDatabase.getFileHistory(this.currentFilePath)),
+            currentContent: "",
+            fileExists: false,
+        };
+    }
+    async getHistoryComparisonModel(state) {
+        const filePath = normalizePath(state.filePath);
+        const history = toPluginHistory(await this.app.appDatabase.getFileHistory(filePath));
+        if (!history)
+            throw new Error("No stored history found for this file");
+        const selectedRevision = history.revisions.find((revision) => revision.revisionId === state.revisionId);
+        if (!selectedRevision) {
+            throw new Error("Selected revision is no longer available");
+        }
+        const selectedIndex = history.revisions.findIndex((revision) => revision.revisionId === selectedRevision.revisionId);
+        const previousRevision = selectedIndex >= 0 ? (history.revisions[selectedIndex + 1] ?? null) : null;
+        const otherRevision = state.otherRevisionId
+            ? (history.revisions.find((revision) => revision.revisionId === state.otherRevisionId) ?? null)
+            : null;
+        const file = this.app.vault.getFileByPath(filePath);
+        const fileExists = file instanceof TFile;
+        const currentContent = fileExists
+            ? await this.app.vault.cachedRead(file).catch(() => "")
+            : "";
+        const compareMode = state.compareMode === "selected" && otherRevision
+            ? "selected"
+            : state.compareMode === "previous" && previousRevision
+                ? "previous"
+                : "current";
+        const pair = compareMode === "selected" && otherRevision
+            ? [selectedRevision, otherRevision].sort((left, right) => left.createdAt - right.createdAt)
+            : compareMode === "previous" && previousRevision
+                ? [previousRevision, selectedRevision]
+                : [selectedRevision, { content: currentContent, createdAt: Date.now() }];
+        return {
+            filePath,
+            history,
+            currentContent,
+            fileExists,
+            compareMode,
+            selectedRevision,
+            previousRevision,
+            otherRevision,
+            compareBaseText: pair[0]?.content ?? "",
+            compareNewText: pair[1]?.content ?? "",
+            beforeLabel: compareMode === "current"
+                ? "Selected revision"
+                : formatRevisionLabel(pair[0]?.createdAt),
+            afterLabel: compareMode === "current"
+                ? fileExists
+                    ? "Current file"
+                    : "Latest"
+                : formatRevisionLabel(pair[1]?.createdAt),
+        };
+    }
+    async restoreRevision(filePath, revision) {
+        const normalizedPath = normalizePath(filePath);
+        this.suppressedHashes.set(normalizedPath, revision.contentHash);
+        const existingFile = this.app.vault.getFileByPath(normalizedPath);
+        if (existingFile instanceof TFile) {
+            await this.app.vault.modify(existingFile, revision.content);
+        }
+        else {
+            await this.app.vault.mkpath(dirname(normalizedPath));
+            await this.app.vault.create(normalizedPath, revision.content);
+        }
+        const nextFile = this.app.vault.getFileByPath(normalizedPath);
+        await this.app.appDatabase.storeFileHistoryRevision({
+            path: normalizedPath,
+            eventType: "restore",
+            createdAt: Date.now(),
+            sourceMtime: nextFile instanceof TFile ? nextFile.stat.mtime : undefined,
+            sourceSize: nextFile instanceof TFile
+                ? nextFile.stat.size
+                : revision.content.length,
+            contentHash: revision.contentHash,
+            content: revision.content,
+            maxRevisions: this.settings.retentionCount,
+        });
+        this.setCurrentFilePath(normalizedPath);
+        this.notify();
+    }
+    async saveCurrentFileContent(filePath, content) {
+        const normalizedPath = normalizePath(filePath);
+        const existingFile = this.app.vault.getFileByPath(normalizedPath);
+        if (existingFile instanceof TFile) {
+            const current = await this.app.vault.cachedRead(existingFile).catch(() => null);
+            if (current === content)
+                return;
+            await this.app.vault.modify(existingFile, content);
+        }
+        else {
+            await this.app.vault.mkpath(dirname(normalizedPath));
+            await this.app.vault.create(normalizedPath, content);
+        }
+        this.setCurrentFilePath(normalizedPath);
+        this.notify();
+    }
+    getFocusedFile() {
+        const activeLeafFile = this.app.workspace.activeLeaf?.view?.file;
+        if (activeLeafFile instanceof TFile)
+            return activeLeafFile;
+        const activeFile = this.app.workspace.getActiveFile?.();
+        return activeFile instanceof TFile ? activeFile : null;
+    }
+    setCurrentFilePath(path) {
+        const normalizedPath = path ? normalizePath(path) : null;
+        if (this.currentFilePath === normalizedPath)
+            return;
+        this.currentFilePath = normalizedPath;
+        if (this.compareAnchor && this.compareAnchor.filePath !== normalizedPath) {
+            this.compareAnchor = null;
+        }
+        this.notify();
+    }
+    scheduleCapture(file, eventType) {
+        if (!isHistoryTrackedFile(file, this.settings))
+            return;
+        const path = normalizePath(file.path);
+        const existing = this.pendingCaptures.get(path);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.pendingCaptures.delete(path);
+            void this.captureSnapshot(file, eventType);
+        }, this.settings.debounceMs);
+        this.pendingCaptures.set(path, timer);
+    }
+    async ensureBaselineForFile(file) {
+        if (!isHistoryTrackedFile(file, this.settings))
+            return;
+        const existing = await this.app.appDatabase.getFileHistory(file.path);
+        if (existing)
+            return;
+        await this.captureSnapshot(file, "baseline");
+    }
+    async captureSnapshot(file, eventType) {
+        if (!isHistoryTrackedFile(file, this.settings))
+            return;
+        let content;
+        try {
+            content = await this.app.vault.cachedRead(file);
+        }
+        catch {
+            return;
+        }
+        const path = normalizePath(file.path);
+        const contentHash = md5(content);
+        if (consumeSuppressedHash(this.suppressedHashes, path, contentHash)) {
+            return;
+        }
+        const existing = await this.app.appDatabase.getFileHistory(path);
+        const latest = existing?.revisions.at(-1);
+        const replaceLatest = shouldReplaceLatestModify(eventType, latest?.eventType, this.lastModifyStoredAt.get(path), this.settings.mergeWindowMs);
+        const result = await this.app.appDatabase.storeFileHistoryRevision({
+            path,
+            eventType,
+            createdAt: Date.now(),
+            sourceMtime: file.stat.mtime,
+            sourceSize: file.stat.size,
+            contentHash,
+            content,
+            maxRevisions: this.settings.retentionCount,
+            replaceLatest,
+        });
+        if (result.stored) {
+            if (eventType === "modify")
+                this.lastModifyStoredAt.set(path, Date.now());
+            this.notify();
+        }
+    }
+    async captureRename(file, oldPath) {
+        const hadHistory = await this.app.appDatabase.getFileHistory(oldPath);
+        if (!hadHistory && !isHistoryTrackedFile(file, this.settings))
+            return;
+        let content = hadHistory?.revisions.at(-1)?.content ?? "";
+        try {
+            if (isHistoryTrackedFile(file, this.settings)) {
+                content = await this.app.vault.cachedRead(file);
+            }
+        }
+        catch {
+            return;
+        }
+        const result = await this.app.appDatabase.storeFileHistoryRevision({
+            path: file.path,
+            previousPath: oldPath,
+            eventType: "rename",
+            createdAt: Date.now(),
+            sourceMtime: file.stat.mtime,
+            sourceSize: file.stat.size,
+            contentHash: content ? md5(content) : hadHistory?.revisions.at(-1)?.contentHash,
+            content,
+            maxRevisions: this.settings.retentionCount,
+        });
+        if (result.stored)
+            this.notify();
+    }
+    async captureDelete(file) {
+        const path = normalizePath(file.path);
+        const existing = await this.app.appDatabase.getFileHistory(path);
+        if (!existing)
+            return;
+        const result = await this.app.appDatabase.storeFileHistoryRevision({
+            path,
+            eventType: "delete",
+            createdAt: Date.now(),
+            sourceMtime: file.stat.mtime,
+            sourceSize: file.stat.size,
+            maxRevisions: this.settings.retentionCount,
+        });
+        if (result.stored)
+            this.notify();
+    }
+    notify() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+function formatRevisionLabel(value) {
+    return value ? new Date(value).toLocaleString() : "Revision";
+}
+export default HistoryPlugin;

package/dist/history-settings-tab.d.ts

@@ -0,0 +1,9 @@
+import { PluginSettingTab, type App } from "@lapis-notes/api";
+import type { HistoryPlugin } from "./history-plugin";
+export declare class HistorySettingsTab extends PluginSettingTab {
+    private readonly historyPlugin;
+    constructor(app: App, historyPlugin: HistoryPlugin);
+    display(): void;
+    private addNumber;
+    private update;
+}

package/dist/history-settings-tab.js

@@ -0,0 +1,72 @@
+import { PluginSettingTab, Setting } from "@lapis-notes/api";
+export class HistorySettingsTab extends PluginSettingTab {
+    historyPlugin;
+    constructor(app, historyPlugin) {
+        super(app, historyPlugin);
+        this.historyPlugin = historyPlugin;
+    }
+    display() {
+        const settings = this.historyPlugin.getSettings();
+        this.containerEl.empty();
+        this.addNumber("Revisions per file", "Maximum stored snapshots for one path.", settings.retentionCount, 1, 200, 1, (retentionCount) => ({ retentionCount }));
+        this.addNumber("Maximum file size (KiB)", "Files larger than this are not snapshotted.", Math.round(settings.maxFileSizeBytes / 1024), 1, 2048, 1, (kib) => ({ maxFileSizeBytes: kib * 1024 }));
+        this.addNumber("Merge window (seconds)", "Replace the latest modify for the same path when another modify arrives inside this window.", Math.round(settings.mergeWindowMs / 1000), 0, 120, 1, (seconds) => ({ mergeWindowMs: seconds * 1000 }));
+        this.addNumber("Capture debounce (ms)", "Delay before create and modify snapshots are stored.", settings.debounceMs, 0, 5000, 50, (debounceMs) => ({ debounceMs }));
+        new Setting(this.containerEl)
+            .setName("Exclude globs")
+            .setDesc("Comma-separated globs that skip capture. Defaults include .obsidian, .lapis, .git, and .jj.")
+            .addText((text) => {
+            text
+                .setPlaceholder(".obsidian/**, .lapis/**")
+                .setValue(settings.excludeGlobs.join(", "))
+                .onChange((value) => {
+                void this.update({
+                    excludeGlobs: value.split(","),
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Include globs")
+            .setDesc("Optional path allowlist. Leave empty to snapshot remaining paths after excludes.")
+            .addText((text) => {
+            text
+                .setPlaceholder("Notes/**, Projects/**")
+                .setValue(settings.includeGlobs.join(", "))
+                .onChange((value) => {
+                void this.update({
+                    includeGlobs: value.split(","),
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Tracked extensions")
+            .setDesc("Optional allowlist. Leave empty to snapshot remaining UTF-8 text under the size cap.")
+            .addText((text) => {
+            text
+                .setPlaceholder("md, json, txt")
+                .setValue(settings.trackedExtensions.join(", "))
+                .onChange((value) => {
+                void this.update({
+                    trackedExtensions: value.split(","),
+                });
+            });
+        });
+    }
+    addNumber(name, description, value, min, max, step, patch) {
+        new Setting(this.containerEl)
+            .setName(name)
+            .setDesc(description)
+            .addSlider((slider) => {
+            slider
+                .setDynamicTooltip()
+                .setLimits(min, max, step)
+                .setValue(value)
+                .onChange((next) => void this.update(patch(Number(next)), false));
+        });
+    }
+    async update(patch, redisplay = true) {
+        await this.historyPlugin.updateSettings(patch);
+        if (redisplay)
+            this.display();
+    }
+}

package/dist/history-settings.d.ts

@@ -0,0 +1,14 @@
+export interface HistoryPluginSettings {
+    retentionCount: number;
+    debounceMs: number;
+    mergeWindowMs: number;
+    maxFileSizeBytes: number;
+    excludeGlobs: string[];
+    includeGlobs: string[];
+    trackedExtensions: string[];
+}
+export type HistoryPluginSettingsPatch = Partial<HistoryPluginSettings>;
+export declare const DEFAULT_HISTORY_EXCLUDE_GLOBS: readonly [".obsidian/**", ".lapis/**", "**/.git/**", "**/.jj/**"];
+export declare const DEFAULT_HISTORY_SETTINGS: HistoryPluginSettings;
+export declare function mergeHistorySettings(stored: Partial<HistoryPluginSettings> | null | undefined): HistoryPluginSettings;
+export declare function patchHistorySettings(current: HistoryPluginSettings, patch: HistoryPluginSettingsPatch): HistoryPluginSettings;

package/dist/history-settings.js

@@ -0,0 +1,47 @@
+export const DEFAULT_HISTORY_EXCLUDE_GLOBS = [
+    ".obsidian/**",
+    ".lapis/**",
+    "**/.git/**",
+    "**/.jj/**",
+];
+export const DEFAULT_HISTORY_SETTINGS = {
+    retentionCount: 50,
+    debounceMs: 500,
+    mergeWindowMs: 10_000,
+    maxFileSizeBytes: 256 * 1024,
+    excludeGlobs: [...DEFAULT_HISTORY_EXCLUDE_GLOBS],
+    includeGlobs: [],
+    trackedExtensions: [],
+};
+function normalizeStringList(values) {
+    return [
+        ...new Set((values ?? [])
+            .flatMap((value) => value.split(","))
+            .map((value) => value.trim())
+            .filter(Boolean)),
+    ];
+}
+function normalizeExtensions(values) {
+    return [
+        ...new Set(normalizeStringList(values).map((value) => value.toLowerCase().replace(/^\.+/u, ""))),
+    ];
+}
+export function mergeHistorySettings(stored) {
+    return {
+        retentionCount: Math.max(1, Math.round(stored?.retentionCount ?? DEFAULT_HISTORY_SETTINGS.retentionCount)),
+        debounceMs: Math.max(0, Math.round(stored?.debounceMs ?? DEFAULT_HISTORY_SETTINGS.debounceMs)),
+        mergeWindowMs: Math.max(0, Math.round(stored?.mergeWindowMs ?? DEFAULT_HISTORY_SETTINGS.mergeWindowMs)),
+        maxFileSizeBytes: Math.max(1, Math.round(stored?.maxFileSizeBytes ?? DEFAULT_HISTORY_SETTINGS.maxFileSizeBytes)),
+        excludeGlobs: normalizeStringList(stored?.excludeGlobs).length > 0
+            ? normalizeStringList(stored?.excludeGlobs)
+            : [...DEFAULT_HISTORY_SETTINGS.excludeGlobs],
+        includeGlobs: normalizeStringList(stored?.includeGlobs),
+        trackedExtensions: normalizeExtensions(stored?.trackedExtensions),
+    };
+}
+export function patchHistorySettings(current, patch) {
+    return mergeHistorySettings({
+        ...current,
+        ...patch,
+    });
+}

package/dist/history-tracking.d.ts

@@ -0,0 +1,4 @@
+import { type TFile } from "@lapis-notes/api";
+import type { HistoryPluginSettings } from "./history-settings";
+export declare const HISTORY_BINARY_EXTENSIONS: Set<string>;
+export declare function isHistoryTrackedFile(file: TFile, settings: HistoryPluginSettings): boolean;

package/dist/history-tracking.js

@@ -0,0 +1,49 @@
+import { isLapisInternalPath, matchesEditorAssociationGlob, normalizePath, } from "@lapis-notes/api";
+export const HISTORY_BINARY_EXTENSIONS = new Set([
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "webp",
+    "avif",
+    "bmp",
+    "ico",
+    "pdf",
+    "zip",
+    "gz",
+    "tgz",
+    "7z",
+    "mp3",
+    "mp4",
+    "mov",
+    "wav",
+    "ogg",
+    "woff",
+    "woff2",
+    "ttf",
+    "otf",
+]);
+export function isHistoryTrackedFile(file, settings) {
+    const path = normalizePath(file.path);
+    if (isLapisInternalPath(path)) {
+        return false;
+    }
+    if (file.stat.size > settings.maxFileSizeBytes) {
+        return false;
+    }
+    const extension = file.extension.toLowerCase();
+    if (HISTORY_BINARY_EXTENSIONS.has(extension)) {
+        return false;
+    }
+    if (settings.excludeGlobs.some((pattern) => matchesEditorAssociationGlob(pattern, path))) {
+        return false;
+    }
+    if (settings.includeGlobs.length > 0 &&
+        !settings.includeGlobs.some((pattern) => matchesEditorAssociationGlob(pattern, path))) {
+        return false;
+    }
+    if (settings.trackedExtensions.length === 0) {
+        return true;
+    }
+    return settings.trackedExtensions.includes(extension);
+}

package/dist/history-view-type.d.ts

@@ -0,0 +1,2 @@
+export declare const HistoryViewType = "history";
+export declare const HistoryCompareViewType = "history-compare";

package/dist/history-view-type.js

@@ -0,0 +1,2 @@
+export const HistoryViewType = "history";
+export const HistoryCompareViewType = "history-compare";

package/dist/history-view.d.ts

@@ -0,0 +1,12 @@
+import { View, type WorkspaceLeaf } from "@lapis-notes/api";
+export declare class HistoryView extends View {
+    private component;
+    constructor(leaf: WorkspaceLeaf);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    onunload(): void;
+}