@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/browser/widget/diffEditor/overviewRulerPart.js

@@ -0,0 +1,141 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { h, addStandardDisposableListener, addDisposableListener, EventType } from '../../../../base/browser/dom.js';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { ScrollbarState } from '../../../../base/browser/ui/scrollbar/scrollbarState.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { appendRemoveOnDispose } from './utils.js';
+import { Position } from '../../../common/core/position.js';
+import { OverviewRulerZone } from '../../../common/viewModel/overviewZoneManager.js';
+import { diffOverviewRulerInserted, diffInserted, defaultInsertColor, diffOverviewRulerRemoved, diffRemoved, defaultRemoveColor } from '../../../../platform/theme/common/colorRegistry.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { derived } from '../../../../base/common/observableInternal/derived.js';
+import { autorunWithStore, autorun } from '../../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent, observableSignalFromEvent } from '../../../../base/common/observableInternal/utils.js';
+var OverviewRulerPart_1;
+let OverviewRulerPart = class OverviewRulerPart extends Disposable {
+    static { OverviewRulerPart_1 = this; }
+    static { this.ONE_OVERVIEW_WIDTH = 15; }
+    static { this.ENTIRE_DIFF_OVERVIEW_WIDTH = OverviewRulerPart_1.ONE_OVERVIEW_WIDTH * 2; }
+    constructor(_editors, _rootElement, _diffModel, _rootWidth, _rootHeight, _modifiedEditorLayoutInfo, _themeService) {
+        super();
+        this._editors = _editors;
+        this._rootElement = _rootElement;
+        this._diffModel = _diffModel;
+        this._rootWidth = _rootWidth;
+        this._rootHeight = _rootHeight;
+        this._modifiedEditorLayoutInfo = _modifiedEditorLayoutInfo;
+        this._themeService = _themeService;
+        this.width = OverviewRulerPart_1.ENTIRE_DIFF_OVERVIEW_WIDTH;
+        const currentColorTheme = observableFromEvent(this._themeService.onDidColorThemeChange, () => this._themeService.getColorTheme());
+        const currentColors = derived(reader => {
+            const theme = currentColorTheme.read(reader);
+            const insertColor = theme.getColor(diffOverviewRulerInserted) || ( (theme.getColor(diffInserted) || defaultInsertColor).transparent(2));
+            const removeColor = theme.getColor(diffOverviewRulerRemoved) || ( (theme.getColor(diffRemoved) || defaultRemoveColor).transparent(2));
+            return { insertColor, removeColor };
+        });
+        const viewportDomElement = createFastDomNode(document.createElement('div'));
+        viewportDomElement.setClassName('diffViewport');
+        viewportDomElement.setPosition('absolute');
+        const diffOverviewRoot = h('div.diffOverview', {
+            style: { position: 'absolute', top: '0px', width: OverviewRulerPart_1.ENTIRE_DIFF_OVERVIEW_WIDTH + 'px' }
+        }).root;
+        this._register(appendRemoveOnDispose(diffOverviewRoot, viewportDomElement.domNode));
+        this._register(addStandardDisposableListener(diffOverviewRoot, EventType.POINTER_DOWN, (e) => {
+            this._editors.modified.delegateVerticalScrollbarPointerDown(e);
+        }));
+        this._register(addDisposableListener(diffOverviewRoot, EventType.MOUSE_WHEEL, (e) => {
+            this._editors.modified.delegateScrollFromMouseWheelEvent(e);
+        }, { passive: false }));
+        this._register(appendRemoveOnDispose(this._rootElement, diffOverviewRoot));
+        this._register(autorunWithStore((reader, store) => {
+            const m = this._diffModel.read(reader);
+            const originalOverviewRuler = this._editors.original.createOverviewRuler('original diffOverviewRuler');
+            if (originalOverviewRuler) {
+                store.add(originalOverviewRuler);
+                store.add(appendRemoveOnDispose(diffOverviewRoot, originalOverviewRuler.getDomNode()));
+            }
+            const modifiedOverviewRuler = this._editors.modified.createOverviewRuler('modified diffOverviewRuler');
+            if (modifiedOverviewRuler) {
+                store.add(modifiedOverviewRuler);
+                store.add(appendRemoveOnDispose(diffOverviewRoot, modifiedOverviewRuler.getDomNode()));
+            }
+            if (!originalOverviewRuler || !modifiedOverviewRuler) {
+                return;
+            }
+            const origViewZonesChanged = observableSignalFromEvent('viewZoneChanged', this._editors.original.onDidChangeViewZones);
+            const modViewZonesChanged = observableSignalFromEvent('viewZoneChanged', this._editors.modified.onDidChangeViewZones);
+            const origHiddenRangesChanged = observableSignalFromEvent('hiddenRangesChanged', this._editors.original.onDidChangeHiddenAreas);
+            const modHiddenRangesChanged = observableSignalFromEvent('hiddenRangesChanged', this._editors.modified.onDidChangeHiddenAreas);
+            store.add(autorun(reader => {
+                origViewZonesChanged.read(reader);
+                modViewZonesChanged.read(reader);
+                origHiddenRangesChanged.read(reader);
+                modHiddenRangesChanged.read(reader);
+                const colors = currentColors.read(reader);
+                const diff = m?.diff.read(reader)?.mappings;
+                function createZones(ranges, color, editor) {
+                    const vm = editor._getViewModel();
+                    if (!vm) {
+                        return [];
+                    }
+                    return ( ranges
+                        .filter(d => d.length > 0)
+                        .map(r => {
+                        const start = vm.coordinatesConverter.convertModelPositionToViewPosition(( new Position(r.startLineNumber, 1)));
+                        const end = vm.coordinatesConverter.convertModelPositionToViewPosition(( new Position(r.endLineNumberExclusive, 1)));
+                        const lineCount = end.lineNumber - start.lineNumber;
+                        return ( new OverviewRulerZone(start.lineNumber, end.lineNumber, lineCount, ( color.toString())));
+                    }));
+                }
+                const originalZones = createZones(( (diff || []).map(d => d.lineRangeMapping.original)), colors.removeColor, this._editors.original);
+                const modifiedZones = createZones(( (diff || []).map(d => d.lineRangeMapping.modified)), colors.insertColor, this._editors.modified);
+                originalOverviewRuler?.setZones(originalZones);
+                modifiedOverviewRuler?.setZones(modifiedZones);
+            }));
+            store.add(autorun(reader => {
+                const height = this._rootHeight.read(reader);
+                const width = this._rootWidth.read(reader);
+                const layoutInfo = this._modifiedEditorLayoutInfo.read(reader);
+                if (layoutInfo) {
+                    const freeSpace = OverviewRulerPart_1.ENTIRE_DIFF_OVERVIEW_WIDTH - 2 * OverviewRulerPart_1.ONE_OVERVIEW_WIDTH;
+                    originalOverviewRuler.setLayout({
+                        top: 0,
+                        height: height,
+                        right: freeSpace + OverviewRulerPart_1.ONE_OVERVIEW_WIDTH,
+                        width: OverviewRulerPart_1.ONE_OVERVIEW_WIDTH,
+                    });
+                    modifiedOverviewRuler.setLayout({
+                        top: 0,
+                        height: height,
+                        right: 0,
+                        width: OverviewRulerPart_1.ONE_OVERVIEW_WIDTH,
+                    });
+                    const scrollTop = this._editors.modifiedScrollTop.read(reader);
+                    const scrollHeight = this._editors.modifiedScrollHeight.read(reader);
+                    const scrollBarOptions = this._editors.modified.getOption(102 );
+                    const state = ( new ScrollbarState(
+                        scrollBarOptions.verticalHasArrows ? scrollBarOptions.arrowSize : 0,
+                        scrollBarOptions.verticalScrollbarSize,
+                        0,
+                        layoutInfo.height,
+                        scrollHeight,
+                        scrollTop
+                    ));
+                    viewportDomElement.setTop(state.getSliderPosition());
+                    viewportDomElement.setHeight(state.getSliderSize());
+                }
+                else {
+                    viewportDomElement.setTop(0);
+                    viewportDomElement.setHeight(0);
+                }
+                diffOverviewRoot.style.height = height + 'px';
+                diffOverviewRoot.style.left = (width - OverviewRulerPart_1.ENTIRE_DIFF_OVERVIEW_WIDTH) + 'px';
+                viewportDomElement.setWidth(OverviewRulerPart_1.ENTIRE_DIFF_OVERVIEW_WIDTH);
+            }));
+        }));
+    }
+};
+OverviewRulerPart = OverviewRulerPart_1 = ( __decorate([
+    ( __param(6, IThemeService))
+], OverviewRulerPart));
+export { OverviewRulerPart };

