@theia/scm 1.77.0-next.47 → 1.77.0-next.56

package/lib/browser/multi-diff-editor/multi-diff-editor-widget.spec.js

@@ -0,0 +1,835 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const jsdom_1 = require("@theia/core/lib/browser/test/jsdom");
+let disableJSDOM = (0, jsdom_1.enableJSDOM)();
+const frontend_application_config_provider_1 = require("@theia/core/lib/browser/frontend-application-config-provider");
+frontend_application_config_provider_1.FrontendApplicationConfigProvider.set({});
+const chai_1 = require("chai");
+const sinon = tslib_1.__importStar(require("sinon"));
+const monaco_editor_1 = require("@theia/monaco/lib/browser/monaco-editor");
+const monaco_diff_editor_1 = require("@theia/monaco/lib/browser/monaco-diff-editor");
+const multi_diff_editor_widget_factory_1 = require("./multi-diff-editor-widget-factory");
+const core_1 = require("@theia/core");
+const browser_1 = require("@theia/core/lib/browser");
+const inversify_1 = require("@theia/core/shared/inversify");
+const multi_diff_editor_1 = require("./multi-diff-editor");
+const multi_diff_editor_uri_1 = require("./multi-diff-editor-uri");
+disableJSDOM();
+describe('Multi-Diff Editor — widgets', () => {
+    before(() => {
+        disableJSDOM = (0, jsdom_1.enableJSDOM)();
+    });
+    after(() => {
+        disableJSDOM();
+    });
+    // Minimal LabelProvider mock — only the methods DiffEntryHeaderWidget uses.
+    const mockLabelProvider = {
+        getIcon: (_) => 'codicon codicon-file',
+        getName: (uri) => uri.path.base,
+        getLongName: (uri) => uri.path.toString()
+    };
+    const sampleResource = {
+        originalUri: new core_1.URI('file:///workspace/a.ts'),
+        modifiedUri: new core_1.URI('file:///workspace/b.ts')
+    };
+    describe('DiffEntryHeaderWidget', () => {
+        it('should render icon, name and description', () => {
+            const widget = new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider);
+            try {
+                (0, chai_1.expect)(widget.node.querySelector('.multi-diff-entry-icon')).to.exist;
+                (0, chai_1.expect)(widget.node.querySelector('.multi-diff-entry-label')?.textContent).to.equal('b.ts');
+                (0, chai_1.expect)(widget.node.querySelector('.multi-diff-entry-description')?.textContent).to.equal('/workspace/b.ts');
+            }
+            finally {
+                widget.dispose();
+            }
+        });
+        it('should expose aria-expanded=true by default', () => {
+            const widget = new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider);
+            try {
+                (0, chai_1.expect)(widget.node.getAttribute('aria-expanded')).to.equal('true');
+                (0, chai_1.expect)(widget.node.querySelector('.codicon-chevron-down')).to.exist;
+            }
+            finally {
+                widget.dispose();
+            }
+        });
+        it('should toggle chevron and aria-expanded on setCollapsed', () => {
+            const widget = new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider);
+            try {
+                widget.setCollapsed(true);
+                (0, chai_1.expect)(widget.node.getAttribute('aria-expanded')).to.equal('false');
+                (0, chai_1.expect)(widget.node.querySelector('.codicon-chevron-right')).to.exist;
+                (0, chai_1.expect)(widget.node.querySelector('.codicon-chevron-down')).to.be.null;
+                widget.setCollapsed(false);
+                (0, chai_1.expect)(widget.node.getAttribute('aria-expanded')).to.equal('true');
+                (0, chai_1.expect)(widget.node.querySelector('.codicon-chevron-down')).to.exist;
+            }
+            finally {
+                widget.dispose();
+            }
+        });
+        it('should fire onDidToggleCollapse when clicked', () => {
+            const widget = new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider);
+            try {
+                let fired = 0;
+                widget.onDidToggleCollapse(() => fired++);
+                widget.node.click();
+                (0, chai_1.expect)(fired).to.equal(1);
+            }
+            finally {
+                widget.dispose();
+            }
+        });
+    });
+    describe('DiffEntryWidget', () => {
+        function createEntry() {
+            const header = new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider);
+            const entry = new multi_diff_editor_1.DiffEntryWidget(sampleResource, header);
+            return { entry, header };
+        }
+        it('should start in loading state with MIN_ENTRY_HEIGHT', () => {
+            const { entry } = createEntry();
+            try {
+                (0, chai_1.expect)(entry.editorWidget).to.be.undefined;
+                (0, chai_1.expect)(entry.isCollapsed).to.be.false;
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.MIN_ENTRY_HEIGHT}px`);
+                (0, chai_1.expect)(entry.node.querySelector('.multi-diff-entry-loading')).to.exist;
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should transition to error state on setError', () => {
+            const { entry } = createEntry();
+            try {
+                entry.setError('boom');
+                (0, chai_1.expect)(entry.node.querySelector('.multi-diff-entry-loading')).to.be.null;
+                (0, chai_1.expect)(entry.node.querySelector('.multi-diff-entry-error')?.textContent).to.contain('boom');
+                (0, chai_1.expect)(entry.editorWidget).to.be.undefined;
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should fit short content and cap large entries before the viewport size is known', () => {
+            const { entry } = createEntry();
+            try {
+                entry.setHeight(50);
+                (0, chai_1.expect)(entry.node.style.height).to.equal('50px');
+                entry.setHeight(10_000);
+                (0, chai_1.expect)(entry.node.style.height).to.equal('5000px');
+                entry.setHeight(multi_diff_editor_1.MIN_ENTRY_HEIGHT + 42);
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.MIN_ENTRY_HEIGHT + 42}px`);
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should shrink to HEADER_HEIGHT when collapsed and restore height when expanded', () => {
+            const { entry } = createEntry();
+            try {
+                entry.setHeight(multi_diff_editor_1.MIN_ENTRY_HEIGHT + 100);
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.MIN_ENTRY_HEIGHT + 100}px`);
+                entry.setCollapsed(true);
+                (0, chai_1.expect)(entry.isCollapsed).to.be.true;
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.HEADER_HEIGHT}px`);
+                entry.setCollapsed(false);
+                (0, chai_1.expect)(entry.isCollapsed).to.be.false;
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.MIN_ENTRY_HEIGHT + 100}px`);
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should remember requested height while collapsed and apply it on expand', () => {
+            const { entry } = createEntry();
+            try {
+                entry.setCollapsed(true);
+                // setHeight while collapsed updates the remembered expanded height only.
+                entry.setHeight(multi_diff_editor_1.MIN_ENTRY_HEIGHT + 50);
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.HEADER_HEIGHT}px`);
+                entry.setCollapsed(false);
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.MIN_ENTRY_HEIGHT + 50}px`);
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should hide content when collapsed, including content loaded afterwards', () => {
+            const { entry } = createEntry();
+            try {
+                entry.setCollapsed(true);
+                (0, chai_1.expect)(entry['currentContent'].isHidden).to.be.true;
+                entry.setError('boom');
+                (0, chai_1.expect)(entry['currentContent'].isHidden).to.be.true;
+                entry.setCollapsed(false);
+                (0, chai_1.expect)(entry['currentContent'].isHidden).to.be.false;
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should retain the available height across content updates and collapse', () => {
+            const { entry } = createEntry();
+            try {
+                entry.setAvailableHeight(800);
+                entry.setHeight(200);
+                (0, chai_1.expect)(entry.node.style.height).to.equal('800px');
+                entry.setCollapsed(true);
+                entry.setAvailableHeight(600);
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.HEADER_HEIGHT}px`);
+                entry.setCollapsed(false);
+                (0, chai_1.expect)(entry.node.style.height).to.equal('600px');
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should be a no-op when setCollapsed is called with the current value', () => {
+            const { entry } = createEntry();
+            try {
+                let fired = 0;
+                entry.onDidChangeCollapsed(() => fired++);
+                entry.setCollapsed(false);
+                (0, chai_1.expect)(fired).to.equal(0);
+                entry.setCollapsed(true);
+                (0, chai_1.expect)(fired).to.equal(1);
+                entry.setCollapsed(true);
+                (0, chai_1.expect)(fired).to.equal(1);
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should toggle collapsed when the header fires onDidToggleCollapse', () => {
+            const { entry, header } = createEntry();
+            try {
+                (0, chai_1.expect)(entry.isCollapsed).to.be.false;
+                header.node.click();
+                (0, chai_1.expect)(entry.isCollapsed).to.be.true;
+                header.node.click();
+                (0, chai_1.expect)(entry.isCollapsed).to.be.false;
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+    });
+    describe('entry loading', () => {
+        function createEntry(load) {
+            return new multi_diff_editor_1.DiffEntryWidget(sampleResource, new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider), load);
+        }
+        it('should skip collapsed entries, load on expansion, and suppress concurrent or repeated loads', async () => {
+            let resolve;
+            const load = sinon.stub().returns(new Promise(r => resolve = r));
+            const entry = createEntry(load);
+            const widget = new browser_1.Widget();
+            try {
+                entry.setCollapsed(true);
+                await entry.loadEditor();
+                (0, chai_1.expect)(load.callCount).to.equal(0);
+                entry.setCollapsed(false);
+                await entry.loadEditor();
+                (0, chai_1.expect)(load.callCount).to.equal(1);
+                entry.setCollapsed(true);
+                resolve(widget);
+                await Promise.resolve();
+                (0, chai_1.expect)(entry.editorWidget).to.equal(widget);
+                (0, chai_1.expect)(widget.isHidden).to.be.true;
+                entry.setCollapsed(false);
+                await entry.loadEditor();
+                (0, chai_1.expect)(load.callCount).to.equal(1);
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should offer a native Retry button, restore loading state, and serialize retries', async () => {
+            let resolve;
+            const load = sinon.stub();
+            load.onFirstCall().rejects(new Error('provider unavailable'));
+            load.onSecondCall().returns(new Promise(r => resolve = r));
+            const entry = createEntry(load);
+            const widget = new browser_1.Widget();
+            try {
+                await entry.loadEditor();
+                const button = entry.node.querySelector('button');
+                (0, chai_1.expect)(button.textContent).to.equal('Retry');
+                (0, chai_1.expect)(button.type).to.equal('button');
+                await entry.loadEditor();
+                (0, chai_1.expect)(load.callCount).to.equal(1);
+                button.click();
+                (0, chai_1.expect)(entry.node.querySelector('.multi-diff-entry-loading')).to.exist;
+                button.click();
+                await entry.loadEditor(true);
+                (0, chai_1.expect)(load.callCount).to.equal(2);
+                resolve(widget);
+                await Promise.resolve();
+                (0, chai_1.expect)(entry.editorWidget).to.equal(widget);
+            }
+            finally {
+                entry.dispose();
+            }
+        });
+        it('should dispose editors completing after disposal without emitting a load event', async () => {
+            let resolve;
+            const entry = createEntry(() => new Promise(r => resolve = r));
+            const loaded = sinon.spy();
+            entry.onDidLoadEditor(loaded);
+            const pending = entry.loadEditor();
+            entry.dispose();
+            const widget = new browser_1.Widget();
+            resolve(widget);
+            await pending;
+            (0, chai_1.expect)(widget.isDisposed).to.be.true;
+            (0, chai_1.expect)(loaded.called).to.be.false;
+        });
+        it('should ignore rejected loads after disposal', async () => {
+            let reject;
+            const entry = createEntry(() => new Promise((_resolve, r) => reject = r));
+            const setError = sinon.spy(entry, 'setError');
+            const pending = entry.loadEditor();
+            entry.dispose();
+            reject(new Error('late failure'));
+            await pending;
+            (0, chai_1.expect)(setError.called).to.be.false;
+        });
+        it('should track both diff content heights as unchanged regions are hidden or expanded and dispose listeners', () => {
+            const originalChanged = new core_1.Emitter();
+            const modifiedChanged = new core_1.Emitter();
+            let originalHeight = 300;
+            let modifiedHeight = 400;
+            const monacoEditor = Object.create(monaco_diff_editor_1.MonacoDiffEditor.prototype);
+            Object.defineProperty(monacoEditor, 'diffEditor', {
+                value: {
+                    updateOptions: sinon.spy(),
+                    getOriginalEditor: () => ({ getContentHeight: () => originalHeight, onDidContentSizeChange: originalChanged.event }),
+                    getModifiedEditor: () => ({ getContentHeight: () => modifiedHeight, onDidContentSizeChange: modifiedChanged.event })
+                }
+            });
+            const widget = new browser_1.Widget();
+            Object.defineProperty(widget, 'editor', { value: monacoEditor });
+            const entry = createEntry(async () => widget);
+            try {
+                entry.setEditor(widget);
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${400 + multi_diff_editor_1.HEADER_HEIGHT}px`);
+                originalHeight = 140;
+                modifiedHeight = 150;
+                modifiedChanged.fire();
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${150 + multi_diff_editor_1.HEADER_HEIGHT}px`);
+                entry.setCollapsed(true);
+                originalHeight = 350;
+                originalChanged.fire();
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${multi_diff_editor_1.HEADER_HEIGHT}px`);
+                entry.setCollapsed(false);
+                (0, chai_1.expect)(entry.node.style.height).to.equal(`${350 + multi_diff_editor_1.HEADER_HEIGHT}px`);
+                entry.dispose();
+                const setHeight = sinon.spy(entry, 'setHeight');
+                originalChanged.fire();
+                modifiedChanged.fire();
+                (0, chai_1.expect)(setHeight.called).to.be.false;
+            }
+            finally {
+                entry.dispose();
+                originalChanged.dispose();
+                modifiedChanged.dispose();
+            }
+        });
+    });
+    describe('content-fit sizing and inner scrolling', () => {
+        for (const isDiff of [false, true]) {
+            it(`should release vertical wheel events at ${isDiff ? 'diff' : 'code'} boundaries without preventing outer scrolling`, () => {
+                const changed = new core_1.Emitter();
+                let scrollTop = 0;
+                let contentHeight = 6000;
+                const control = {
+                    getContentHeight: () => contentHeight,
+                    onDidContentSizeChange: changed.event,
+                    updateOptions: sinon.spy(),
+                    getScrollTop: () => scrollTop,
+                    getScrollHeight: () => 6000,
+                    getLayoutInfo: () => ({ height: 1000 })
+                };
+                const monacoEditor = Object.create(isDiff ? monaco_diff_editor_1.MonacoDiffEditor.prototype : monaco_editor_1.MonacoEditor.prototype);
+                if (isDiff) {
+                    Object.defineProperty(monacoEditor, 'diffEditor', {
+                        value: { getOriginalEditor: () => control, getModifiedEditor: () => control, updateOptions: control.updateOptions }
+                    });
+                }
+                else {
+                    monacoEditor.getControl = () => control;
+                }
+                const widget = new browser_1.Widget();
+                Object.defineProperty(widget, 'editor', { value: monacoEditor });
+                const entry = new multi_diff_editor_1.DiffEntryWidget(sampleResource, new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider));
+                const targets = Array.from({ length: isDiff ? 2 : 1 }, () => {
+                    const node = document.createElement('div');
+                    widget.node.appendChild(node);
+                    node.addEventListener('wheel', event => event.preventDefault());
+                    return node;
+                });
+                const wheel = (target, deltaY, options = {}) => {
+                    const event = new window.WheelEvent('wheel', { deltaY, bubbles: true, cancelable: true, ...options });
+                    target.dispatchEvent(event);
+                    return event.defaultPrevented;
+                };
+                try {
+                    entry.setEditor(widget);
+                    for (const target of targets) {
+                        scrollTop = 0;
+                        (0, chai_1.expect)(wheel(target, -100)).to.be.false;
+                        (0, chai_1.expect)(wheel(target, 100)).to.be.true;
+                        scrollTop = 2500;
+                        (0, chai_1.expect)(wheel(target, -100)).to.be.true;
+                        (0, chai_1.expect)(wheel(target, 100)).to.be.true;
+                        scrollTop = 5000;
+                        (0, chai_1.expect)(wheel(target, 100)).to.be.false;
+                        (0, chai_1.expect)(wheel(target, -100)).to.be.true;
+                        (0, chai_1.expect)(wheel(target, 100, { deltaX: 200 })).to.be.true;
+                        (0, chai_1.expect)(wheel(target, 100, { ctrlKey: true })).to.be.true;
+                        (0, chai_1.expect)(wheel(target, 100, { shiftKey: true })).to.be.true;
+                    }
+                    contentHeight = 20;
+                    changed.fire();
+                    (0, chai_1.expect)(wheel(targets[0], 100)).to.be.true;
+                    entry.dispose();
+                    (0, chai_1.expect)(wheel(targets[0], 100)).to.be.true;
+                }
+                finally {
+                    entry.dispose();
+                    changed.dispose();
+                }
+            });
+            it(`should size ${isDiff ? 'diff' : 'code'} content including borders and toggle scrolling on content changes and resizes`, () => {
+                const changed = new core_1.Emitter();
+                const originalChanged = new core_1.Emitter();
+                let contentHeight = 20;
+                let originalHeight = 10;
+                const updateOptions = sinon.spy((_options) => changed.fire());
+                const control = {
+                    getContentHeight: () => contentHeight,
+                    onDidContentSizeChange: changed.event,
+                    updateOptions
+                };
+                const monacoEditor = Object.create(isDiff ? monaco_diff_editor_1.MonacoDiffEditor.prototype : monaco_editor_1.MonacoEditor.prototype);
+                if (isDiff) {
+                    Object.defineProperty(monacoEditor, 'diffEditor', {
+                        value: {
+                            getOriginalEditor: () => ({ getContentHeight: () => originalHeight, onDidContentSizeChange: originalChanged.event }),
+                            getModifiedEditor: () => control,
+                            updateOptions
+                        }
+                    });
+                }
+                else {
+                    monacoEditor.getControl = () => control;
+                }
+                const widget = new browser_1.Widget();
+                Object.defineProperty(widget, 'editor', { value: monacoEditor });
+                const entry = new multi_diff_editor_1.DiffEntryWidget(sampleResource, new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider));
+                entry.node.style.border = '1px solid black';
+                browser_1.Widget.attach(entry, document.body);
+                const chrome = multi_diff_editor_1.HEADER_HEIGHT + 2;
+                const expectScrolling = (enabled) => (0, chai_1.expect)(updateOptions.lastCall.args[0]).to.deep.equal({
+                    scrollbar: { vertical: enabled ? 'auto' : 'hidden', handleMouseWheel: enabled, alwaysConsumeMouseWheel: false }
+                });
+                try {
+                    entry.setAvailableHeight(250, false);
+                    entry.setEditor(widget);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal(`${20 + chrome}px`);
+                    expectScrolling(false);
+                    (0, chai_1.expect)(updateOptions.callCount).to.equal(1);
+                    changed.fire();
+                    (0, chai_1.expect)(updateOptions.callCount).to.equal(1);
+                    contentHeight = 6000;
+                    changed.fire();
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('5000px');
+                    expectScrolling(true);
+                    (0, chai_1.expect)(updateOptions.callCount).to.equal(2);
+                    entry.setAvailableHeight(600, false);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('5000px');
+                    expectScrolling(true);
+                    (0, chai_1.expect)(updateOptions.callCount).to.equal(2);
+                    contentHeight = 400;
+                    changed.fire();
+                    (0, chai_1.expect)(entry.node.style.height).to.equal(`${400 + chrome}px`);
+                    expectScrolling(false);
+                    entry.setAvailableHeight(200, false);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal(`${400 + chrome}px`);
+                    expectScrolling(false);
+                    contentHeight = 5000 - chrome;
+                    changed.fire();
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('5000px');
+                    expectScrolling(false);
+                    contentHeight++;
+                    changed.fire();
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('5000px');
+                    expectScrolling(true);
+                    entry.setCollapsed(true);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal(`${chrome}px`);
+                    entry.setAvailableHeight(100, false);
+                    contentHeight = 20;
+                    changed.fire();
+                    (0, chai_1.expect)(entry.node.style.height).to.equal(`${chrome}px`);
+                    entry.setCollapsed(false);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal(`${20 + chrome}px`);
+                    expectScrolling(false);
+                    if (isDiff) {
+                        originalHeight = 500;
+                        originalChanged.fire();
+                        (0, chai_1.expect)(entry.node.style.height).to.equal(`${500 + chrome}px`);
+                        expectScrolling(false);
+                        originalHeight = 10;
+                        originalChanged.fire();
+                        (0, chai_1.expect)(entry.node.style.height).to.equal(`${20 + chrome}px`);
+                        expectScrolling(false);
+                    }
+                    entry.setAvailableHeight(500);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('500px');
+                    expectScrolling(false);
+                    contentHeight = 600;
+                    changed.fire();
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('500px');
+                    expectScrolling(true);
+                    entry.setAvailableHeight(700);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('700px');
+                    expectScrolling(false);
+                }
+                finally {
+                    entry.dispose();
+                    changed.dispose();
+                    originalChanged.dispose();
+                }
+            });
+        }
+    });
+    describe('DiffEntryLoadingWidget / DiffEntryErrorWidget', () => {
+        it('should render a spinning codicon loading indicator', () => {
+            const w = new multi_diff_editor_1.DiffEntryLoadingWidget();
+            try {
+                const spinner = w.node.querySelector('.codicon-loading.codicon-modifier-spin');
+                (0, chai_1.expect)(spinner).to.exist;
+            }
+            finally {
+                w.dispose();
+            }
+        });
+        it('should render the error message', () => {
+            const w = new multi_diff_editor_1.DiffEntryErrorWidget('oops');
+            try {
+                (0, chai_1.expect)(w.node.textContent).to.contain('oops');
+                (0, chai_1.expect)(w.node.querySelector('.codicon-error')).to.exist;
+            }
+            finally {
+                w.dispose();
+            }
+        });
+    });
+    describe('MultiDiffEditor', () => {
+        function createEditor(count, load) {
+            const container = new inversify_1.Container();
+            container.bind(multi_diff_editor_1.MultiDiffEditorData).toConstantValue({ title: 'Changes', resources: Array(count).fill(sampleResource) });
+            container.bind(multi_diff_editor_1.MultiDiffEditor).toSelf();
+            const editor = container.get(multi_diff_editor_1.MultiDiffEditor);
+            for (let index = 0; index < count; index++) {
+                editor.addDiffEntry(sampleResource, new multi_diff_editor_1.DiffEntryHeaderWidget(sampleResource, mockLabelProvider), load);
+            }
+            return editor;
+        }
+        it('should opt out of persistence and ignore restore state', () => {
+            const editor = createEditor(1);
+            try {
+                editor.restoreState({ collapsedUris: [sampleResource.modifiedUri.toString()], scrollTop: 123 });
+                (0, chai_1.expect)(editor.entries[0].isCollapsed).to.be.false;
+                (0, chai_1.expect)(editor['entriesPanel'].node.scrollTop).to.equal(0);
+                (0, chai_1.expect)(editor.storeState()).to.be.undefined;
+            }
+            finally {
+                editor.dispose();
+            }
+        });
+        it('should observe near-viewport entries, skip collapsed entries, and disconnect safely', async () => {
+            const previous = globalThis.IntersectionObserver;
+            let callback;
+            const observe = sinon.spy();
+            const disconnect = sinon.spy();
+            let options;
+            globalThis.IntersectionObserver = class {
+                constructor(cb, opts) {
+                    this.observe = observe;
+                    this.disconnect = disconnect;
+                    callback = cb;
+                    options = opts;
+                }
+            };
+            const load = sinon.stub().callsFake(async () => new browser_1.Widget());
+            const editor = createEditor(2, load);
+            const firstLoad = sinon.spy(editor.entries[0], 'loadEditor');
+            const secondLoad = sinon.spy(editor.entries[1], 'loadEditor');
+            try {
+                (0, chai_1.expect)(observe.callCount).to.equal(2);
+                (0, chai_1.expect)(options?.root).to.equal(editor['entriesPanel'].node);
+                (0, chai_1.expect)(options?.rootMargin).to.equal('500px 0px');
+                editor.entries[1].setCollapsed(true);
+                const records = editor.entries.map(entry => ({ target: entry.node, isIntersecting: true }));
+                callback([{ ...records[0], isIntersecting: false }], editor['entryObserver']);
+                (0, chai_1.expect)(firstLoad.called).to.be.false;
+                callback(records, editor['entryObserver']);
+                (0, chai_1.expect)(firstLoad.calledOnce).to.be.true;
+                (0, chai_1.expect)(editor.entries[1].editorWidget).to.be.undefined;
+                (0, chai_1.expect)(load.calledOnce).to.be.true;
+                await Promise.resolve();
+                (0, chai_1.expect)(editor.entries[0].editorWidget).to.exist;
+                editor.entries[1].setCollapsed(false);
+                await Promise.resolve();
+                (0, chai_1.expect)(load.calledTwice).to.be.true;
+                (0, chai_1.expect)(editor.entries[1].editorWidget).to.exist;
+                editor.dispose();
+                (0, chai_1.expect)(disconnect.calledOnce).to.be.true;
+                callback(records, editor['entryObserver']);
+                (0, chai_1.expect)(firstLoad.calledOnce).to.be.true;
+                (0, chai_1.expect)(secondLoad.calledTwice).to.be.true;
+                (0, chai_1.expect)(load.calledTwice).to.be.true;
+            }
+            finally {
+                editor.dispose();
+                globalThis.IntersectionObserver = previous;
+            }
+        });
+        it('should expand and load explicitly revealed entries', () => {
+            const previous = globalThis.requestAnimationFrame;
+            globalThis.requestAnimationFrame = sinon.stub().returns(0);
+            const editor = createEditor(1);
+            const load = sinon.spy(editor.entries[0], 'loadEditor');
+            try {
+                editor.entries[0].setCollapsed(true);
+                editor.revealResource(sampleResource.modifiedUri);
+                (0, chai_1.expect)(editor.entries[0].isCollapsed).to.be.false;
+                (0, chai_1.expect)(load.called).to.be.true;
+            }
+            finally {
+                editor.dispose();
+                globalThis.requestAnimationFrame = previous;
+            }
+        });
+        it('should reveal only within the entries panel and repeat after an in-flight target loads', async () => {
+            const previous = globalThis.requestAnimationFrame;
+            const frames = [];
+            globalThis.requestAnimationFrame = callback => frames.push(callback);
+            let resolve;
+            const editor = createEditor(1, () => new Promise(r => resolve = r));
+            const entry = editor.entries[0];
+            const panel = editor['entriesPanel'].node;
+            const offset = sinon.stub(entry.node, 'offsetTop').get(() => 120);
+            const pending = entry.loadEditor();
+            try {
+                browser_1.Widget.attach(editor, document.body);
+                editor.node.scrollTop = 42;
+                document.body.scrollTop = 17;
+                editor.revealResource(entry.modifiedUri);
+                frames.splice(0).forEach(frame => frame(0));
+                (0, chai_1.expect)(panel.scrollTop).to.equal(120);
+                (0, chai_1.expect)(editor.node.scrollTop).to.equal(42);
+                (0, chai_1.expect)(document.body.scrollTop).to.equal(17);
+                offset.get(() => 480);
+                resolve(new browser_1.Widget());
+                await pending;
+                frames.splice(0).forEach(frame => frame(0));
+                (0, chai_1.expect)(panel.scrollTop).to.equal(480);
+                (0, chai_1.expect)(editor.node.scrollTop).to.equal(42);
+                (0, chai_1.expect)(document.body.scrollTop).to.equal(17);
+            }
+            finally {
+                editor.dispose();
+                offset.restore();
+                document.body.scrollTop = 0;
+                globalThis.requestAnimationFrame = previous;
+            }
+        });
+        it('should ignore stale reveal frames and frames after disposal', () => {
+            const previous = globalThis.requestAnimationFrame;
+            const frames = [];
+            globalThis.requestAnimationFrame = callback => frames.push(callback);
+            const editor = createEditor(1);
+            const otherResource = { ...sampleResource, modifiedUri: new core_1.URI('file:///workspace/c.ts') };
+            const other = editor.addDiffEntry(otherResource, new multi_diff_editor_1.DiffEntryHeaderWidget(otherResource, mockLabelProvider));
+            const panel = editor['entriesPanel'].node;
+            const offset = sinon.stub(other.node, 'offsetTop').get(() => 240);
+            try {
+                browser_1.Widget.attach(editor, document.body);
+                editor.revealResource(sampleResource.modifiedUri);
+                editor.revealResource(otherResource.modifiedUri);
+                frames.shift()(0);
+                (0, chai_1.expect)(panel.scrollTop).to.equal(0);
+                frames.shift()(0);
+                (0, chai_1.expect)(panel.scrollTop).to.equal(240);
+                editor.revealResource(sampleResource.modifiedUri);
+                editor.dispose();
+                frames.splice(0).forEach(frame => frame(0));
+                (0, chai_1.expect)(panel.scrollTop).to.equal(240);
+            }
+            finally {
+                editor.dispose();
+                offset.restore();
+                globalThis.requestAnimationFrame = previous;
+            }
+        });
+        it('should activate a visible editor, remember focused entries, and preserve ancestor scroll positions', () => {
+            const editor = createEditor(2);
+            const panel = editor['entriesPanel'].node;
+            sinon.stub(panel, 'getBoundingClientRect').returns({ top: 0, bottom: 500 });
+            const firstBounds = sinon.stub(editor.entries[0].node, 'getBoundingClientRect').returns({ top: -400, bottom: -100 });
+            sinon.stub(editor.entries[1].node, 'getBoundingClientRect').returns({ top: 100, bottom: 400 });
+            class FocusWidget extends browser_1.Widget {
+                onActivateRequest() {
+                    panel.scrollTop = 0;
+                    editor.node.scrollTop = 0;
+                }
+            }
+            const first = new FocusWidget();
+            const second = new FocusWidget();
+            editor.entries[0].setEditor(first);
+            editor.entries[1].setEditor(second);
+            const firstActivate = sinon.spy(first, 'processMessage');
+            const secondActivate = sinon.spy(second, 'processMessage');
+            try {
+                panel.scrollTop = 350;
+                editor.node.scrollTop = 42;
+                browser_1.MessageLoop.sendMessage(editor, browser_1.Widget.Msg.ActivateRequest);
+                (0, chai_1.expect)(firstActivate.calledWith(browser_1.Widget.Msg.ActivateRequest)).to.be.false;
+                (0, chai_1.expect)(secondActivate.calledWith(browser_1.Widget.Msg.ActivateRequest)).to.be.true;
+                (0, chai_1.expect)(panel.scrollTop).to.equal(350);
+                (0, chai_1.expect)(editor.node.scrollTop).to.equal(42);
+                second.node.dispatchEvent(new window.Event('focusin', { bubbles: true }));
+                firstBounds.returns({ top: 0, bottom: 200 });
+                secondActivate.resetHistory();
+                browser_1.MessageLoop.sendMessage(editor, browser_1.Widget.Msg.ActivateRequest);
+                (0, chai_1.expect)(secondActivate.calledWith(browser_1.Widget.Msg.ActivateRequest)).to.be.true;
+                editor.entries[1].setCollapsed(true);
+                browser_1.MessageLoop.sendMessage(editor, browser_1.Widget.Msg.ActivateRequest);
+                (0, chai_1.expect)(panel.scrollTop).to.equal(350);
+            }
+            finally {
+                sinon.restore();
+                editor.dispose();
+            }
+        });
+        it('should fill the viewport for a single entry and follow resizes', () => {
+            const editor = createEditor(1);
+            try {
+                browser_1.MessageLoop.sendMessage(editor, new browser_1.Widget.ResizeMessage(1000, 800));
+                (0, chai_1.expect)(editor.entries[0].node.style.height).to.equal('800px');
+                browser_1.MessageLoop.sendMessage(editor, new browser_1.Widget.ResizeMessage(1000, 400));
+                (0, chai_1.expect)(editor.entries[0].node.style.height).to.equal('400px');
+            }
+            finally {
+                editor.dispose();
+            }
+        });
+        it('should retain bounded content heights for multiple entries', () => {
+            const editor = createEditor(2);
+            try {
+                browser_1.MessageLoop.sendMessage(editor, new browser_1.Widget.ResizeMessage(1000, 800));
+                for (const entry of editor.entries) {
+                    entry.setHeight(1000);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('1000px');
+                    entry.setHeight(10_000);
+                    (0, chai_1.expect)(entry.node.style.height).to.equal('5000px');
+                }
+                browser_1.MessageLoop.sendMessage(editor, new browser_1.Widget.ResizeMessage(1000, 300));
+                (0, chai_1.expect)(editor.entries[0].node.style.height).to.equal('5000px');
+                editor.entries[1].setHeight(60);
+                (0, chai_1.expect)(editor.entries[1].node.style.height).to.equal('60px');
+            }
+            finally {
+                editor.dispose();
+            }
+        });
+    });
+    describe('MultiDiffEditorWidgetFactory', () => {
+        class TestFactory extends multi_diff_editor_widget_factory_1.MultiDiffEditorWidgetFactory {
+            configure(widget) {
+                this.configureEmbeddedEditor(widget);
+            }
+        }
+        it('should disable visibility side effects and enable unchanged-region hiding only for diff editors', () => {
+            const factory = new TestFactory(new inversify_1.Container(), {}, mockLabelProvider);
+            const diff = Object.create(monaco_diff_editor_1.MonacoDiffEditor.prototype);
+            const updateDiffOptions = sinon.spy();
+            Object.defineProperty(diff, 'diffEditor', { value: { updateOptions: updateDiffOptions } });
+            const code = Object.create(monaco_editor_1.MonacoEditor.prototype);
+            const updateCodeOptions = sinon.spy();
+            code.getControl = () => ({ updateOptions: updateCodeOptions });
+            factory.configure({ editor: diff });
+            factory.configure({ editor: code });
+            for (const editor of [diff, code]) {
+                (0, chai_1.expect)(editor.detachModelOnHide).to.be.false;
+            }
+            (0, chai_1.expect)(updateDiffOptions.firstCall.args[0]).to.deep.equal({
+                folding: false, codeLens: false, scrollBeyondLastLine: false, stickyScroll: { enabled: false }, minimap: { enabled: false }, hideUnchangedRegions: { enabled: true }
+            });
+            (0, chai_1.expect)(updateCodeOptions.firstCall.args[0]).not.to.have.property('hideUnchangedRegions');
+        });
+        it('should return placeholders without loading models, then configure and publish loaded editors', async () => {
+            const widget = new browser_1.Widget();
+            const createByUri = sinon.stub().resolves(widget);
+            const manager = { createByUri };
+            const factory = new multi_diff_editor_widget_factory_1.MultiDiffEditorWidgetFactory(new inversify_1.Container(), manager, mockLabelProvider);
+            const editor = factory.createMultiDiffEditor(multi_diff_editor_uri_1.MultiDiffEditorUri.encode({ title: 'Changes', resources: [sampleResource] }));
+            const changed = sinon.spy();
+            editor.onDidChangeTrackableWidgets(changed);
+            try {
+                (0, chai_1.expect)(createByUri.called).to.be.false;
+                (0, chai_1.expect)(editor.entries[0].node.querySelector('.multi-diff-entry-loading')).to.exist;
+                await editor.entries[0].loadEditor();
+                (0, chai_1.expect)(createByUri.calledOnce).to.be.true;
+                (0, chai_1.expect)(editor.getTrackableWidgets()).to.deep.equal([widget]);
+                (0, chai_1.expect)(changed.calledOnce).to.be.true;
+            }
+            finally {
+                editor.dispose();
+            }
+        });
+    });
+    describe('MultiDiffEditorLabelProvider', () => {
+        it('should label synthetic URIs with the full editor title', () => {
+            const provider = new multi_diff_editor_1.MultiDiffEditorLabelProvider();
+            const uri = multi_diff_editor_uri_1.MultiDiffEditorUri.encode({ title: 'Changes in feature/test', resources: [] });
+            (0, chai_1.expect)(provider.canHandle(uri)).to.equal(20);
+            (0, chai_1.expect)(provider.canHandle(new core_1.URI('file:///a.ts'))).to.equal(0);
+            (0, chai_1.expect)(provider.getName(uri)).to.equal('Changes in feature/test');
+            (0, chai_1.expect)(provider.getLongName(uri)).to.equal('Changes in feature/test');
+            (0, chai_1.expect)(provider.getIcon()).to.equal('codicon codicon-diff-multiple');
+        });
+    });
+    describe('MultiDiffEditorOpenHandler', () => {
+        // canHandle can be exercised without DI, since it's a pure function of the URI.
+        const handler = Object.create(multi_diff_editor_1.MultiDiffEditorOpenHandler.prototype);
+        it('should return 1000 for multi-diff-editor URIs', () => {
+            const uri = multi_diff_editor_uri_1.MultiDiffEditorUri.encode({ title: 'x', resources: [] });
+            (0, chai_1.expect)(handler.canHandle(uri)).to.equal(1000);
+        });
+        it('should return 0 for other URIs', () => {
+            (0, chai_1.expect)(handler.canHandle(new core_1.URI('file:///a.ts'))).to.equal(0);
+            (0, chai_1.expect)(handler.canHandle(new core_1.URI('diff://a/b'))).to.equal(0);
+        });
+    });
+});
+//# sourceMappingURL=multi-diff-editor-widget.spec.js.map