@lapis-notes/history 0.1.4 → 0.2.0

package/dist/repository/controllers/operation-controller.d.ts

@@ -0,0 +1,33 @@
+import { OperationFiles } from "./operation-files.js";
+import type { LocalGraphOperationNode } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+import { pause } from "./history-selection.js";
+import { type OperationState } from "./operation-state.js";
+/** Independent operation-pinned reader; it shares no mutable history selection. */
+export declare class OperationController {
+    #private;
+    readonly files: OperationFiles;
+    readonly reader: HistoryReader;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    readonly wait: typeof pause;
+    constructor(reader: HistoryReader, feedback: OperationController["feedback"], wait?: typeof pause);
+    get state(): OperationState;
+    get pinned(): boolean;
+    subscribe(listener: (state: OperationState) => void): () => void;
+    refresh(preferred?: string): Promise<void>;
+    selectPin(operation: string): Promise<void>;
+    checkpointChanged(operation: string): Promise<void>;
+    more(): Promise<void>;
+    loadRevisions(): Promise<void>;
+    loadWorkspaces(): Promise<void>;
+    selectWorkspace(workspace: string | null): Promise<void>;
+    clearSelection(): Promise<void>;
+    select(node: LocalGraphOperationNode): Promise<void>;
+    selectId(id: string): Promise<void>;
+    loadParents(): Promise<void>;
+    selectParent(parent: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/repository/controllers/operation-controller.js

@@ -0,0 +1,267 @@
+import { OperationGraph } from "./operation-graph.js";
+import { operationRevisionCards } from "./operation-metadata.js";
+import { operationParent, operationParents } from "./operation-parent.js";
+import { OperationFiles } from "./operation-files.js";
+import { HistoryLifetime } from "./history-lifetime.js";
+import { check, pause, prepared } from "./history-selection.js";
+import { initialOperationState, resetOperationSelection, } from "./operation-state.js";
+/** Independent operation-pinned reader; it shares no mutable history selection. */
+export class OperationController {
+    #state = initialOperationState();
+    files;
+    #graph;
+    #listeners = new Set();
+    #lifetime;
+    #handle;
+    #selection = 0;
+    #detail = 0;
+    #request = 0;
+    #abort = new AbortController();
+    #closed = false;
+    #pinned = false;
+    #closing;
+    reader;
+    feedback;
+    wait;
+    constructor(reader, feedback, wait = pause) {
+        this.#graph = new OperationGraph(reader, () => ({
+            handle: this.#handle,
+            state: this.#state,
+            closed: this.#closed,
+        }), (patch) => this.#set(patch));
+        this.files = new OperationFiles(async (query) => {
+            check(this.#handle);
+            return reader.read(this.#handle, query);
+        }, (action) => this.#run(action), (files) => this.#set({ files }));
+        this.reader = reader;
+        this.feedback = feedback;
+        this.wait = wait;
+        this.#lifetime = new HistoryLifetime(reader);
+    }
+    get state() {
+        return this.#state;
+    }
+    get pinned() {
+        return this.#pinned || !!this.#state.selected;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#state);
+        return () => this.#listeners.delete(listener);
+    }
+    #set(patch) {
+        if (this.#closed)
+            return;
+        this.#state = { ...this.#state, ...patch };
+        for (const listener of this.#listeners)
+            listener(this.#state);
+    }
+    #run(action) {
+        if (this.#closed)
+            return Promise.resolve();
+        return this.#lifetime.run(async () => {
+            const request = ++this.#request;
+            this.#set({ busy: true });
+            try {
+                await action();
+                if (!this.#closed && request === this.#request)
+                    this.feedback.recovered();
+            }
+            catch (error) {
+                if (!this.#closed && request === this.#request) {
+                    this.#set({ phase: this.#state.snapshot ? "ready" : "unavailable" });
+                    this.feedback.report(error);
+                }
+            }
+            finally {
+                if (request === this.#request)
+                    this.#set({ busy: false });
+            }
+        });
+    }
+    refresh(preferred) {
+        if (preferred)
+            this.#pinned = true;
+        return this.#run(async () => {
+            const selection = this.#selection;
+            const heads = await this.reader.heads();
+            if (selection !== this.#selection || this.#closed)
+                return;
+            this.#set({
+                heads: heads.heads,
+                headsReady: true,
+                phase: this.#state.snapshot ? "ready" : "idle",
+            });
+            if (preferred && !this.#state.operation)
+                await this.#pin(preferred);
+            else if (this.#state.operation && !this.#state.snapshot)
+                await this.#pin(this.#state.operation);
+            else if (this.#state.operation && !this.#state.ready)
+                await this.#graph.load(false);
+            else if (!this.#state.operation && heads.heads.length === 1)
+                await this.#pin(heads.heads[0]);
+        });
+    }
+    selectPin(operation) {
+        this.#pinned = true;
+        return this.#run(() => this.#pin(operation));
+    }
+    checkpointChanged(operation) {
+        if (this.#closed ||
+            this.#pinned ||
+            this.#state.selected ||
+            this.#state.operation === operation)
+            return Promise.resolve();
+        return this.#run(() => this.#pin(operation));
+    }
+    async #pin(operation) {
+        const selection = ++this.#selection;
+        this.#detail++;
+        this.files.reset();
+        this.#abort.abort();
+        const abort = (this.#abort = new AbortController());
+        const prior = this.#handle;
+        this.#handle = undefined;
+        this.#set({
+            ...initialOperationState(),
+            heads: this.#state.heads,
+            headsReady: this.#state.headsReady,
+            operation,
+            phase: "loading",
+            busy: true,
+        });
+        if (prior)
+            await this.#lifetime.closeHandle(prior);
+        const handle = await this.reader.open(operation);
+        this.#lifetime.handles.add(handle);
+        if (this.#closed)
+            return;
+        if (selection !== this.#selection) {
+            await this.#lifetime.closeHandle(handle);
+            return;
+        }
+        this.#handle = handle;
+        const snapshot = await prepared(this.reader, handle, abort.signal, this.wait);
+        check(snapshot.operation === operation);
+        if (selection !== this.#selection || this.#closed)
+            return;
+        this.#set({ snapshot, phase: "ready" });
+        await this.#graph.load(false);
+    }
+    more() {
+        return this.#run(() => this.#graph.load(true));
+    }
+    loadRevisions() {
+        return this.#run(async () => {
+            const handle = this.#handle, detail = this.#detail;
+            if (!handle)
+                return;
+            const commits = await operationRevisionCards(this.reader, handle, this.#state, () => !this.#closed && this.#handle === handle && this.#detail === detail);
+            if (commits)
+                this.#set({ commits });
+        });
+    }
+    loadWorkspaces() {
+        return this.#run(() => this.#graph.workspaces());
+    }
+    selectWorkspace(workspace) {
+        return this.#run(async () => {
+            this.#detail++;
+            this.files.reset();
+            this.#set({ workspace, ...resetOperationSelection() });
+        });
+    }
+    clearSelection() {
+        return this.#run(async () => {
+            this.#detail++;
+            this.files.reset();
+            this.#set(resetOperationSelection());
+        });
+    }
+    select(node) {
+        return this.#run(async () => {
+            const selected = this.#state.selected?.id === node.id
+                ? this.#state.selected
+                : this.#state.nodes.find((item) => item.id === node.id);
+            check(selected);
+            await this.#selectNode(selected);
+        });
+    }
+    selectId(id) {
+        return this.#run(async () => {
+            const known = this.#state.nodes.find((node) => node.id === id);
+            if (known)
+                return this.#selectNode(known);
+            const handle = this.#handle;
+            check(handle && this.#state.selected?.parents.includes(id));
+            const request = ++this.#detail;
+            const node = await operationParent(this.reader, handle, this.#state.operation, this.#state.selected.id, id, () => !this.#closed && handle === this.#handle && request === this.#detail);
+            if (node)
+                await this.#selectNode(node);
+        });
+    }
+    async #selectNode(selected) {
+        this.#detail++;
+        this.files.reset();
+        this.#set({
+            selected,
+            parent: undefined,
+            detail: undefined,
+            parentNodes: [],
+        });
+        if (selected.parents.length <= 1)
+            await this.#compare(selected.parents[0]);
+    }
+    loadParents() {
+        return this.#run(async () => {
+            const handle = this.#handle, selected = this.#state.selected, request = this.#detail;
+            if (!handle || !selected)
+                return;
+            const parentNodes = await operationParents(this.reader, handle, this.#state.operation, selected.id, selected.parents, [...this.#state.nodes, ...this.#state.parentNodes], () => !this.#closed && handle === this.#handle && request === this.#detail);
+            if (parentNodes)
+                this.#set({ parentNodes });
+        });
+    }
+    selectParent(parent) {
+        return this.#run(async () => {
+            check(this.#state.selected?.parents.includes(parent));
+            await this.#compare(parent);
+        });
+    }
+    async #compare(parent) {
+        const handle = this.#handle, selected = this.#state.selected;
+        if (!handle || !selected)
+            return;
+        const request = ++this.#detail;
+        this.files.reset();
+        this.#set({ parent, detail: undefined });
+        const response = await this.reader.read(handle, {
+            kind: "operation_diff",
+            query: { operation: selected.id, parent },
+        });
+        if (this.#closed || handle !== this.#handle || request !== this.#detail)
+            return;
+        check(response.kind === "operation_diff" &&
+            response.data.data.operation === selected.id);
+        const detail = response.data.data;
+        if ("parent" in detail)
+            check(detail.parent === parent);
+        else if ("status" in detail && detail.status === "root")
+            check(!selected.parents.length);
+        this.#set({ detail });
+        if (detail.status === "difference")
+            await this.files.load(selected.id, detail.parent);
+    }
+    close() {
+        this.#closed = true;
+        this.#selection++;
+        this.#detail++;
+        this.files.reset();
+        this.#abort.abort();
+        this.#listeners.clear();
+        return (this.#closing ??= this.#lifetime.drain().catch((error) => {
+            this.#closing = undefined;
+            throw error;
+        }));
+    }
+}

