@theia/scm 1.71.0-next.72 → 1.71.0

package/src/browser/scm-history-graph-lanes.ts

@@ -0,0 +1,258 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/**
+ * DAG graph lane computation for SCM commit history visualization.
+ *
+ * Each row in the graph has:
+ * - `lane`: the column index where the commit circle is drawn
+ * - `color`: a lane index (0-7) used to pick a CSS color variable
+ * - `edges`: segments to draw on this row — each segment connects two lane
+ *   positions and carries a color and type
+ *
+ * Edge types determine how each segment is rendered in the SVG:
+ * - `'pass-through'`: straight vertical line through the full row height
+ * - `'branch-out'`:  bezier curve starting at the commit's Y (mid-row),
+ *                    sweeping down to the new lane at the bottom of the row
+ * - `'merge-in'`:    bezier curve starting at the source lane at the top of
+ *                    the row, sweeping into the commit's Y (mid-row)
+ */
+
+export type GraphEdgeType = 'pass-through' | 'branch-out' | 'merge-in';
+
+export interface GraphEdge {
+    /** Source lane position (top of the row for pass-through/merge-in; commit lane for branch-out). */
+    readonly fromLane: number;
+    /** Target lane position (bottom of the row for pass-through/branch-out; commit lane for merge-in). */
+    readonly toLane: number;
+    /** Color index (0–7) for this edge. */
+    readonly color: number;
+    /** How this edge should be rendered in the SVG. */
+    readonly type: GraphEdgeType;
+}
+
+export interface GraphRow {
+    /** Lane index where the commit node is rendered. */
+    readonly lane: number;
+    /** Color index for the commit node dot. */
+    readonly color: number;
+    /** Edges crossing or originating on this row. */
+    readonly edges: readonly GraphEdge[];
+    /**
+     * Whether the commit's lane continues downward (i.e. first parent stays in
+     * the same lane). When false, no bottom line segment is drawn below the
+     * commit circle (root commit or merge convergence where the lane is freed).
+     */
+    readonly hasContinuation: boolean;
+    /**
+     * Whether there is an incoming line from above on the commit's lane (i.e.
+     * the commit was referenced as a parent by an earlier row). When false,
+     * no top line segment is drawn above the commit circle.
+     */
+    readonly hasTopLine: boolean;
+}
+
+/**
+ * Mutable version of GraphRow used internally during computation.
+ */
+interface MutableGraphRow {
+    lane: number;
+    color: number;
+    edges: GraphEdge[];
+    hasContinuation: boolean;
+    hasTopLine: boolean;
+}
+
+/**
+ * Compute graph rows for an ordered list of commits (topological order,
+ * newest first). Each commit must supply its own `id` and `parentIds`.
+ *
+ * @param commits Topologically sorted commits (newest → oldest).
+ * @returns One `GraphRow` per commit in the same order.
+ */
+export function computeGraphRows(
+    commits: ReadonlyArray<{ id: string; parentIds?: readonly string[] }>
+): GraphRow[] {
+    // lanes[i] = id of commit that "owns" lane i (i.e. we are waiting for this
+    // commit to appear in the list so we can close the lane).
+    const lanes: (string | undefined)[] = [];
+    // laneColors[i] = the color index permanently assigned to lane i
+    const laneColors: (number | undefined)[] = [];
+
+    const rows: MutableGraphRow[] = [];
+
+    for (const commit of commits) {
+        const parentIds = commit.parentIds ?? [];
+
+        // --- 1. Find or assign a lane for this commit -----------------------
+        let myLane = lanes.indexOf(commit.id);
+        // hasTopLine: true when this commit was already reserved as a parent by
+        // an earlier row — meaning there IS a connection coming from above.
+        const hasTopLine = myLane !== -1;
+        if (myLane === -1) {
+            // Not yet tracked → open a new lane
+            myLane = firstFreeLane(lanes);
+            lanes[myLane] = commit.id;
+            laneColors[myLane] = myLane % 8;
+        }
+
+        const myColor = laneColors[myLane] ?? myLane % 8;
+
+        // Collect any duplicate lane occupants: other lanes that were kept
+        // alive pointing at this same commit (sibling branch tips whose lane
+        // was preserved until the parent row).  These emit merge-in edges and
+        // are freed before the pass-through snapshot so they don't appear as
+        // spurious pass-through lines on this row.
+        const duplicateLanes: { lane: number; color: number }[] = [];
+        if (hasTopLine) {
+            for (let li = 0; li < lanes.length; li++) {
+                if (lanes[li] === commit.id && li !== myLane) {
+                    duplicateLanes.push({ lane: li, color: laneColors[li] ?? li % 8 });
+                    lanes[li] = undefined;
+                    laneColors[li] = undefined;
+                }
+            }
+        }
+
+        // --- 2. Snapshot current lane state before mutations ----------------
+        const lanesCopy = lanes.slice();
+
+        // --- 3. Determine parent lane assignments ---------------------------
+        const parentLanes: number[] = [];
+        // Track which parents were ALREADY in existing lanes (merge-in) vs new
+        const parentIsExisting: boolean[] = [];
+
+        for (let pi = 0; pi < parentIds.length; pi++) {
+            const pid = parentIds[pi];
+
+            const parentLane = lanesCopy.indexOf(pid);
+
+            if (parentLane !== -1 && parentLane !== myLane) {
+                if (hasTopLine) {
+                    // Pre-reserved commit: parent already has a lane → merge-in edge on this row.
+                    parentLanes.push(parentLane);
+                    parentIsExisting.push(true);
+                } else {
+                    // Non-pre-reserved sibling branch tip: keep this lane alive so it
+                    // passes through as a pass-through line until the parent row, where
+                    // a merge-in is emitted via the duplicateLanes mechanism.
+                    // No edge is emitted here; record myLane so hasContinuation is true.
+                    lanes[myLane] = pid;
+                    parentLanes.push(myLane);
+                    parentIsExisting.push(false);
+                }
+            } else if (parentLane === myLane) {
+                // First parent inherits this lane (fast-forward) — straight down
+                parentLanes.push(myLane);
+                parentIsExisting.push(false); // treated as inline continuation
+            } else {
+                // New parent → assign a lane
+                if (pi === 0) {
+                    // First parent continues in the same lane
+                    lanes[myLane] = pid;
+                    // Keep the same color as myLane for the first parent
+                    parentLanes.push(myLane);
+                    parentIsExisting.push(false);
+                } else {
+                    // Additional parents get new lanes — branch-out
+                    const newLane = firstFreeLane(lanes);
+                    lanes[newLane] = pid;
+                    laneColors[newLane] = newLane % 8;
+                    parentLanes.push(newLane);
+                    parentIsExisting.push(false);
+                }
+            }
+        }
+
+        // If the commit has no parents (root commit), free the lane
+        if (parentIds.length === 0) {
+            lanes[myLane] = undefined;
+            laneColors[myLane] = undefined;
+        } else if (!parentLanes.includes(myLane)) {
+            // No parent inherited myLane — decide whether to free or keep the lane.
+            if (hasTopLine) {
+                // Pre-reserved commit (merge convergence): free the lane immediately.
+                lanes[myLane] = undefined;
+                laneColors[myLane] = undefined;
+            } else {
+                // Non-pre-reserved sibling branch tip: keep the lane alive pointing
+                // at the first parent so it persists as a pass-through until the
+                // parent row.  At the parent row, the duplicate lane occupant is
+                // detected and a merge-in edge is emitted there instead.
+                lanes[myLane] = parentIds[0];
+            }
+        }
+
+        // --- 4. Emit edges --------------------------------------------------
+        const edges: GraphEdge[] = [];
+
+        // Pass-through lines: lanes that were occupied before this row and
+        // are NOT the commit's own lane continue straight through.
+        for (let li = 0; li < lanesCopy.length; li++) {
+            const occupant = lanesCopy[li];
+            if (!occupant || occupant === commit.id) {
+                continue;
+            }
+            const color = laneColors[li] ?? li % 8;
+            edges.push({ fromLane: li, toLane: li, color, type: 'pass-through' });
+        }
+
+        for (let pi = 0; pi < parentIds.length; pi++) {
+            const toLane = parentLanes[pi];
+            const isExisting = parentIsExisting[pi];
+
+            if (toLane === myLane) {
+                // First parent continues in the same lane — no edge is emitted.
+                // The vertical connection is represented by hasContinuation:true on
+                // this row and hasTopLine:true on the parent's row; the SVG renderer
+                // draws the top/bottom line segments around the commit circle instead.
+                continue;
+            }
+
+            if (isExisting) {
+                // Merge-in: an existing lane at the top of the row curves into
+                // the commit position at mid-row.
+                const color = laneColors[toLane] ?? toLane % 8;
+                edges.push({ fromLane: toLane, toLane: myLane, color, type: 'merge-in' });
+            } else {
+                // Branch-out: the commit spawns a new lane below mid-row.
+                const color = laneColors[toLane] ?? toLane % 8;
+                edges.push({ fromLane: myLane, toLane, color, type: 'branch-out' });
+            }
+        }
+
+        // Merge-in edges for duplicate lane occupants (sibling branch tips
+        // converging into this commit's lane).
+        for (const dl of duplicateLanes) {
+            edges.push({ fromLane: dl.lane, toLane: myLane, color: dl.color, type: 'merge-in' });
+        }
+
+        // hasContinuation: true if the first parent continues in the same lane,
+        // OR if this is a sibling branch tip whose lane was kept alive (pointing
+        // at the parent) so it persists as a pass-through to the parent row.
+        const hasContinuation = parentIds.length > 0 && (parentLanes[0] === myLane || lanes[myLane] === parentIds[0]);
+
+        rows.push({ lane: myLane, color: myColor, edges, hasContinuation, hasTopLine });
+    }
+
+    return rows;
+}
+
+/** Returns the index of the first undefined slot, or lanes.length if full. */
+function firstFreeLane(lanes: (string | undefined)[]): number {
+    const idx = lanes.indexOf(undefined);
+    return idx === -1 ? lanes.length : idx;
+}