package/vscode/src/vs/editor/browser/widget/diffEditor/renderLines.js

@@ -0,0 +1,124 @@
+import { createTrustedTypesPolicy } from '../../../../base/browser/trustedTypes.js';
+import { applyFontInfo } from '../../config/domFontInfo.js';
+import { EditorFontLigatures } from '../../../common/config/editorOptions.js';
+import { StringBuilder } from '../../../common/core/stringBuilder.js';
+import { LineDecoration } from '../../../common/viewLayout/lineDecorations.js';
+import { renderViewLine, RenderLineInput } from '../../../common/viewLayout/viewLineRenderer.js';
+import { ViewLineRenderingData } from '../../../common/viewModel.js';
+const ttPolicy = createTrustedTypesPolicy('diffEditorWidget', { createHTML: value => value });
+function renderLines(source, options, decorations, domNode) {
+    applyFontInfo(domNode, options.fontInfo);
+    const hasCharChanges = (decorations.length > 0);
+    const sb = ( new StringBuilder(10000));
+    let maxCharsPerLine = 0;
+    let renderedLineCount = 0;
+    const viewLineCounts = [];
+    for (let lineIndex = 0; lineIndex < source.lineTokens.length; lineIndex++) {
+        const lineNumber = lineIndex + 1;
+        const lineTokens = source.lineTokens[lineIndex];
+        const lineBreakData = source.lineBreakData[lineIndex];
+        const actualDecorations = LineDecoration.filter(decorations, lineNumber, 1, Number.MAX_SAFE_INTEGER);
+        if (lineBreakData) {
+            let lastBreakOffset = 0;
+            for (const breakOffset of lineBreakData.breakOffsets) {
+                const viewLineTokens = lineTokens.sliceAndInflate(lastBreakOffset, breakOffset, 0);
+                maxCharsPerLine = Math.max(maxCharsPerLine, renderOriginalLine(renderedLineCount, viewLineTokens, LineDecoration.extractWrapped(actualDecorations, lastBreakOffset, breakOffset), hasCharChanges, source.mightContainNonBasicASCII, source.mightContainRTL, options, sb));
+                renderedLineCount++;
+                lastBreakOffset = breakOffset;
+            }
+            viewLineCounts.push(lineBreakData.breakOffsets.length);
+        }
+        else {
+            viewLineCounts.push(1);
+            maxCharsPerLine = Math.max(maxCharsPerLine, renderOriginalLine(renderedLineCount, lineTokens, actualDecorations, hasCharChanges, source.mightContainNonBasicASCII, source.mightContainRTL, options, sb));
+            renderedLineCount++;
+        }
+    }
+    maxCharsPerLine += options.scrollBeyondLastColumn;
+    const html = sb.build();
+    const trustedhtml = ttPolicy ? ttPolicy.createHTML(html) : html;
+    domNode.innerHTML = trustedhtml;
+    const minWidthInPx = (maxCharsPerLine * options.typicalHalfwidthCharacterWidth);
+    return {
+        heightInLines: renderedLineCount,
+        minWidthInPx,
+        viewLineCounts,
+    };
+}
+class LineSource {
+    constructor(lineTokens, lineBreakData, mightContainNonBasicASCII, mightContainRTL) {
+        this.lineTokens = lineTokens;
+        this.lineBreakData = lineBreakData;
+        this.mightContainNonBasicASCII = mightContainNonBasicASCII;
+        this.mightContainRTL = mightContainRTL;
+    }
+}
+class RenderOptions {
+    static fromEditor(editor) {
+        const modifiedEditorOptions = editor.getOptions();
+        const fontInfo = modifiedEditorOptions.get(50 );
+        const layoutInfo = modifiedEditorOptions.get(143 );
+        return ( new RenderOptions(
+            editor.getModel()?.getOptions().tabSize || 0,
+            fontInfo,
+            modifiedEditorOptions.get(33 ),
+            fontInfo.typicalHalfwidthCharacterWidth,
+            modifiedEditorOptions.get(103 ),
+            modifiedEditorOptions.get(66 ),
+            layoutInfo.decorationsWidth,
+            modifiedEditorOptions.get(116 ),
+            modifiedEditorOptions.get(98 ),
+            modifiedEditorOptions.get(93 ),
+            modifiedEditorOptions.get(51 )
+        ));
+    }
+    constructor(tabSize, fontInfo, disableMonospaceOptimizations, typicalHalfwidthCharacterWidth, scrollBeyondLastColumn, lineHeight, lineDecorationsWidth, stopRenderingLineAfter, renderWhitespace, renderControlCharacters, fontLigatures) {
+        this.tabSize = tabSize;
+        this.fontInfo = fontInfo;
+        this.disableMonospaceOptimizations = disableMonospaceOptimizations;
+        this.typicalHalfwidthCharacterWidth = typicalHalfwidthCharacterWidth;
+        this.scrollBeyondLastColumn = scrollBeyondLastColumn;
+        this.lineHeight = lineHeight;
+        this.lineDecorationsWidth = lineDecorationsWidth;
+        this.stopRenderingLineAfter = stopRenderingLineAfter;
+        this.renderWhitespace = renderWhitespace;
+        this.renderControlCharacters = renderControlCharacters;
+        this.fontLigatures = fontLigatures;
+    }
+}
+function renderOriginalLine(viewLineIdx, lineTokens, decorations, hasCharChanges, mightContainNonBasicASCII, mightContainRTL, options, sb) {
+    sb.appendString('<div class="view-line');
+    if (!hasCharChanges) {
+        sb.appendString(' char-delete');
+    }
+    sb.appendString('" style="top:');
+    sb.appendString(String(viewLineIdx * options.lineHeight));
+    sb.appendString('px;width:1000000px;">');
+    const lineContent = lineTokens.getLineContent();
+    const isBasicASCII = ViewLineRenderingData.isBasicASCII(lineContent, mightContainNonBasicASCII);
+    const containsRTL = ViewLineRenderingData.containsRTL(lineContent, isBasicASCII, mightContainRTL);
+    const output = renderViewLine(( new RenderLineInput(
+        (options.fontInfo.isMonospace && !options.disableMonospaceOptimizations),
+        options.fontInfo.canUseHalfwidthRightwardsArrow,
+        lineContent,
+        false,
+        isBasicASCII,
+        containsRTL,
+        0,
+        lineTokens,
+        decorations,
+        options.tabSize,
+        0,
+        options.fontInfo.spaceWidth,
+        options.fontInfo.middotWidth,
+        options.fontInfo.wsmiddotWidth,
+        options.stopRenderingLineAfter,
+        options.renderWhitespace,
+        options.renderControlCharacters,
+        options.fontLigatures !== EditorFontLigatures.OFF,
+        null
+    )), sb);
+    sb.appendString('</div>');
+    return output.characterMapping.getHorizontalOffset(output.characterMapping.length);
+}
+export { LineSource, RenderOptions, renderLines };