package/dist/repository/controllers/operation-files.d.ts

@@ -0,0 +1,33 @@
+import type { LocalCodeQuery, LocalCodeResponse, LocalFileDiffChange, LocalOperationChangesGroup } from "@lapismd/jj-history";
+export interface OperationFilesState {
+    ready: boolean;
+    groups: LocalOperationChangesGroup[];
+    next?: string | null;
+    group?: LocalOperationChangesGroup;
+    from?: string;
+    to?: string;
+    paths: LocalFileDiffChange[];
+    pathsReady: boolean;
+    nextPath?: string | null;
+    path?: string;
+    diff?: LocalFileDiffChange;
+}
+export declare const initialOperationFiles: () => OperationFilesState;
+/** Shares the operation reader's lifetime; every reset fences delayed replies. */
+export declare class OperationFiles {
+    #private;
+    state: OperationFilesState;
+    readonly read: (q: LocalCodeQuery) => Promise<LocalCodeResponse>;
+    readonly run: (f: () => Promise<void>) => Promise<void>;
+    readonly changed: (s: OperationFilesState) => void;
+    constructor(read: OperationFiles["read"], run: OperationFiles["run"], changed: OperationFiles["changed"]);
+    reset(): void;
+    load(operation: string, parent: string): Promise<void>;
+    more(): Promise<void>;
+    retry(): Promise<void>;
+    selectGroup(change: string): Promise<void>;
+    compare(from: string, to: string): Promise<void>;
+    morePaths(): Promise<void>;
+    retryPaths(): Promise<void>;
+    selectPath(path: string): Promise<void>;
+}