package/src/browser/scm-history-graph-model.spec.ts

@@ -0,0 +1,171 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { Emitter } from '@theia/core/lib/common/event';
+import { ScmHistoryGraphModel, PAGE_SIZE } from './scm-history-graph-model';
+import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryItemChange, ScmHistoryOptions, ScmHistoryProvider } from './scm-provider';
+import { ScmRepository } from './scm-repository';
+
+class StubHistoryProvider implements ScmHistoryProvider {
+    readonly currentHistoryItemRef: ScmHistoryItemRef | undefined;
+    readonly currentHistoryItemRemoteRef: ScmHistoryItemRef | undefined;
+    readonly currentHistoryItemBaseRef: ScmHistoryItemRef | undefined;
+
+    readonly onDidChangeCurrentHistoryItemRefs = new Emitter<void>().event;
+    readonly onDidChangeHistoryItemRefs = new Emitter<{
+        readonly added: readonly ScmHistoryItemRef[];
+        readonly removed: readonly ScmHistoryItemRef[];
+        readonly modified: readonly ScmHistoryItemRef[];
+    }>().event;
+
+    /** Pages this provider will return on consecutive calls (FIFO). */
+    pages: ScmHistoryItem[][] = [];
+    /** Captured options for each call (so tests can assert what was sent). */
+    receivedOptions: ScmHistoryOptions[] = [];
+
+    async provideHistoryItemRefs(): Promise<ScmHistoryItemRef[] | undefined> {
+        return [];
+    }
+
+    async provideHistoryItems(options: ScmHistoryOptions): Promise<ScmHistoryItem[] | undefined> {
+        this.receivedOptions.push(options);
+        return this.pages.shift() ?? [];
+    }
+
+    async provideHistoryItemChanges(): Promise<ScmHistoryItemChange[] | undefined> {
+        return [];
+    }
+
+    async resolveHistoryItem(): Promise<ScmHistoryItem | undefined> {
+        return undefined;
+    }
+
+    async resolveHistoryItemRefsCommonAncestor(): Promise<string | undefined> {
+        return undefined;
+    }
+}
+
+function makeItems(start: number, count: number): ScmHistoryItem[] {
+    const items: ScmHistoryItem[] = [];
+    for (let i = 0; i < count; i++) {
+        const id = `c${start + i}`;
+        items.push({
+            id,
+            subject: `commit ${id}`,
+            parentIds: [`c${start + i + 1}`],
+        });
+    }
+    return items;
+}
+
+/**
+ * Instantiates the model with a stub provider, bypassing inversify and the
+ * SCM service so tests can drive pagination directly via loadPage().
+ */
+function createModel(provider: ScmHistoryProvider): { model: ScmHistoryGraphModel; loadPage(): Promise<void> } {
+    const model = new ScmHistoryGraphModel();
+    const internals = model as unknown as {
+        scmService: {
+            onDidChangeSelectedRepository: Emitter<ScmRepository | undefined>['event'];
+            selectedRepository: ScmRepository | undefined;
+        };
+        _provider: ScmHistoryProvider | undefined;
+        init(): void;
+        loadPage(): Promise<void>;
+    };
+    internals.scmService = {
+        onDidChangeSelectedRepository: new Emitter<ScmRepository | undefined>().event,
+        selectedRepository: undefined,
+    };
+    internals.init();
+    internals._provider = provider;
+    return {
+        model,
+        loadPage: () => internals.loadPage(),
+    };
+}
+
+describe('ScmHistoryGraphModel - pagination', () => {
+
+    it('hasMore is true when a full page returns', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, PAGE_SIZE)];
+        const { model, loadPage } = createModel(provider);
+
+        await loadPage();
+
+        expect(model.entries).to.have.length(PAGE_SIZE);
+        expect(model.hasMore).to.be.true;
+    });
+
+    it('hasMore is false when fewer than a full page is returned', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10)];
+        const { model, loadPage } = createModel(provider);
+
+        await loadPage();
+
+        expect(model.entries).to.have.length(10);
+        expect(model.hasMore).to.be.false;
+    });
+
+    it('paginates using skip = current entry count', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [
+            makeItems(1, PAGE_SIZE),
+            makeItems(51, PAGE_SIZE),
+            makeItems(101, 10),
+        ];
+        const { model, loadPage } = createModel(provider);
+
+        await loadPage();
+        expect(model.entries).to.have.length(PAGE_SIZE);
+        expect(provider.receivedOptions[0].skip).to.equal(0);
+
+        await loadPage();
+        expect(model.entries).to.have.length(2 * PAGE_SIZE);
+        expect(provider.receivedOptions[1].skip).to.equal(PAGE_SIZE);
+
+        await loadPage();
+        expect(model.entries).to.have.length(2 * PAGE_SIZE + 10);
+        expect(provider.receivedOptions[2].skip).to.equal(2 * PAGE_SIZE);
+    });
+
+    it('passes skip and not cursor (cursor is not part of the VS Code SCM history options API)', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, PAGE_SIZE)];
+        const { loadPage } = createModel(provider);
+
+        await loadPage();
+
+        expect((provider.receivedOptions[0] as { cursor?: string }).cursor).to.be.undefined;
+        expect(provider.receivedOptions[0]).to.have.property('skip');
+    });
+
+    it('does not grow entries when a provider re-returns duplicates', async () => {
+        const provider = new StubHistoryProvider();
+        const firstPage = makeItems(1, PAGE_SIZE);
+        provider.pages = [firstPage, firstPage.slice()];
+        const { model, loadPage } = createModel(provider);
+
+        await loadPage();
+        expect(model.entries).to.have.length(PAGE_SIZE);
+
+        await loadPage();
+        expect(model.entries).to.have.length(PAGE_SIZE, 'should not grow when all items are duplicates');
+    });
+});