package/vscode/src/vs/editor/browser/widget/diffEditor/style.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .diff-hidden-lines-widget{width:100%}.monaco-editor .diff-hidden-lines{font-size:13px;height:0;line-height:14px;transform:translateY(-10px)}.monaco-editor .diff-hidden-lines .bottom.dragging,.monaco-editor .diff-hidden-lines .top.dragging,.monaco-editor .diff-hidden-lines:not(.dragging) .bottom:hover,.monaco-editor .diff-hidden-lines:not(.dragging) .top:hover{background-color:var(--vscode-focusBorder)}.monaco-editor .diff-hidden-lines .bottom,.monaco-editor .diff-hidden-lines .top{background-clip:padding-box;background-color:transparent;border-bottom:2px solid transparent;border-top:4px solid transparent;height:4px;transition:background-color .1s ease-out}.monaco-editor .diff-hidden-lines .bottom.canMoveTop:not(.canMoveBottom),.monaco-editor .diff-hidden-lines .top.canMoveTop:not(.canMoveBottom),.monaco-editor.draggingUnchangedRegion.canMoveTop:not(.canMoveBottom) *{cursor:n-resize!important}.monaco-editor .diff-hidden-lines .bottom:not(.canMoveTop).canMoveBottom,.monaco-editor .diff-hidden-lines .top:not(.canMoveTop).canMoveBottom,.monaco-editor.draggingUnchangedRegion:not(.canMoveTop).canMoveBottom *{cursor:s-resize!important}.monaco-editor .diff-hidden-lines .bottom.canMoveTop.canMoveBottom,.monaco-editor .diff-hidden-lines .top.canMoveTop.canMoveBottom,.monaco-editor.draggingUnchangedRegion.canMoveTop.canMoveBottom *{cursor:ns-resize!important}.monaco-editor .diff-hidden-lines .top{transform:translateY(4px)}.monaco-editor .diff-hidden-lines .bottom{transform:translateY(-6px)}.monaco-editor .diff-unchanged-lines{background:var(--vscode-diffEditor-unchangedCodeBackground)}.monaco-editor .noModificationsOverlay{align-items:center;background:var(--vscode-editor-background);display:flex;justify-content:center;z-index:1}.monaco-editor .diff-hidden-lines .center{background:var(--vscode-diffEditor-unchangedRegionBackground);box-shadow:inset 0 -5px 5px -7px var(--vscode-diffEditor-unchangedRegionShadow),inset 0 5px 5px -7px var(--vscode-diffEditor-unchangedRegionShadow);color:var(--vscode-diffEditor-unchangedRegionForeground);display:block;height:24px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.monaco-editor .diff-hidden-lines .center span.codicon{vertical-align:middle}.monaco-editor .diff-hidden-lines .center a:hover .codicon{color:var(--vscode-editorLink-activeForeground)!important;cursor:pointer}.monaco-editor .diff-hidden-lines div.breadcrumb-item{cursor:pointer}.monaco-editor .diff-hidden-lines div.breadcrumb-item:hover{color:var(--vscode-editorLink-activeForeground)}.monaco-editor .movedModified,.monaco-editor .movedOriginal{border:2px solid var(--vscode-diffEditor-move-border)}.monaco-editor .movedModified.currentMove,.monaco-editor .movedOriginal.currentMove{border:2px solid var(--vscode-diffEditor-moveActive-border)}.monaco-diff-editor .moved-blocks-lines path.currentMove{stroke:var(--vscode-diffEditor-moveActive-border)}.monaco-diff-editor .moved-blocks-lines path{pointer-events:visiblestroke}.monaco-diff-editor .moved-blocks-lines .arrow{fill:var(--vscode-diffEditor-move-border)}.monaco-diff-editor .moved-blocks-lines .arrow.currentMove{fill:var(--vscode-diffEditor-moveActive-border)}.monaco-diff-editor .moved-blocks-lines .arrow-rectangle{fill:var(--vscode-editor-background)}.monaco-diff-editor .moved-blocks-lines{pointer-events:none;position:absolute}.monaco-diff-editor .moved-blocks-lines path{fill:none;stroke:var(--vscode-diffEditor-move-border);stroke-width:2}.monaco-editor .char-delete.diff-range-empty{border-left:3px solid var(--vscode-diffEditor-removedTextBackground);margin-left:-1px}.monaco-editor .char-insert.diff-range-empty{border-left:3px solid var(--vscode-diffEditor-insertedTextBackground)}.monaco-editor .fold-unchanged{cursor:pointer}.monaco-diff-editor .diff-moved-code-block{display:flex;justify-content:flex-end;margin-top:-4px}.monaco-diff-editor .diff-moved-code-block .action-bar .action-label.codicon{font-size:12px;height:12px;width:12px}.monaco-diff-editor .diffOverview{z-index:9}.monaco-diff-editor .diffOverview .diffViewport{z-index:10}.monaco-diff-editor.vs\t\t\t.diffOverview{background:rgba(0,0,0,.03)}.monaco-diff-editor.vs-dark\t\t.diffOverview{background:hsla(0,0%,100%,.01)}.monaco-scrollable-element.modified-in-monaco-diff-editor.vs\t\t.scrollbar,.monaco-scrollable-element.modified-in-monaco-diff-editor.vs-dark\t.scrollbar{background:transparent}.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-black\t.scrollbar,.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-light\t.scrollbar{background:none}.monaco-scrollable-element.modified-in-monaco-diff-editor .slider{z-index:10}.modified-in-monaco-diff-editor\t\t\t\t.slider.active{background:hsla(0,0%,67%,.4)}.modified-in-monaco-diff-editor.hc-black\t.slider.active,.modified-in-monaco-diff-editor.hc-light\t.slider.active{background:none}.monaco-diff-editor .delete-sign,.monaco-diff-editor .insert-sign,.monaco-editor .delete-sign,.monaco-editor .insert-sign{align-items:center;display:flex!important;font-size:11px!important;opacity:.7!important}.monaco-diff-editor.hc-black .delete-sign,.monaco-diff-editor.hc-black .insert-sign,.monaco-diff-editor.hc-light .delete-sign,.monaco-diff-editor.hc-light .insert-sign,.monaco-editor.hc-black .delete-sign,.monaco-editor.hc-black .insert-sign,.monaco-editor.hc-light .delete-sign,.monaco-editor.hc-light .insert-sign{opacity:1}.monaco-editor .inline-added-margin-view-zone,.monaco-editor .inline-deleted-margin-view-zone{text-align:right}.monaco-editor .arrow-revert-change{position:absolute;z-index:10}.monaco-editor .arrow-revert-change:hover{cursor:pointer}.monaco-editor .view-zones .view-lines .view-line span{display:inline-block}.monaco-editor .margin-view-zones .lightbulb-glyph:hover{cursor:pointer}.monaco-diff-editor .char-insert,.monaco-editor .char-insert{background-color:var(--vscode-diffEditor-insertedTextBackground)}.monaco-diff-editor .line-insert,.monaco-editor .line-insert{background-color:var(--vscode-diffEditor-insertedLineBackground,var(--vscode-diffEditor-insertedTextBackground))}.monaco-editor .char-insert,.monaco-editor .line-insert{border:1px solid var(--vscode-diffEditor-insertedTextBorder);box-sizing:border-box}.monaco-editor.hc-black .char-insert,.monaco-editor.hc-black .line-insert,.monaco-editor.hc-light .char-insert,.monaco-editor.hc-light .line-insert{border-style:dashed}.monaco-editor .char-delete,.monaco-editor .line-delete{border:1px solid var(--vscode-diffEditor-removedTextBorder);box-sizing:border-box}.monaco-editor.hc-black .char-delete,.monaco-editor.hc-black .line-delete,.monaco-editor.hc-light .char-delete,.monaco-editor.hc-light .line-delete{border-style:dashed}.monaco-diff-editor .gutter-insert,.monaco-editor .gutter-insert,.monaco-editor .inline-added-margin-view-zone{background-color:var(--vscode-diffEditorGutter-insertedLineBackground,var(--vscode-diffEditor-insertedLineBackground),var(--vscode-diffEditor-insertedTextBackground))}.monaco-diff-editor .char-delete,.monaco-editor .char-delete{background-color:var(--vscode-diffEditor-removedTextBackground)}.monaco-diff-editor .line-delete,.monaco-editor .line-delete{background-color:var(--vscode-diffEditor-removedLineBackground,var(--vscode-diffEditor-removedTextBackground))}.monaco-diff-editor .gutter-delete,.monaco-editor .gutter-delete,.monaco-editor .inline-deleted-margin-view-zone{background-color:var(--vscode-diffEditorGutter-removedLineBackground,var(--vscode-diffEditor-removedLineBackground),var(--vscode-diffEditor-removedTextBackground))}.monaco-diff-editor.side-by-side .editor.modified{border-left:1px solid var(--vscode-diffEditor-border);box-shadow:-6px 0 5px -5px var(--vscode-scrollbar-shadow)}.monaco-diff-editor .diffViewport{background:var(--vscode-scrollbarSlider-background)}.monaco-diff-editor .diffViewport:hover{background:var(--vscode-scrollbarSlider-hoverBackground)}.monaco-diff-editor .diffViewport:active{background:var(--vscode-scrollbarSlider-activeBackground)}.monaco-editor .diagonal-fill{background-image:linear-gradient(-45deg,var(--vscode-diffEditor-diagonalFill) 12.5%,#0000 12.5%,#0000 50%,var(--vscode-diffEditor-diagonalFill) 50%,var(--vscode-diffEditor-diagonalFill) 62.5%,#0000 62.5%,#0000 100%);background-size:8px 8px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/editor/browser/widget/diffEditor/utils.js

@@ -0,0 +1,343 @@
+import { findLast } from '../../../../base/common/arraysFind.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { isHotReloadEnabled, registerHotReloadHandler } from '../../../../base/common/hotReload.js';
+import { toDisposable, Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { ElementSizeObserver } from '../../config/elementSizeObserver.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { LengthObj } from '../../../common/model/bracketPairsTextModelPart/bracketPairsTree/length.js';
+import { observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
+import { autorun, autorunWithStore, autorunOpts, autorunHandleChanges } from '../../../../base/common/observableInternal/autorun.js';
+import { observableSignalFromEvent } from '../../../../base/common/observableInternal/utils.js';
+function joinCombine(arr1, arr2, keySelector, combine) {
+    if (arr1.length === 0) {
+        return arr2;
+    }
+    if (arr2.length === 0) {
+        return arr1;
+    }
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < arr1.length && j < arr2.length) {
+        const val1 = arr1[i];
+        const val2 = arr2[j];
+        const key1 = keySelector(val1);
+        const key2 = keySelector(val2);
+        if (key1 < key2) {
+            result.push(val1);
+            i++;
+        }
+        else if (key1 > key2) {
+            result.push(val2);
+            j++;
+        }
+        else {
+            result.push(combine(val1, val2));
+            i++;
+            j++;
+        }
+    }
+    while (i < arr1.length) {
+        result.push(arr1[i]);
+        i++;
+    }
+    while (j < arr2.length) {
+        result.push(arr2[j]);
+        j++;
+    }
+    return result;
+}
+function applyObservableDecorations(editor, decorations) {
+    const d = ( new DisposableStore());
+    const decorationsCollection = editor.createDecorationsCollection();
+    d.add(autorunOpts({ debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
+        const d = decorations.read(reader);
+        decorationsCollection.set(d);
+    }));
+    d.add({
+        dispose: () => {
+            decorationsCollection.clear();
+        }
+    });
+    return d;
+}
+function appendRemoveOnDispose(parent, child) {
+    parent.appendChild(child);
+    return toDisposable(() => {
+        parent.removeChild(child);
+    });
+}
+class ObservableElementSizeObserver extends Disposable {
+    get width() { return this._width; }
+    get height() { return this._height; }
+    constructor(element, dimension) {
+        super();
+        this.elementSizeObserver = this._register(( new ElementSizeObserver(element, dimension)));
+        this._width = observableValue(this, this.elementSizeObserver.getWidth());
+        this._height = observableValue(this, this.elementSizeObserver.getHeight());
+        this._register(this.elementSizeObserver.onDidChange(e => transaction(tx => {
+            this._width.set(this.elementSizeObserver.getWidth(), tx);
+            this._height.set(this.elementSizeObserver.getHeight(), tx);
+        })));
+    }
+    observe(dimension) {
+        this.elementSizeObserver.observe(dimension);
+    }
+    setAutomaticLayout(automaticLayout) {
+        if (automaticLayout) {
+            this.elementSizeObserver.startObserving();
+        }
+        else {
+            this.elementSizeObserver.stopObserving();
+        }
+    }
+}
+function animatedObservable(targetWindow, base, store) {
+    let targetVal = base.get();
+    let startVal = targetVal;
+    let curVal = targetVal;
+    const result = observableValue('animatedValue', targetVal);
+    let animationStartMs = -1;
+    const durationMs = 300;
+    let animationFrame = undefined;
+    store.add(autorunHandleChanges({
+        createEmptyChangeSummary: () => ({ animate: false }),
+        handleChange: (ctx, s) => {
+            if (ctx.didChange(base)) {
+                s.animate = s.animate || ctx.change;
+            }
+            return true;
+        }
+    }, (reader, s) => {
+        if (animationFrame !== undefined) {
+            targetWindow.cancelAnimationFrame(animationFrame);
+            animationFrame = undefined;
+        }
+        startVal = curVal;
+        targetVal = base.read(reader);
+        animationStartMs = Date.now() - (s.animate ? 0 : durationMs);
+        update();
+    }));
+    function update() {
+        const passedMs = Date.now() - animationStartMs;
+        curVal = Math.floor(easeOutExpo(passedMs, startVal, targetVal - startVal, durationMs));
+        if (passedMs < durationMs) {
+            animationFrame = targetWindow.requestAnimationFrame(update);
+        }
+        else {
+            curVal = targetVal;
+        }
+        result.set(curVal, undefined);
+    }
+    return result;
+}
+function easeOutExpo(t, b, c, d) {
+    return t === d ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
+}
+class ViewZoneOverlayWidget extends Disposable {
+    constructor(editor, viewZone, htmlElement) {
+        super();
+        this._register(( new ManagedOverlayWidget(editor, htmlElement)));
+        this._register(applyStyle(htmlElement, {
+            height: viewZone.actualHeight,
+            top: viewZone.actualTop,
+        }));
+    }
+}
+class PlaceholderViewZone {
+    get afterLineNumber() { return this._afterLineNumber.get(); }
+    constructor(_afterLineNumber, heightInPx) {
+        this._afterLineNumber = _afterLineNumber;
+        this.heightInPx = heightInPx;
+        this.domNode = document.createElement('div');
+        this._actualTop = observableValue(this, undefined);
+        this._actualHeight = observableValue(this, undefined);
+        this.actualTop = this._actualTop;
+        this.actualHeight = this._actualHeight;
+        this.showInHiddenAreas = true;
+        this.onChange = this._afterLineNumber;
+        this.onDomNodeTop = (top) => {
+            this._actualTop.set(top, undefined);
+        };
+        this.onComputedHeight = (height) => {
+            this._actualHeight.set(height, undefined);
+        };
+    }
+}
+class ManagedOverlayWidget {
+    static { this._counter = 0; }
+    constructor(_editor, _domElement) {
+        this._editor = _editor;
+        this._domElement = _domElement;
+        this._overlayWidgetId = `managedOverlayWidget-${ManagedOverlayWidget._counter++}`;
+        this._overlayWidget = {
+            getId: () => this._overlayWidgetId,
+            getDomNode: () => this._domElement,
+            getPosition: () => null
+        };
+        this._editor.addOverlayWidget(this._overlayWidget);
+    }
+    dispose() {
+        this._editor.removeOverlayWidget(this._overlayWidget);
+    }
+}
+function applyStyle(domNode, style) {
+    return autorun(reader => {
+        for (let [key, val] of Object.entries(style)) {
+            if (val && typeof val === 'object' && 'read' in val) {
+                val = val.read(reader);
+            }
+            if (typeof val === 'number') {
+                val = `${val}px`;
+            }
+            key = key.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+            domNode.style[key] = val;
+        }
+    });
+}
+function readHotReloadableExport(value, reader) {
+    observeHotReloadableExports([value], reader);
+    return value;
+}
+function observeHotReloadableExports(values, reader) {
+    if (isHotReloadEnabled()) {
+        const o = observableSignalFromEvent('reload', event => registerHotReloadHandler(({ oldExports }) => {
+            if (!( [...( Object.values(oldExports))].some(v => values.includes(v)))) {
+                return undefined;
+            }
+            return (_newExports) => {
+                event(undefined);
+                return true;
+            };
+        }));
+        o.read(reader);
+    }
+}
+function applyViewZones(editor, viewZones, setIsUpdating, zoneIds) {
+    const store = ( new DisposableStore());
+    const lastViewZoneIds = [];
+    store.add(autorunWithStore((reader, store) => {
+        const curViewZones = viewZones.read(reader);
+        const viewZonIdsPerViewZone = ( new Map());
+        const viewZoneIdPerOnChangeObservable = ( new Map());
+        if (setIsUpdating) {
+            setIsUpdating(true);
+        }
+        editor.changeViewZones(a => {
+            for (const id of lastViewZoneIds) {
+                a.removeZone(id);
+                zoneIds?.delete(id);
+            }
+            lastViewZoneIds.length = 0;
+            for (const z of curViewZones) {
+                const id = a.addZone(z);
+                if (z.setZoneId) {
+                    z.setZoneId(id);
+                }
+                lastViewZoneIds.push(id);
+                zoneIds?.add(id);
+                viewZonIdsPerViewZone.set(z, id);
+            }
+        });
+        if (setIsUpdating) {
+            setIsUpdating(false);
+        }
+        store.add(autorunHandleChanges({
+            createEmptyChangeSummary() {
+                return { zoneIds: [] };
+            },
+            handleChange(context, changeSummary) {
+                const id = viewZoneIdPerOnChangeObservable.get(context.changedObservable);
+                if (id !== undefined) {
+                    changeSummary.zoneIds.push(id);
+                }
+                return true;
+            },
+        }, (reader, changeSummary) => {
+            for (const vz of curViewZones) {
+                if (vz.onChange) {
+                    viewZoneIdPerOnChangeObservable.set(vz.onChange, viewZonIdsPerViewZone.get(vz));
+                    vz.onChange.read(reader);
+                }
+            }
+            if (setIsUpdating) {
+                setIsUpdating(true);
+            }
+            editor.changeViewZones(a => { for (const id of changeSummary.zoneIds) {
+                a.layoutZone(id);
+            } });
+            if (setIsUpdating) {
+                setIsUpdating(false);
+            }
+        }));
+    }));
+    store.add({
+        dispose() {
+            if (setIsUpdating) {
+                setIsUpdating(true);
+            }
+            editor.changeViewZones(a => { for (const id of lastViewZoneIds) {
+                a.removeZone(id);
+            } });
+            zoneIds?.clear();
+            if (setIsUpdating) {
+                setIsUpdating(false);
+            }
+        }
+    });
+    return store;
+}
+class DisposableCancellationTokenSource extends CancellationTokenSource {
+    dispose() {
+        super.dispose(true);
+    }
+}
+function translatePosition(posInOriginal, mappings) {
+    const mapping = findLast(mappings, m => m.original.startLineNumber <= posInOriginal.lineNumber);
+    if (!mapping) {
+        return Range.fromPositions(posInOriginal);
+    }
+    if (mapping.original.endLineNumberExclusive <= posInOriginal.lineNumber) {
+        const newLineNumber = posInOriginal.lineNumber - mapping.original.endLineNumberExclusive + mapping.modified.endLineNumberExclusive;
+        return Range.fromPositions(( new Position(newLineNumber, posInOriginal.column)));
+    }
+    if (!mapping.innerChanges) {
+        return Range.fromPositions(( new Position(mapping.modified.startLineNumber, 1)));
+    }
+    const innerMapping = findLast(mapping.innerChanges, m => m.originalRange.getStartPosition().isBeforeOrEqual(posInOriginal));
+    if (!innerMapping) {
+        const newLineNumber = posInOriginal.lineNumber - mapping.original.startLineNumber + mapping.modified.startLineNumber;
+        return Range.fromPositions(( new Position(newLineNumber, posInOriginal.column)));
+    }
+    if (innerMapping.originalRange.containsPosition(posInOriginal)) {
+        return innerMapping.modifiedRange;
+    }
+    else {
+        const l = lengthBetweenPositions(innerMapping.originalRange.getEndPosition(), posInOriginal);
+        return Range.fromPositions(addLength(innerMapping.modifiedRange.getEndPosition(), l));
+    }
+}
+function lengthBetweenPositions(position1, position2) {
+    if (position1.lineNumber === position2.lineNumber) {
+        return ( new LengthObj(0, position2.column - position1.column));
+    }
+    else {
+        return ( new LengthObj(position2.lineNumber - position1.lineNumber, position2.column - 1));
+    }
+}
+function addLength(position, length) {
+    if (length.lineCount === 0) {
+        return ( new Position(position.lineNumber, position.column + length.columnCount));
+    }
+    else {
+        return ( new Position(position.lineNumber + length.lineCount, length.columnCount + 1));
+    }
+}
+function bindContextKey(key, service, computeValue) {
+    const boundKey = key.bindTo(service);
+    return autorunOpts({ debugName: () => `Update ${key.key}` }, reader => {
+        boundKey.set(computeValue(reader));
+    });
+}
+export { DisposableCancellationTokenSource, ManagedOverlayWidget, ObservableElementSizeObserver, PlaceholderViewZone, ViewZoneOverlayWidget, animatedObservable, appendRemoveOnDispose, applyObservableDecorations, applyStyle, applyViewZones, bindContextKey, joinCombine, observeHotReloadableExports, readHotReloadableExport, translatePosition };