package/dist/repository/controllers/operation-files.js

@@ -0,0 +1,182 @@
+import { check } from "./history-selection.js";
+export const initialOperationFiles = () => ({
+    ready: false,
+    groups: [],
+    paths: [],
+    pathsReady: false,
+});
+/** Shares the operation reader's lifetime; every reset fences delayed replies. */
+export class OperationFiles {
+    state = initialOperationFiles();
+    #epoch = 0;
+    #file = 0;
+    #operation;
+    #parent;
+    read;
+    run;
+    changed;
+    constructor(read, run, changed) {
+        this.read = read;
+        this.run = run;
+        this.changed = changed;
+    }
+    #set(patch) {
+        this.state = { ...this.state, ...patch };
+        this.changed(this.state);
+    }
+    reset() {
+        this.#epoch++;
+        this.#file++;
+        this.#operation = undefined;
+        this.#parent = undefined;
+        this.state = initialOperationFiles();
+        this.changed(this.state);
+    }
+    async load(operation, parent) {
+        this.reset();
+        this.#operation = operation;
+        this.#parent = parent;
+        await this.#groups(false);
+    }
+    more() {
+        return this.run(() => this.#groups(true));
+    }
+    retry() {
+        return this.run(() => this.#groups(false));
+    }
+    async #groups(append) {
+        const operation = this.#operation, parent = this.#parent, epoch = this.#epoch;
+        if (!operation || !parent || (append && !this.state.next))
+            return;
+        const response = await this.read({
+            kind: "operation_changes",
+            query: {
+                operation,
+                parent,
+                limit: 100,
+                anchor: append ? this.state.next : null,
+                direction: "forward",
+            },
+        });
+        if (epoch !== this.#epoch)
+            return;
+        check(response.kind === "operation_changes" &&
+            response.data.operation === operation &&
+            response.data.parent === parent);
+        const retained = append ? this.state.groups : [];
+        const ids = new Set(retained.map((g) => g.change));
+        for (const group of response.data.groups) {
+            check(!ids.has(group.change));
+            ids.add(group.change);
+        }
+        const groups = [...retained, ...response.data.groups].slice(0, 500);
+        this.#set({
+            groups,
+            ready: true,
+            next: groups.length < 500 ? response.data.next : null,
+        });
+    }
+    selectGroup(change) {
+        return this.run(async () => {
+            const group = this.state.groups.find((g) => g.change === change);
+            check(group);
+            this.#epoch++;
+            this.#file++;
+            this.#set({
+                group,
+                from: undefined,
+                to: undefined,
+                paths: [],
+                pathsReady: false,
+                nextPath: null,
+                path: undefined,
+                diff: undefined,
+            });
+            if (group.comparison.status === "exact")
+                await this.#compare(group.comparison.from, group.comparison.to);
+        });
+    }
+    compare(from, to) {
+        return this.run(() => this.#compare(from, to));
+    }
+    async #compare(from, to) {
+        const group = this.state.group;
+        check(group);
+        const comparison = group.comparison;
+        check(comparison.status === "exact"
+            ? comparison.from === from && comparison.to === to
+            : comparison.status === "select" &&
+                comparison.before.includes(from) &&
+                comparison.after.includes(to));
+        this.#epoch++;
+        this.#file++;
+        this.#set({
+            from,
+            to,
+            paths: [],
+            pathsReady: false,
+            nextPath: null,
+            path: undefined,
+            diff: undefined,
+        });
+        await this.#paths(false);
+    }
+    morePaths() {
+        return this.run(() => this.#paths(true));
+    }
+    retryPaths() {
+        return this.run(() => this.#paths(false));
+    }
+    async #paths(append) {
+        const { from, to, nextPath } = this.state, epoch = this.#epoch;
+        if (!from || !to || (append && !nextPath))
+            return;
+        const response = await this.read({
+            kind: "diff_paths",
+            query: {
+                from,
+                to,
+                path: "",
+                limit: 100,
+                anchor: append ? nextPath : null,
+                direction: "forward",
+            },
+        });
+        if (epoch !== this.#epoch)
+            return;
+        check(response.kind === "diff_paths" &&
+            response.data.from === from &&
+            response.data.to === to);
+        const paths = [
+            ...(append ? this.state.paths : []),
+            ...response.data.changes,
+        ].slice(0, 500);
+        this.#set({
+            paths,
+            pathsReady: true,
+            nextPath: paths.length < 500 ? response.data.next : null,
+        });
+    }
+    selectPath(path) {
+        return this.run(async () => {
+            const { from, to } = this.state, epoch = this.#epoch, request = ++this.#file;
+            if (!from || !to)
+                return;
+            check(this.state.paths.some((p) => p.path === path));
+            this.#set({ path, diff: undefined });
+            const response = await this.read({
+                kind: "diff",
+                query: { from, to, path, content: true },
+            });
+            if (epoch !== this.#epoch || request !== this.#file)
+                return;
+            check(response.kind === "diff" &&
+                response.data.from === from &&
+                response.data.to === to &&
+                response.data.path === path);
+            const diff = response.data.changes.find((c) => c.path === path);
+            check(diff);
+            this.#set({ diff });
+        });
+    }
+}

