@lapis-notes/history 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# History changelog
+
+## 0.1.0
+
+- Initial independent public package extracted from Lapis Notes without changing
+  the runtime plugin ID.

package/LICENSE.md

@@ -0,0 +1,8 @@
+# License
+
+Copyright (c) LapisMD contributors.
+
+This software is licensed under the GNU Affero General Public License, version
+3 or (at your option) any later version (`AGPL-3.0-or-later`). The complete
+license text is available from the
+[GNU Project](https://www.gnu.org/licenses/agpl-3.0.html).

package/README.md

@@ -0,0 +1,20 @@
+# History
+
+File history
+
+## Install for static composition
+
+```sh
+pnpm add @lapis-notes/history
+```
+
+Register the exported plugin class in the application's `PluginProfile`. Import
+`@lapis-notes/history/styles.css?inline` and pass the CSS through the static
+registration so the host owns its lifecycle.
+
+The runtime plugin ID is `history`. A matching signed
+`history-0.1.0.lapis-plugin` archive is attached to the
+package-scoped GitHub release for manual or registry installation.
+
+See the [repository README](https://github.com/lapismd/lapis-plugins#readme) for
+development, validation, and release-gate details.

package/dist/history-capture.d.ts

@@ -0,0 +1,7 @@
+export declare function shouldReplaceLatestModify(eventType: string, latestEventType: string | undefined, lastModifyStoredAt: number | undefined, mergeWindowMs: number, now?: number): boolean;
+export declare function consumeSuppressedHash(suppressed: Map<string, string>, path: string, contentHash: string): boolean;
+export declare function historyIdentityStoreInput(eventType: "rename" | "delete", path: string, previousPath?: string): {
+    path: string;
+    previousPath?: string;
+    eventType: "rename" | "delete";
+};

package/dist/history-capture.js

@@ -0,0 +1,21 @@
+export function shouldReplaceLatestModify(eventType, latestEventType, lastModifyStoredAt, mergeWindowMs, now = Date.now()) {
+    return (eventType === "modify" &&
+        latestEventType === "modify" &&
+        lastModifyStoredAt != null &&
+        now - lastModifyStoredAt < mergeWindowMs);
+}
+export function consumeSuppressedHash(suppressed, path, contentHash) {
+    if (suppressed.get(path) !== contentHash)
+        return false;
+    suppressed.delete(path);
+    return true;
+}
+export function historyIdentityStoreInput(eventType, path, previousPath) {
+    return {
+        path,
+        eventType,
+        ...(eventType === "rename" && previousPath
+            ? { previousPath }
+            : {}),
+    };
+}

package/dist/history-compare-panel.css

@@ -0,0 +1,126 @@
+.history-compare {
+  --ui-diff-frame-border: none;
+  --ui-diff-frame-radius: 0;
+  /* Prefer Design Core's brand mono. Host `--font-mono` can be reset to
+     system UI mono by other plugin stylesheets. */
+  --ui-diff-mono: var(
+    --studio-font-mono,
+    "Source Code Pro Variable",
+    "Source Code Pro",
+    ui-monospace,
+    SFMono-Regular,
+    Menlo,
+    Monaco,
+    Consolas,
+    "Liberation Mono",
+    monospace
+  );
+  display: flex;
+  box-sizing: border-box;
+  width: 100%;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
+  flex-direction: column;
+  overflow: hidden;
+  color: var(--ui-workspace-view-foreground, inherit);
+  background: var(--ui-workspace-view-background, transparent);
+}
+
+.history-compare__chrome {
+  display: flex;
+  flex: 0 0 auto;
+  flex-direction: column;
+  align-items: stretch;
+  gap: 0;
+  padding: 0.25rem 0.25rem 0;
+  border-bottom: 1px solid
+    var(--ui-workspace-border, color-mix(in srgb, currentColor 14%, transparent));
+  background: var(--ui-workspace-view-background, transparent);
+}
+
+.history-compare__revision {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem;
+  padding: 0.35rem 0.5rem 0.15rem;
+  color: var(--ui-workspace-muted-foreground, var(--muted-foreground));
+  font-size: 0.75rem;
+}
+
+.history-compare__revision > span:first-child {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.history-compare__revision [data-ui-component="file-change-stats"] {
+  flex: 0 0 auto;
+}
+
+.history-compare__toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.125rem;
+  padding: 0.15rem 0 0.25rem;
+}
+
+.history-compare__toolbar
+  button[data-ui-component="button"].history-compare__toolbar-action {
+  color: inherit;
+  background: transparent;
+}
+
+.history-compare__toolbar
+  button[data-ui-component="button"].history-compare__toolbar-action:hover,
+.history-compare__toolbar
+  button[data-ui-component="button"].history-compare__toolbar-action:focus-visible {
+  color: var(
+    --ui-workspace-panel-action-hover-foreground,
+    var(--sidebar-accent-foreground, inherit)
+  );
+  background: var(
+    --ui-workspace-panel-action-hover-background,
+    var(--sidebar-accent, #e3e3e3)
+  );
+  outline: none;
+}
+
+.history-compare__toolbar
+  button[data-ui-component="button"].history-compare__toolbar-action[aria-pressed="true"],
+.history-compare__toolbar
+  button[data-ui-component="button"].history-compare__toolbar-action[aria-pressed="true"]:hover {
+  color: var(--ui-workspace-accent, #7c3aed);
+  background: var(
+    --ui-workspace-selection,
+    color-mix(in srgb, var(--ui-workspace-accent, #7c3aed) 14%, transparent)
+  );
+}
+
+.history-compare__body {
+  display: flex;
+  min-width: 0;
+  min-height: 0;
+  flex: 1 1 auto;
+  flex-direction: column;
+}
+
+.history-compare__body [data-ui-component="merge-editor"],
+.history-compare__body [data-ui-component="file-diff"] {
+  flex: 1 1 auto;
+  height: 100%;
+  min-height: 0;
+  border: none;
+  border-radius: 0;
+}
+
+.history-compare__empty,
+.history-compare__binary {
+  margin: 0;
+  padding: 0.75rem;
+  color: var(--ui-workspace-muted-foreground, var(--muted-foreground));
+}

package/dist/history-compare-panel.svelte

@@ -0,0 +1,314 @@
+<script lang="ts">
+  import "./history-compare-panel.css";
+  import { type App } from "@lapis-notes/api";
+  import {
+    FileChangeStats,
+    FileDiff,
+    MergeEditor,
+    buildUnifiedDiffRows,
+    isBinaryFilePath,
+    type FileDiffViewMode,
+    type MergeResolvedChange,
+  } from "@lapismd/design-core/diff";
+  import { Button } from "@lapismd/design-core/shadcn/button";
+  import * as Tooltip from "@lapismd/design-core/shadcn/tooltip";
+  import ArchiveRestore from "@lucide/svelte/icons/archive-restore";
+  import Check from "@lucide/svelte/icons/check";
+  import Columns2 from "@lucide/svelte/icons/columns-2";
+  import GitCompare from "@lucide/svelte/icons/git-compare";
+  import GitCompareArrows from "@lucide/svelte/icons/git-compare-arrows";
+  import Rows2 from "@lucide/svelte/icons/rows-2";
+  import WrapText from "@lucide/svelte/icons/wrap-text";
+  import { onMount, untrack } from "svelte";
+  import type {
+    HistoryCompareViewState,
+    HistoryComparisonModel,
+    HistoryRevision,
+  } from "./history-plugin";
+
+  type HistoryComparePanelPlugin = {
+    getHistoryComparisonModel(
+      state: HistoryCompareViewState,
+    ): Promise<HistoryComparisonModel>;
+    getCompareAnchor(): { revisionId: string } | null;
+    openHistoryCompareView(state: HistoryCompareViewState): Promise<void>;
+    closeHistoryCompareView(sourceLeafId?: string): void;
+    saveCurrentFileContent(filePath: string, content: string): Promise<void>;
+    restoreRevision(filePath: string, revision: HistoryRevision): Promise<void>;
+    onHistoryChanged(listener: () => void): () => void;
+  };
+
+  let {
+    app,
+    compareState,
+  }: {
+    app: App;
+    compareState: HistoryCompareViewState;
+  } = $props();
+
+  const plugin = untrack(() => {
+    const registered = app.plugins.plugins.get("history") as
+      | HistoryComparePanelPlugin
+      | undefined;
+    if (!registered) throw new Error("History plugin is not registered");
+    return registered;
+  });
+
+  let model = $state<HistoryComparisonModel | null>(null);
+  let error = $state<string | null>(null);
+  let viewMode = $state<FileDiffViewMode>("unified");
+  let wrap = $state(false);
+  let pendingContent = $state<string | null>(null);
+
+  const viewModeLabel = $derived(
+    viewMode === "split" ? "Split diff" : "Unified diff",
+  );
+  const binary = $derived(isBinaryFilePath(compareState.filePath));
+  const stats = $derived.by(() => {
+    if (!model) return { additions: 0, deletions: 0 };
+    const rows = buildUnifiedDiffRows(
+      model.compareBaseText,
+      model.compareNewText,
+    );
+    return {
+      additions: rows.filter((row) => row.variant === "added").length,
+      deletions: rows.filter((row) => row.variant === "removed").length,
+    };
+  });
+
+  async function refresh(): Promise<void> {
+    try {
+      model = await plugin.getHistoryComparisonModel(compareState);
+      error = null;
+      pendingContent = null;
+    } catch (cause) {
+      model = null;
+      error = cause instanceof Error ? cause.message : String(cause);
+    }
+  }
+
+  function close(): void {
+    plugin.closeHistoryCompareView(compareState.sourceLeafId);
+  }
+
+  function openMode(compareMode: HistoryCompareViewState["compareMode"]): void {
+    if (!model) return;
+    void plugin.openHistoryCompareView({
+      ...compareState,
+      revisionId: model.selectedRevision.revisionId,
+      compareMode,
+      otherRevisionId:
+        compareMode === "selected"
+          ? (plugin.getCompareAnchor()?.revisionId ??
+            compareState.otherRevisionId)
+          : undefined,
+    });
+  }
+
+  async function applyMerged(): Promise<void> {
+    if (!model || pendingContent == null) return;
+    await plugin.saveCurrentFileContent(model.filePath, pendingContent);
+    pendingContent = null;
+    await refresh();
+  }
+
+  async function restoreSelected(): Promise<void> {
+    if (!model) return;
+    await plugin.restoreRevision(model.filePath, model.selectedRevision);
+    await refresh();
+  }
+
+  function onResolvedChange(next: MergeResolvedChange): void {
+    pendingContent = next.content;
+  }
+
+  function onKeydown(event: KeyboardEvent): void {
+    if (event.key !== "Escape") return;
+    event.preventDefault();
+    close();
+  }
+
+  onMount(() => {
+    const unsubscribe = plugin.onHistoryChanged(() => void refresh());
+    document.addEventListener("keydown", onKeydown);
+    void refresh();
+    return () => {
+      unsubscribe();
+      document.removeEventListener("keydown", onKeydown);
+    };
+  });
+</script>
+
+<div
+  class="history-compare"
+  data-ui-component="history-compare-panel"
+  data-testid="history-compare-panel"
+  data-compare-mode={model?.compareMode ?? compareState.compareMode}
+  data-wrap={wrap ? "true" : "false"}
+  aria-label="File history comparison"
+>
+  <div class="history-compare__chrome" data-ui-part="chrome">
+    {#if model}
+      <div class="history-compare__revision">
+        <span>{model.beforeLabel} → {model.afterLabel}</span>
+        <FileChangeStats
+          additions={stats.additions}
+          deletions={stats.deletions}
+          showZero
+        />
+      </div>
+    {/if}
+    <Tooltip.Provider delayDuration={0}>
+      <div class="history-compare__toolbar" data-ui-part="toolbar">
+        <Tooltip.Root>
+          <Tooltip.Trigger>
+            {#snippet child({ props })}
+              <Button
+                {...props}
+                variant="ghost"
+                size="icon-sm"
+                class="history-compare__toolbar-action"
+                aria-label="Compare with current"
+                aria-pressed={model?.compareMode === "current"}
+                onclick={() => openMode("current")}
+              >
+                <GitCompare aria-hidden="true" />
+              </Button>
+            {/snippet}
+          </Tooltip.Trigger>
+          <Tooltip.Content side="bottom">Compare with current</Tooltip.Content>
+        </Tooltip.Root>
+        <Tooltip.Root>
+          <Tooltip.Trigger>
+            {#snippet child({ props })}
+              <Button
+                {...props}
+                variant="ghost"
+                size="icon-sm"
+                class="history-compare__toolbar-action"
+                aria-label="Compare with previous"
+                aria-pressed={model?.compareMode === "previous"}
+                disabled={!model?.previousRevision}
+                onclick={() => openMode("previous")}
+              >
+                <GitCompareArrows aria-hidden="true" />
+              </Button>
+            {/snippet}
+          </Tooltip.Trigger>
+          <Tooltip.Content side="bottom">Compare with previous</Tooltip.Content>
+        </Tooltip.Root>
+        {#if model?.compareMode !== "current"}
+          <Tooltip.Root>
+            <Tooltip.Trigger>
+              {#snippet child({ props })}
+                <Button
+                  {...props}
+                  variant="ghost"
+                  size="icon-sm"
+                  class="history-compare__toolbar-action"
+                  data-testid="history-compare-view-mode"
+                  data-view-mode={viewMode}
+                  aria-label={viewModeLabel}
+                  onclick={() =>
+                    (viewMode = viewMode === "split" ? "unified" : "split")}
+                >
+                  {#if viewMode === "split"}
+                    <Columns2 aria-hidden="true" />
+                  {:else}
+                    <Rows2 aria-hidden="true" />
+                  {/if}
+                </Button>
+              {/snippet}
+            </Tooltip.Trigger>
+            <Tooltip.Content side="bottom">{viewModeLabel}</Tooltip.Content>
+          </Tooltip.Root>
+        {/if}
+        <Tooltip.Root>
+          <Tooltip.Trigger>
+            {#snippet child({ props })}
+              <Button
+                {...props}
+                variant="ghost"
+                size="icon-sm"
+                class="history-compare__toolbar-action"
+                data-testid="history-compare-wrap"
+                aria-label="Wrap text"
+                aria-pressed={wrap ? "true" : "false"}
+                onclick={() => (wrap = !wrap)}
+              >
+                <WrapText aria-hidden="true" />
+              </Button>
+            {/snippet}
+          </Tooltip.Trigger>
+          <Tooltip.Content side="bottom">Wrap text</Tooltip.Content>
+        </Tooltip.Root>
+        {#if model?.compareMode === "current"}
+          <Tooltip.Root>
+            <Tooltip.Trigger>
+              {#snippet child({ props })}
+                <Button
+                  {...props}
+                  variant="ghost"
+                  size="icon-sm"
+                  class="history-compare__toolbar-action"
+                  aria-label="Apply"
+                  disabled={pendingContent == null}
+                  onclick={() => void applyMerged()}
+                >
+                  <Check aria-hidden="true" />
+                </Button>
+              {/snippet}
+            </Tooltip.Trigger>
+            <Tooltip.Content side="bottom">Apply</Tooltip.Content>
+          </Tooltip.Root>
+        {/if}
+        <Tooltip.Root>
+          <Tooltip.Trigger>
+            {#snippet child({ props })}
+              <Button
+                {...props}
+                variant="ghost"
+                size="icon-sm"
+                class="history-compare__toolbar-action"
+                aria-label="Restore this revision"
+                onclick={() => void restoreSelected()}
+              >
+                <ArchiveRestore aria-hidden="true" />
+              </Button>
+            {/snippet}
+          </Tooltip.Trigger>
+          <Tooltip.Content side="bottom">Restore this revision</Tooltip.Content>
+        </Tooltip.Root>
+      </div>
+    </Tooltip.Provider>
+  </div>
+  <div class="history-compare__body">
+    {#if error}
+      <p class="history-compare__empty">{error}</p>
+    {:else if !model}
+      <p class="history-compare__empty">Loading comparison…</p>
+    {:else if binary}
+      <p class="history-compare__binary">Binary file not shown.</p>
+    {:else if model.compareMode === "current"}
+      <MergeEditor
+        mode="one-way"
+        left={model.selectedRevision.content}
+        right={model.currentContent}
+        leftLabel="Selected revision"
+        rightLabel={model.fileExists ? "Current file" : "Latest"}
+        path={model.filePath}
+        syncHorizontalScroll
+        {wrap}
+        onResolvedChange={onResolvedChange}
+      />
+    {:else}
+      <FileDiff
+        path={model.filePath}
+        oldText={model.compareBaseText}
+        newText={model.compareNewText}
+        {viewMode}
+        {wrap}
+      />
+    {/if}
+  </div>
+</div>

package/dist/history-compare-panel.svelte.d.ts

@@ -0,0 +1,10 @@
+import "./history-compare-panel.css";
+import { type App } from "@lapis-notes/api";
+import type { HistoryCompareViewState } from "./history-plugin";
+type $$ComponentProps = {
+    app: App;
+    compareState: HistoryCompareViewState;
+};
+declare const HistoryComparePanel: import("svelte").Component<$$ComponentProps, {}, "">;
+type HistoryComparePanel = ReturnType<typeof HistoryComparePanel>;
+export default HistoryComparePanel;

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

@@ -0,0 +1,24 @@
+import { View, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { HistoryPlugin } from "./history-plugin";
+export declare class HistoryCompareView extends View {
+    private readonly historyPlugin;
+    private component;
+    private compareState;
+    constructor(historyPlugin: HistoryPlugin, leaf: WorkspaceLeaf);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    getBreadcrumbFilePath(): string | null;
+    getBreadcrumbs(): {
+        id: string;
+        label: string;
+        onSelect: () => void;
+    }[];
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    setState(state: Record<string, unknown>): Promise<void>;
+    onunload(): void;
+    private mountPanel;
+    private unmountPanel;
+}

package/dist/history-compare-view.js

@@ -0,0 +1,97 @@
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import HistoryComparePanel from "./history-compare-panel.svelte";
+import { HistoryCompareViewType } from "./history-view-type";
+function readCompareState(state) {
+    if (typeof state["filePath"] !== "string")
+        return null;
+    if (typeof state["revisionId"] !== "string")
+        return null;
+    const compareMode = state["compareMode"];
+    if (compareMode !== "current" &&
+        compareMode !== "previous" &&
+        compareMode !== "selected") {
+        return null;
+    }
+    return {
+        filePath: state["filePath"],
+        revisionId: state["revisionId"],
+        compareMode,
+        otherRevisionId: typeof state["otherRevisionId"] === "string"
+            ? state["otherRevisionId"]
+            : undefined,
+        sourceLeafId: typeof state["sourceLeafId"] === "string"
+            ? state["sourceLeafId"]
+            : undefined,
+    };
+}
+export class HistoryCompareView extends View {
+    historyPlugin;
+    component = null;
+    compareState = null;
+    constructor(historyPlugin, leaf) {
+        super(leaf);
+        this.historyPlugin = historyPlugin;
+    }
+    getViewType() {
+        return HistoryCompareViewType;
+    }
+    getDisplayText() {
+        return this.compareState
+            ? `History: ${this.compareState.filePath}`
+            : "History compare";
+    }
+    getIcon() {
+        return "git-compare";
+    }
+    getBreadcrumbFilePath() {
+        return this.compareState?.filePath ?? null;
+    }
+    getBreadcrumbs() {
+        return [
+            {
+                id: "history",
+                label: "History",
+                onSelect: () => {
+                    void this.historyPlugin.openHistoryView(this.compareState?.filePath);
+                },
+            },
+        ];
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    onload() {
+        this.compareState = readCompareState(this.getState());
+        this.mountPanel();
+    }
+    async setState(state) {
+        await super.setState(state);
+        this.compareState = readCompareState(state);
+        if (this.loaded)
+            this.mountPanel();
+    }
+    onunload() {
+        this.unmountPanel();
+    }
+    mountPanel() {
+        this.unmountPanel();
+        if (!this.compareState)
+            return;
+        this.component = mount(HistoryComparePanel, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                compareState: this.compareState,
+            },
+        });
+    }
+    unmountPanel() {
+        if (this.component)
+            void unmount(this.component);
+        this.component = null;
+    }
+}

package/dist/history-format.d.ts

@@ -0,0 +1,3 @@
+import type { HistoryCaptureEventType } from "./history-plugin";
+export declare function formatHistoryTimestamp(value: number): string;
+export declare function formatHistoryEvent(eventType: HistoryCaptureEventType): string;

package/dist/history-format.js

@@ -0,0 +1,19 @@
+export function formatHistoryTimestamp(value) {
+    return new Date(value).toLocaleString();
+}
+export function formatHistoryEvent(eventType) {
+    switch (eventType) {
+        case "baseline":
+            return "Opened";
+        case "create":
+            return "Created";
+        case "modify":
+            return "Edited";
+        case "rename":
+            return "Renamed";
+        case "delete":
+            return "Deleted";
+        case "restore":
+            return "Restored";
+    }
+}