package/src/browser/scm-history-graph-model.ts

@@ -0,0 +1,207 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { Emitter } from '@theia/core/lib/common/event';
+import { CancellationTokenSource } from '@theia/core/lib/common/cancellation';
+import { ScmService } from './scm-service';
+import { ScmHistoryItem, ScmHistoryProvider, ScmHistoryOptions } from './scm-provider';
+import { computeGraphRows, GraphRow } from './scm-history-graph-lanes';
+
+export const PAGE_SIZE = 50;
+
+export interface HistoryGraphEntry {
+    readonly item: ScmHistoryItem;
+    readonly graphRow: GraphRow;
+}
+
+@injectable()
+export class ScmHistoryGraphModel {
+
+    @inject(ScmService) protected readonly scmService: ScmService;
+
+    protected readonly toDispose = new DisposableCollection();
+    protected readonly toDisposeOnProviderChange = new DisposableCollection();
+
+    protected _entries: HistoryGraphEntry[] = [];
+    protected _hasMore = false;
+    protected _loading = false;
+    protected _hasAttemptedLoad = false;
+    protected _provider: ScmHistoryProvider | undefined;
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange = this.onDidChangeEmitter.event;
+
+    protected cancelSource = new CancellationTokenSource();
+
+    @postConstruct()
+    protected init(): void {
+        this.toDispose.pushAll([
+            Disposable.create(() => this.toDisposeOnProviderChange.dispose()),
+            this.onDidChangeEmitter,
+            this.scmService.onDidChangeSelectedRepository(() => this.refresh()),
+        ]);
+        this.refresh();
+    }
+
+    dispose(): void {
+        this.cancelSource.cancel();
+        this.toDispose.dispose();
+    }
+
+    get provider(): ScmHistoryProvider | undefined {
+        return this._provider;
+    }
+
+    get entries(): readonly HistoryGraphEntry[] {
+        return this._entries;
+    }
+
+    get hasMore(): boolean {
+        return this._hasMore;
+    }
+
+    get loading(): boolean {
+        return this._loading;
+    }
+
+    /**
+     * Returns true once the model has completed at least one load attempt
+     * (regardless of whether history items were found). This is used by
+     * the widget to distinguish "still initializing" from "no history".
+     */
+    get hasAttemptedLoad(): boolean {
+        return this._hasAttemptedLoad;
+    }
+
+    refresh(): void {
+        this.cancelSource.cancel();
+        this.cancelSource = new CancellationTokenSource();
+
+        this.toDisposeOnProviderChange.dispose();
+
+        const repo = this.scmService.selectedRepository;
+        const hp = repo?.provider.historyProvider;
+        this._provider = hp;
+
+        if (this._provider) {
+            this.toDisposeOnProviderChange.push(
+                this._provider.onDidChangeCurrentHistoryItemRefs(() => this.refresh())
+            );
+            this.toDisposeOnProviderChange.push(
+                this._provider.onDidChangeHistoryItemRefs(() => this.refresh())
+            );
+        } else if (repo) {
+            // historyProvider is not yet available; listen for provider changes
+            // so that refresh() is retried when historyProvider becomes available.
+            this.toDisposeOnProviderChange.push(
+                repo.provider.onDidChange(() => this.refresh())
+            );
+        }
+
+        this._entries = [];
+        this._hasMore = false;
+
+        this.loadPage();
+    }
+
+    async loadMore(): Promise<void> {
+        if (this._loading || !this._hasMore) {
+            return;
+        }
+        await this.loadPage();
+    }
+
+    protected async loadPage(): Promise<void> {
+        if (!this._provider) {
+            this._entries = [];
+            this._hasMore = false;
+            this._loading = false;
+            this._hasAttemptedLoad = true;
+            this.onDidChangeEmitter.fire();
+            return;
+        }
+
+        this._loading = true;
+        this.onDidChangeEmitter.fire();
+
+        const token = this.cancelSource.token;
+        try {
+            const historyItemRefs = this.getCurrentHistoryItemRefs();
+            const options: ScmHistoryOptions = {
+                skip: this._entries.length,
+                limit: PAGE_SIZE,
+                historyItemRefs: historyItemRefs.length > 0 ? historyItemRefs : undefined,
+            };
+            const items = await this._provider.provideHistoryItems(options, token);
+
+            if (token.isCancellationRequested) {
+                return;
+            }
+
+            const fetchedItems: ScmHistoryItem[] = items ?? [];
+            this._hasMore = fetchedItems.length >= PAGE_SIZE;
+
+            // Filter out any items already loaded so the graph does not show duplicates.
+            const existingIds = new Set(this._entries.map(e => e.item.id));
+            const newItems = fetchedItems.filter(i => !existingIds.has(i.id));
+
+            const allItems = [...this._entries.map(e => e.item), ...newItems];
+            const graphRows = computeGraphRows(allItems.map(i => ({
+                id: i.id,
+                parentIds: i.parentIds,
+            })));
+
+            this._entries = allItems.map((item, idx) => ({
+                item,
+                graphRow: graphRows[idx],
+            }));
+        } catch (err) {
+            if (!token.isCancellationRequested) {
+                console.error('ScmHistoryGraphModel: failed to load history', err);
+            }
+        } finally {
+            if (!token.isCancellationRequested) {
+                this._loading = false;
+                this._hasAttemptedLoad = true;
+                this.onDidChangeEmitter.fire();
+            }
+        }
+    }
+
+    /**
+     * Returns the revisions of the current branch ref, its remote tracking ref,
+     * and the merge-base ref to pass to `provideHistoryItems`. Providers walk
+     * history starting from these revisions.
+     */
+    protected getCurrentHistoryItemRefs(): string[] {
+        if (!this._provider) {
+            return [];
+        }
+        const refs: string[] = [];
+        if (this._provider.currentHistoryItemRef) {
+            refs.push(this._provider.currentHistoryItemRef.revision ?? this._provider.currentHistoryItemRef.id);
+        }
+        if (this._provider.currentHistoryItemRemoteRef) {
+            refs.push(this._provider.currentHistoryItemRemoteRef.revision ?? this._provider.currentHistoryItemRemoteRef.id);
+        }
+        if (this._provider.currentHistoryItemBaseRef) {
+            refs.push(this._provider.currentHistoryItemBaseRef.revision ?? this._provider.currentHistoryItemBaseRef.id);
+        }
+        return refs;
+    }
+}