package/dist/repository/controllers/operation-graph.d.ts

@@ -0,0 +1,17 @@
+import type { Handle } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+import type { OperationState } from "./operation-state.js";
+type Scope = {
+    handle?: Handle;
+    state: OperationState;
+    closed: boolean;
+};
+export declare class OperationGraph {
+    readonly reader: HistoryReader;
+    readonly scope: () => Scope;
+    readonly publish: (patch: Partial<OperationState>) => void;
+    constructor(reader: HistoryReader, scope: () => Scope, publish: (patch: Partial<OperationState>) => void);
+    load(append: boolean): Promise<void>;
+    workspaces(): Promise<void>;
+}
+export {};

package/dist/repository/controllers/operation-graph.js

@@ -0,0 +1,50 @@
+import { check } from "./history-selection.js";
+import { workspaceCommits } from "./operation-metadata.js";
+export class OperationGraph {
+    reader;
+    scope;
+    publish;
+    constructor(reader, scope, publish) {
+        this.reader = reader;
+        this.scope = scope;
+        this.publish = publish;
+    }
+    async load(append) {
+        const handle = this.scope().handle, operation = this.scope().state.operation;
+        if (!handle || !operation || (append && !this.scope().state.next))
+            return;
+        const response = await this.reader.read(handle, {
+            kind: "graph",
+            query: [
+                { graph: "operations" },
+                { limit: 50, after: append ? this.scope().state.next : null },
+            ],
+        });
+        if (handle !== this.scope().handle || this.scope().closed)
+            return;
+        check(response.kind === "graph" &&
+            response.data.operation === operation &&
+            response.data.data.graph === "operations");
+        const retained = append ? this.scope().state.nodes : [];
+        const incoming = response.data.data.nodes;
+        const ids = new Set(retained.map((node) => node.id));
+        for (const node of incoming) {
+            check(!ids.has(node.id));
+            ids.add(node.id);
+        }
+        const nodes = [...retained, ...incoming].slice(0, 200);
+        this.publish({
+            nodes,
+            ready: true,
+            next: nodes.length < 200 ? response.data.next : null,
+        });
+    }
+    async workspaces() {
+        const { handle, state } = this.scope();
+        if (!handle || !state.operation)
+            return;
+        const commits = await workspaceCommits(this.reader, handle, state.operation);
+        if (!this.scope().closed && handle === this.scope().handle)
+            this.publish({ workspaceCommits: commits });
+    }
+}

