@lapis-notes/history 0.1.4 → 0.2.0

package/dist/repository/components/conflicts/repository-conflict-file-tree.css

@@ -0,0 +1,73 @@
+.community-projects__file-tree {
+  --ui-diff-row-hover: color-mix(
+    in srgb,
+    var(--foreground) 7%,
+    var(--background)
+  );
+  --ui-diff-selected: color-mix(
+    in srgb,
+    var(--foreground) 12%,
+    var(--background)
+  );
+  display: flex;
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  box-sizing: border-box;
+  flex-direction: column;
+  padding: 0 0.5rem 0.5rem;
+  background: var(--background);
+}
+
+.community-projects__file-tree-actions {
+  display: flex;
+  height: var(--community-projects-file-header-height, 2.25rem);
+  box-sizing: border-box;
+  align-items: center;
+  gap: 0.45rem;
+  margin-inline: -0.5rem;
+  padding: 0.2rem 0.5rem 0.2rem 1rem;
+  padding-inline-start: 0.5rem;
+  border-bottom: 1px solid var(--border);
+}
+
+.community-projects__file-tree-title {
+  min-width: 0;
+  flex: 1 1 auto;
+  overflow: hidden;
+  color: var(--foreground);
+  font-size: var(--community-text-secondary);
+  font-weight: 600;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.community-projects__file-tree-count {
+  display: inline-flex;
+  min-width: 1.25rem;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  padding: 0.05rem 0.35rem;
+  border-radius: 999px;
+  background: color-mix(in srgb, var(--foreground) 7%, var(--background));
+  color: var(--foreground);
+  font-size: var(--community-text-secondary);
+  font-weight: 600;
+  line-height: 1rem;
+}
+
+.review-conflict-file-list {
+  flex: 1;
+  min-height: 0;
+  padding-block-start: 0.35rem;
+}
+.review-conflict-file-label {
+  flex: 1;
+  min-width: 0;
+  line-height: 1.5rem;
+  font-size: 0.75rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}

package/dist/repository/components/conflicts/repository-conflicts.css

@@ -0,0 +1,125 @@
+/* Adapted from jj-store's conflict editor; all selectors target owned hosts. */
+.store-conflict-editor {
+  --ui-shell-surface-layer-inline-end-inset: 0px;
+}
+.store-conflict-editor__header {
+  padding-inline-start: 0.5rem;
+  gap: 0.5rem;
+  border-bottom: 1px solid var(--border);
+}
+.store-conflict-editor__title {
+  flex: 1;
+  min-width: 0;
+  margin: 0;
+  overflow: hidden;
+  font-size: 0.875rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.store-conflict-editor__body-shell {
+  --ui-shell-height: 100%;
+  --ui-shell-main-block-inset: 0px;
+  --ui-shell-main-radius: 0px;
+  --ui-shell-main-shadow: none;
+  --ui-shell-main-border: 0;
+}
+.store-conflict-editor__body {
+  min-width: 0;
+  min-height: 0;
+  overflow: hidden;
+}
+.store-conflict-editor__file-browser {
+  height: 100%;
+}
+.store-conflict-editor__content-body {
+  display: flex;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
+  box-sizing: border-box;
+  flex-direction: column;
+  gap: 0.5rem;
+  padding: 0.5rem;
+}
+.store-conflict-editor__content[hidden] {
+  display: none;
+}
+.store-conflict-editor__path,
+.store-conflict-path {
+  display: flex;
+  min-width: 0;
+  min-height: 0;
+  flex: 1;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+.store-conflict-editor__path[hidden] {
+  display: none;
+}
+.store-conflict-path__editor {
+  min-width: 0;
+  min-height: 0;
+  flex: 1;
+}
+.store-conflict-path__unsupported {
+  display: grid;
+  align-content: start;
+  gap: 0.75rem;
+  flex: 1;
+}
+.store-conflict-path__terms,
+.store-conflict-editor__actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.5rem;
+}
+.store-conflict-editor__staged {
+  color: var(--muted-foreground);
+  font-size: 0.75rem;
+}
+.store-conflict-path__error,
+.store-conflict-editor__error {
+  margin: 0;
+  color: var(--destructive);
+  font-size: 0.8125rem;
+}
+@media (max-width: 700px) {
+  .store-conflict-editor__header {
+    padding-inline: 0.5rem;
+    gap: 0.25rem;
+  }
+  .store-conflict-editor__actions {
+    flex-wrap: nowrap;
+    gap: 0.25rem;
+  }
+  .store-conflict-editor__action-label,
+  .store-conflict-editor__staged {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+  }
+}
+
+.store-conflict-editor {
+  --community-text-secondary: 0.75rem;
+}
+.community-projects__file-tree-region {
+  background: var(--background);
+}
+.store-conflict-preview {
+  padding: 1rem;
+  font-size: 0.8125rem;
+}
+.store-conflict-preview h2 {
+  margin: 0;
+  font-size: 0.875rem;
+}
+.store-conflict-preview pre {
+  padding: 1rem;
+  overflow: auto;
+  background: var(--muted);
+}

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

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

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

@@ -0,0 +1,110 @@
+import { FileView, View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import RepositoryFileHistory from "./RepositoryFileHistory.svelte";
+import { followBackup } from "../controllers/backup-follow.js";
+export class FileHistoryView extends View {
+    plugin;
+    #controller;
+    #component;
+    constructor(leaf, plugin) {
+        super(leaf);
+        this.plugin = plugin;
+    }
+    getViewType() {
+        return "repository-file-history";
+    }
+    getDisplayText() {
+        return "File history";
+    }
+    getIcon() {
+        return "file-clock";
+    }
+    async onOpen() { }
+    async onClose() { }
+    onload() {
+        const controller = (this.#controller =
+            this.plugin.createFileHistoryController());
+        this.register(followBackup(this.plugin.backup?.controller, controller));
+        const workspace = this.app.workspace;
+        const follow = (leaf = workspace.activeLeaf) => {
+            let root = false;
+            workspace.iterateRootLeaves((candidate) => {
+                if (candidate === leaf)
+                    root = true;
+            });
+            if (!leaf || root)
+                void controller.follow(leaf?.view instanceof FileView ? leaf.view.file?.path : undefined);
+        };
+        this.registerEvent(workspace.on("active-leaf-change", follow));
+        this.registerEvent(workspace.on("file-open", () => follow()));
+        this.registerEvent(this.app.vault.on("rename", (file, oldPath) => {
+            const path = controller.state.path;
+            if (path === oldPath)
+                void controller.follow(file.path);
+            else if (path?.startsWith(`${oldPath}/`))
+                void controller.follow(file.path + path.slice(oldPath.length));
+        }));
+        this.registerEvent(this.app.vault.on("delete", (file) => {
+            if (file.path === controller.state.path)
+                void controller.follow();
+        }));
+        this.#component = mount(RepositoryFileHistory, {
+            target: this.containerEl,
+            props: {
+                controller,
+                copyText: (value) => this.plugin.copyIdentifier(value),
+                onBlame: () => {
+                    const { operation, workspaceCommit: commit, path } = controller.state;
+                    if (operation && commit && path)
+                        void this.plugin
+                            .openBlame(operation, commit, path)
+                            .catch((error) => this.plugin.report(error));
+                },
+                onOpen: (revision) => void this.plugin
+                    .open(controller.state.operation, revision)
+                    .catch((error) => this.plugin.report(error)),
+            },
+        });
+        follow();
+    }
+    onunload() {
+        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));
+    }
+}
+export function registerFileHistoryView(plugin) {
+    let active = true;
+    plugin.register(() => {
+        active = false;
+    });
+    const ensure = async (reveal = false) => {
+        if (!active)
+            return;
+        const workspace = plugin.app.workspace;
+        let leaf = workspace.getLeavesOfType("repository-file-history")[0];
+        if (!leaf) {
+            leaf = workspace.ensureSideLeaf("repository-file-history");
+            await leaf.setViewState({ type: "repository-file-history", state: {} });
+        }
+        if (reveal && active)
+            await workspace.revealLeaf(leaf);
+    };
+    plugin.registerSidebarView("repository-file-history", (leaf) => new FileHistoryView(leaf, plugin), { side: "right", title: "File history", icon: "file-clock" }, {
+        kind: "command",
+        command: {
+            id: "open-file-history",
+            name: "Open File History",
+            callback: () => {
+                void ensure(true).catch((error) => plugin.report(error));
+            },
+        },
+    });
+    plugin.app.workspace.onLayoutReady(() => {
+        void ensure().catch((error) => plugin.report(error));
+    });
+}

package/dist/repository/components/operation-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 OperationView 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/operation-view.js

@@ -0,0 +1,95 @@
+import { historySource, } from "../controllers/history-source.js";
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import RepositoryOperations from "./RepositoryOperations.svelte";
+import { followBackup } from "../controllers/backup-follow.js";
+export class OperationView extends View {
+    plugin;
+    #controller;
+    #component;
+    #source = "backup";
+    #operation;
+    #unsubscribe;
+    #live;
+    constructor(leaf, plugin) {
+        super(leaf);
+        this.plugin = plugin;
+    }
+    getViewType() {
+        return "repository-oplog";
+    }
+    getDisplayText() {
+        return this.#source === "original"
+            ? "Original repository operations"
+            : "Repository operation log";
+    }
+    getIcon() {
+        return "git-pull-request-arrow";
+    }
+    getState() {
+        return {
+            source: this.#source,
+            operation: this.#controller
+                ? this.#controller.pinned
+                    ? this.#controller.state.operation
+                    : undefined
+                : this.#operation,
+        };
+    }
+    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;
+        this.#operation =
+            typeof state.operation === "string" ? state.operation : undefined;
+        if (this.#controller &&
+            this.#operation &&
+            this.#operation !== this.#controller.state.operation)
+            await this.#controller.selectPin(this.#operation);
+        await super.setState(state);
+    }
+    async onOpen() { }
+    async onClose() { }
+    onload() {
+        this.#controller = this.plugin.createOperationController(this.#source);
+        this.#live = followBackup(this.#source === "backup" ? this.plugin.backup?.controller : undefined, this.#controller);
+        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-oplog",
+                });
+            }
+        });
+        this.#component = mount(RepositoryOperations, {
+            target: this.containerEl,
+            props: {
+                controller: this.#controller,
+                sources: this.plugin.sourcePicker(this.#source, (source) => {
+                    void this.plugin
+                        .openOperations(source)
+                        .catch((error) => this.plugin.report(error));
+                }),
+                initialOperation: this.#operation,
+                copyText: (value) => this.plugin.copyIdentifier(value),
+                onHistory: (operation) => void this.plugin
+                    .open(operation, undefined, this.#source)
+                    .catch((error) => this.plugin.report(error)),
+            },
+        });
+    }
+    onunload() {
+        this.#live?.();
+        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));
+    }
+}

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