package/dist/repository/controllers/operation-message.d.ts

@@ -0,0 +1,5 @@
+/** jj-store message tokenization: complete native/Git commit and change IDs only. */
+export declare function operationMessageParts(message: string): {
+    type: "text" | "commit" | "change";
+    value: string;
+}[];

package/dist/repository/controllers/operation-message.js

@@ -0,0 +1,18 @@
+/** jj-store message tokenization: complete native/Git commit and change IDs only. */
+export function operationMessageParts(message) {
+    const identity = /\b(?:[0-9a-fA-F]{128}|[0-9a-fA-F]{40}|[0-9a-fA-F]{32})\b/gu;
+    const parts = [];
+    let last = 0;
+    for (const match of message.matchAll(identity)) {
+        if (match.index > last)
+            parts.push({ type: "text", value: message.slice(last, match.index) });
+        parts.push({
+            type: match[0].length === 32 ? "change" : "commit",
+            value: match[0].toLowerCase(),
+        });
+        last = match.index + match[0].length;
+    }
+    if (last < message.length)
+        parts.push({ type: "text", value: message.slice(last) });
+    return parts.length ? parts : [{ type: "text", value: message }];
+}

package/dist/repository/controllers/operation-metadata.d.ts

@@ -0,0 +1,5 @@
+import type { Handle, LocalGraphCommit } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+import type { OperationState } from "./operation-state.js";
+export declare function operationRevisionCards(reader: HistoryReader, handle: Handle, state: OperationState, current: () => boolean): Promise<LocalGraphCommit[] | undefined>;
+export declare function workspaceCommits(reader: HistoryReader, handle: Handle, operation: string): Promise<LocalGraphCommit[]>;

package/dist/repository/controllers/operation-metadata.js

@@ -0,0 +1,26 @@
+import { parentCandidates } from "./parent-candidates.js";
+import { check } from "./history-selection.js";
+export function operationRevisionCards(reader, handle, state, current) {
+    const ids = [
+        ...new Set(state.files.groups.flatMap((g) => [...g.after, ...g.before])),
+    ].slice(0, 64);
+    return parentCandidates(reader, handle, ids, state.commits, current);
+}
+export async function workspaceCommits(reader, handle, operation) {
+    const response = await reader.read(handle, {
+        kind: "graph",
+        query: [
+            {
+                graph: "log",
+                revset: "working_copies()",
+                user_email: "",
+                at_time_millis: Date.now(),
+            },
+            { limit: 64, after: null },
+        ],
+    });
+    check(response.kind === "graph" &&
+        response.data.operation === operation &&
+        response.data.data.graph === "log");
+    return response.data.data.nodes.map((n) => n.commit);
+}

package/dist/repository/controllers/operation-parent.d.ts

@@ -0,0 +1,5 @@
+import type { Handle, LocalGraphOperationNode } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+/** Resolve metadata through the desktop's qualified immutable graph profile. */
+export declare function operationParents(reader: HistoryReader, handle: Handle, pin: string, selected: string, parents: readonly string[], known: readonly LocalGraphOperationNode[], current: () => boolean): Promise<LocalGraphOperationNode[] | undefined>;
+export declare function operationParent(reader: HistoryReader, handle: Handle, pin: string, selected: string, parent: string, current: () => boolean): Promise<LocalGraphOperationNode | undefined>;