@@ -0,0 +1,22 @@
+import { BackupController } from "../controllers/backup.js";
+import type { RepositoryServices } from "../controllers/history-reader.js";
+import { RepositorySync } from "./repository-sync.js";
+import type { RepositoryPlugin } from "./repository-plugin.js";
+export declare const AUTOMATIC_BACKUP_SETTING = "repository-history.automaticBackup";
+export declare const automaticBackup: (value: Record<string, unknown>) => boolean;
+/** Capture lifetime is independent of whether its status control is visible. */
+export declare class RepositoryBackup {
+    #private;
+    readonly plugin: RepositoryPlugin;
+    readonly controller: BackupController;
+    readonly sync?: RepositorySync;
+    get enabled(): boolean;
+    constructor(plugin: RepositoryPlugin, services: RepositoryServices);
+    start(): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    /** Saved-state projection never changes native persisted selection. */
+    reconcile(enabled: boolean): Promise<void>;
+    prepareLeave(): Promise<void>;
+    resumeLeave(): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,75 @@
+import { BackupController } from "../controllers/backup.js";
+import { RepositorySync } from "./repository-sync.js";
+import { BackgroundWork } from "../controllers/background-work.js";
+export const AUTOMATIC_BACKUP_SETTING = "repository-history.automaticBackup";
+export const automaticBackup = (value) => typeof value.automaticBackup === "boolean" ? value.automaticBackup : true;
+/** Capture lifetime is independent of whether its status control is visible. */
+export class RepositoryBackup {
+    plugin;
+    controller;
+    #progress;
+    sync;
+    #enabled = false;
+    get enabled() {
+        return this.#enabled;
+    }
+    constructor(plugin, services) {
+        this.plugin = plugin;
+        this.controller = new BackupController(services.backup, plugin.feedback("Vault backup"));
+        if (services.sync && services.remote)
+            this.sync = new RepositorySync(plugin, services);
+    }
+    async start() {
+        this.#progress = new BackgroundWork(this.plugin.app.notifications, this.plugin.id).follow("Saving vault history", {
+            subscribe: (listener) => this.controller.subscribe((state) => listener({
+                busy: state.phase === "saving",
+                phase: state.phase,
+            })),
+        });
+        const enabled = automaticBackup((await this.plugin.loadData()) ?? {});
+        this.#enabled = enabled;
+        // Admit the worker now; its first scan must not hold plugin/shell startup.
+        if (enabled)
+            void this.controller.start().catch((error) => this.plugin.report(error));
+        else
+            await this.controller.pause();
+        await this.sync?.start();
+    }
+    async setEnabled(enabled) {
+        const service = this.controller.service;
+        if (service.setEnabled) {
+            try {
+                await service.setEnabled(enabled);
+            }
+            finally {
+                // A lost acknowledgement may follow a committed native selection.
+                // Project the reconciled setting without replaying the mutation.
+                await this.reconcile(automaticBackup((await this.plugin.loadData()) ?? {}));
+            }
+            return;
+        }
+        await this.reconcile(enabled);
+    }
+    /** Saved-state projection never changes native persisted selection. */
+    async reconcile(enabled) {
+        this.#enabled = enabled;
+        if (enabled)
+            await this.controller.start();
+        else
+            await this.controller.pause();
+        await this.sync?.start();
+    }
+    async prepareLeave() {
+        await this.controller.pause();
+    }
+    async resumeLeave() {
+        if (this.#enabled)
+            await this.controller.resume();
+    }
+    async close() {
+        this.sync?.close();
+        await this.controller.close();
+        this.#progress?.();
+        this.#progress = undefined;
+    }
+}

package/dist/repository/components/repository-column-chrome.css

@@ -0,0 +1,35 @@
+/* Application-owned contrast treatment for the application-owned column chrome. */
+.repository-shell {
+  --repository-review-column-action-hover: color-mix(
+    in srgb,
+    var(--foreground) 24%,
+    var(--background)
+  );
+  --ui-column-canvas-header-action-hover: var(
+    --repository-review-column-action-hover
+  );
+  --ui-column-canvas-header-action-hover-foreground: var(--foreground);
+  --ui-column-canvas-rail-hover: var(--repository-review-column-action-hover);
+}
+.repository-shell
+  :is(
+    .repository-log-actions,
+    .operation-card-actions,
+    .repository-review-column-actions
+  ) {
+  --accent: var(--repository-review-column-action-hover);
+  --accent-foreground: var(--foreground);
+  --muted: var(--accent);
+  --ui-column-canvas-header-action-hover: var(--accent);
+  --ui-column-canvas-header-action-hover-foreground: var(--foreground);
+}
+.repository-shell
+  :is(
+    .repository-log-actions,
+    .operation-card-actions,
+    .repository-review-column-actions
+  )
+  > button:not(:disabled):is(:hover, :focus-visible) {
+  background: var(--repository-review-column-action-hover);
+  color: var(--foreground);
+}

package/dist/repository/components/repository-commit-picker.css

@@ -0,0 +1,55 @@
+.repository-commit-picker-control {
+  position: relative;
+  min-width: 0;
+  width: 100%;
+}
+.repository-commit-picker-trigger[data-ui-component="button"] {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: auto;
+  min-height: 3.25rem;
+  padding: 0.5rem;
+  justify-content: flex-end;
+  color: var(--foreground);
+  text-align: start;
+}
+.repository-commit-picker-trigger > svg {
+  width: 1rem;
+  height: 1rem;
+  flex: none;
+  color: var(--muted-foreground);
+}
+.repository-commit-picker-value {
+  position: relative;
+  padding: 0.5rem 2rem 0.5rem 0.5rem;
+  pointer-events: none;
+}
+.repository-commit-picker[data-ui-part="popover-content"] {
+  --ui-command-view-list-max-height: min(24rem, 54dvh);
+}
+.repository-commit-picker-header[data-ui-part="popover-header"] {
+  flex-direction: row;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.25rem;
+  min-height: 0;
+  padding: 0;
+  margin: 0;
+}
+.repository-commit-picker-option[data-ui-component="command-view"] {
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: 0.5rem;
+  cursor: pointer;
+}
+.repository-commit-picker-selection {
+  display: inline-flex;
+  width: 1rem;
+  height: 1rem;
+  align-items: center;
+  justify-content: center;
+}
+.repository-commit-picker-selection > svg {
+  width: 0.9rem;
+  height: 0.9rem;
+}

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

@@ -0,0 +1,7 @@
+import type { App } from "@lapis-notes/api";
+export declare function repositoryFeedback(app: App, title: string, identity?: string): {
+    report: (error: unknown) => import("@lapis-notes/api").AppDatabaseNotificationRecord;
+    recovered: () => void;
+};
+export declare function copyRepositoryIdentifier(app: App, value: string): Promise<void>;
+export declare function reportRepositoryError(app: App, error: unknown): void;

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

@@ -0,0 +1,40 @@
+import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
+export function repositoryFeedback(app, title, identity) {
+    const id = identity ?? `repository-history:${crypto.randomUUID()}`;
+    return {
+        report: (error) => app.notifications.notify({
+            id,
+            title,
+            message: error instanceof Error ? error.message : String(error),
+            source: "repository-history",
+            severity: "error",
+            persist: false,
+        }),
+        recovered: () => {
+            getWorkspaceHostBinding(app.workspace).controller.notifications.dismiss(id);
+            void app.notifications
+                .clear(id)
+                .catch((error) => console.error("Repository notification cleanup failed", error));
+        },
+    };
+}
+export async function copyRepositoryIdentifier(app, value) {
+    const feedback = repositoryFeedback(app, "Copy identifier", `repository-copy:${value}`);
+    try {
+        await navigator.clipboard.writeText(value);
+        feedback.recovered();
+    }
+    catch (error) {
+        feedback.report(error);
+        throw error;
+    }
+}
+export function reportRepositoryError(app, error) {
+    app.notifications.notify({
+        title: "Repository history",
+        source: "repository-history",
+        severity: "error",
+        persist: false,
+        message: error instanceof Error ? error.message : String(error),
+    });
+}