@codingame/monaco-vscode-extensions-service-override 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/diffComputer.js

@@ -1,92 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { assertFn, checkAdjacentItems } from 'monaco-editor/esm/vs/base/common/assert.js';
-import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { LineRange } from './lineRange.js';
-import { DetailedLineRangeMapping, RangeMapping } from './mapping.js';
-import { observableConfigValue } from '../utils.js';
-
-let MergeDiffComputer = class MergeDiffComputer {
-    constructor(editorWorkerService, configurationService) {
-        this.editorWorkerService = editorWorkerService;
-        this.configurationService = configurationService;
-        this.mergeAlgorithm = ( observableConfigValue('mergeEditor.diffAlgorithm', 'advanced', this.configurationService)
-            .map(v => v === 'smart' ? 'legacy' : v === 'experimental' ? 'advanced' : v));
-    }
-    async computeDiff(textModel1, textModel2, reader) {
-        const diffAlgorithm = this.mergeAlgorithm.read(reader);
-        const inputVersion = textModel1.getVersionId();
-        const outputVersion = textModel2.getVersionId();
-        const result = await this.editorWorkerService.computeDiff(textModel1.uri, textModel2.uri, {
-            ignoreTrimWhitespace: false,
-            maxComputationTimeMs: 0,
-            computeMoves: false,
-        }, diffAlgorithm);
-        if (!result) {
-            throw new Error('Diff computation failed');
-        }
-        if (textModel1.isDisposed() || textModel2.isDisposed()) {
-            return { diffs: null };
-        }
-        const changes = ( result.changes.map(c => ( new DetailedLineRangeMapping(
-            toLineRange(c.original),
-            textModel1,
-            toLineRange(c.modified),
-            textModel2,
-            c.innerChanges?.map(ic => toRangeMapping(ic))
-        ))));
-        const newInputVersion = textModel1.getVersionId();
-        const newOutputVersion = textModel2.getVersionId();
-        if (inputVersion !== newInputVersion || outputVersion !== newOutputVersion) {
-            return { diffs: null };
-        }
-        assertFn(() => {
-            for (const c of changes) {
-                const inputRange = c.inputRange;
-                const outputRange = c.outputRange;
-                const inputTextModel = c.inputTextModel;
-                const outputTextModel = c.outputTextModel;
-                for (const map of c.rangeMappings) {
-                    let inputRangesValid = inputRange.startLineNumber - 1 <= map.inputRange.startLineNumber
-                        && map.inputRange.endLineNumber <= inputRange.endLineNumberExclusive;
-                    if (inputRangesValid && map.inputRange.startLineNumber === inputRange.startLineNumber - 1) {
-                        inputRangesValid = map.inputRange.endColumn >= inputTextModel.getLineMaxColumn(map.inputRange.startLineNumber);
-                    }
-                    if (inputRangesValid && map.inputRange.endLineNumber === inputRange.endLineNumberExclusive) {
-                        inputRangesValid = map.inputRange.endColumn === 1;
-                    }
-                    let outputRangesValid = outputRange.startLineNumber - 1 <= map.outputRange.startLineNumber
-                        && map.outputRange.endLineNumber <= outputRange.endLineNumberExclusive;
-                    if (outputRangesValid && map.outputRange.startLineNumber === outputRange.startLineNumber - 1) {
-                        outputRangesValid = map.outputRange.endColumn >= outputTextModel.getLineMaxColumn(map.outputRange.endLineNumber);
-                    }
-                    if (outputRangesValid && map.outputRange.endLineNumber === outputRange.endLineNumberExclusive) {
-                        outputRangesValid = map.outputRange.endColumn === 1;
-                    }
-                    if (!inputRangesValid || !outputRangesValid) {
-                        return false;
-                    }
-                }
-            }
-            return changes.length === 0 || (changes[0].inputRange.startLineNumber === changes[0].outputRange.startLineNumber &&
-                checkAdjacentItems(changes, (m1, m2) => m2.inputRange.startLineNumber - m1.inputRange.endLineNumberExclusive === m2.outputRange.startLineNumber - m1.outputRange.endLineNumberExclusive &&
-                    m1.inputRange.endLineNumberExclusive < m2.inputRange.startLineNumber &&
-                    m1.outputRange.endLineNumberExclusive < m2.outputRange.startLineNumber));
-        });
-        return {
-            diffs: changes
-        };
-    }
-};
-MergeDiffComputer = ( __decorate([
-    ( __param(0, IEditorWorkerService)),
-    ( __param(1, IConfigurationService))
-], MergeDiffComputer));
-function toLineRange(range) {
-    return ( new LineRange(range.startLineNumber, range.length));
-}
-function toRangeMapping(mapping) {
-    return ( new RangeMapping(mapping.originalRange, mapping.modifiedRange));
-}
-
-export { MergeDiffComputer, toLineRange, toRangeMapping };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/editing.js

@@ -1,56 +0,0 @@
-import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-
-class LineRangeEdit {
-    constructor(range, newLines) {
-        this.range = range;
-        this.newLines = newLines;
-    }
-    equals(other) {
-        return this.range.equals(other.range) && equals(this.newLines, other.newLines);
-    }
-    toEdits(modelLineCount) {
-        return ( new LineEdits([this])).toEdits(modelLineCount);
-    }
-}
-class RangeEdit {
-    constructor(range, newText) {
-        this.range = range;
-        this.newText = newText;
-    }
-    equals(other) {
-        return Range.equalsRange(this.range, other.range) && this.newText === other.newText;
-    }
-}
-class LineEdits {
-    constructor(edits) {
-        this.edits = edits;
-    }
-    toEdits(modelLineCount) {
-        return ( this.edits.map((e) => {
-            if (e.range.endLineNumberExclusive <= modelLineCount) {
-                return {
-                    range: ( new Range(e.range.startLineNumber, 1, e.range.endLineNumberExclusive, 1)),
-                    text: ( e.newLines.map(s => s + '\n')).join(''),
-                };
-            }
-            if (e.range.startLineNumber === 1) {
-                return {
-                    range: ( new Range(1, 1, modelLineCount, Number.MAX_SAFE_INTEGER)),
-                    text: e.newLines.join('\n'),
-                };
-            }
-            return {
-                range: ( new Range(
-                    e.range.startLineNumber - 1,
-                    Number.MAX_SAFE_INTEGER,
-                    modelLineCount,
-                    Number.MAX_SAFE_INTEGER
-                )),
-                text: ( e.newLines.map(s => '\n' + s)).join(''),
-            };
-        }));
-    }
-}
-
-export { LineEdits, LineRangeEdit, RangeEdit };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/lineRange.js

@@ -1,110 +0,0 @@
-import { compareBy, numberComparator } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-
-class LineRange {
-    static { this.compareByStart = compareBy(l => l.startLineNumber, numberComparator); }
-    static join(ranges) {
-        if (ranges.length === 0) {
-            return undefined;
-        }
-        let startLineNumber = Number.MAX_SAFE_INTEGER;
-        let endLineNumber = 0;
-        for (const range of ranges) {
-            startLineNumber = Math.min(startLineNumber, range.startLineNumber);
-            endLineNumber = Math.max(endLineNumber, range.startLineNumber + range.lineCount);
-        }
-        return ( new LineRange(startLineNumber, endLineNumber - startLineNumber));
-    }
-    static fromLineNumbers(startLineNumber, endExclusiveLineNumber) {
-        return ( new LineRange(startLineNumber, endExclusiveLineNumber - startLineNumber));
-    }
-    constructor(startLineNumber, lineCount) {
-        this.startLineNumber = startLineNumber;
-        this.lineCount = lineCount;
-        if (lineCount < 0) {
-            throw new BugIndicatingError();
-        }
-    }
-    join(other) {
-        return ( new LineRange(
-            Math.min(this.startLineNumber, other.startLineNumber),
-            Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive) - this.startLineNumber
-        ));
-    }
-    get endLineNumberExclusive() {
-        return this.startLineNumber + this.lineCount;
-    }
-    get isEmpty() {
-        return this.lineCount === 0;
-    }
-    touches(other) {
-        return (this.endLineNumberExclusive >= other.startLineNumber &&
-            other.endLineNumberExclusive >= this.startLineNumber);
-    }
-    isAfter(range) {
-        return this.startLineNumber >= range.endLineNumberExclusive;
-    }
-    isBefore(range) {
-        return range.startLineNumber >= this.endLineNumberExclusive;
-    }
-    delta(lineDelta) {
-        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount));
-    }
-    toString() {
-        return `[${this.startLineNumber},${this.endLineNumberExclusive})`;
-    }
-    equals(originalRange) {
-        return this.startLineNumber === originalRange.startLineNumber && this.lineCount === originalRange.lineCount;
-    }
-    contains(lineNumber) {
-        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
-    }
-    deltaEnd(delta) {
-        return ( new LineRange(this.startLineNumber, this.lineCount + delta));
-    }
-    deltaStart(lineDelta) {
-        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount - lineDelta));
-    }
-    getLines(model) {
-        const result = ( new Array(this.lineCount));
-        for (let i = 0; i < this.lineCount; i++) {
-            result[i] = model.getLineContent(this.startLineNumber + i);
-        }
-        return result;
-    }
-    containsRange(range) {
-        return this.startLineNumber <= range.startLineNumber && range.endLineNumberExclusive <= this.endLineNumberExclusive;
-    }
-    toRange() {
-        return ( new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1));
-    }
-    toInclusiveRange() {
-        if (this.isEmpty) {
-            return undefined;
-        }
-        return ( new Range(
-            this.startLineNumber,
-            1,
-            this.endLineNumberExclusive - 1,
-            1073741824
-        ));
-    }
-    toInclusiveRangeOrEmpty() {
-        if (this.isEmpty) {
-            return ( new Range(this.startLineNumber, 1, this.startLineNumber, 1));
-        }
-        return ( new Range(
-            this.startLineNumber,
-            1,
-            this.endLineNumberExclusive - 1,
-            1073741824
-        ));
-    }
-    intersects(lineRange) {
-        return this.startLineNumber <= lineRange.endLineNumberExclusive
-            && lineRange.startLineNumber <= this.endLineNumberExclusive;
-    }
-}
-
-export { LineRange };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.js

@@ -1,260 +0,0 @@
-import { lastOrDefault, compareBy, numberComparator } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { findLast } from 'monaco-editor/esm/vs/base/common/arraysFind.js';
-import { assertFn, checkAdjacentItems } from 'monaco-editor/esm/vs/base/common/assert.js';
-import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { concatArrays } from '../utils.js';
-import { LineRangeEdit } from './editing.js';
-import { LineRange } from './lineRange.js';
-import { rangeIsBeforeOrTouching, rangeContainsPosition, lengthBetweenPositions, addLength } from './rangeUtils.js';
-
-class LineRangeMapping {
-    static join(mappings) {
-        return mappings.reduce((acc, cur) => acc ? acc.join(cur) : cur, undefined);
-    }
-    constructor(inputRange, outputRange) {
-        this.inputRange = inputRange;
-        this.outputRange = outputRange;
-    }
-    extendInputRange(extendedInputRange) {
-        if (!extendedInputRange.containsRange(this.inputRange)) {
-            throw new BugIndicatingError();
-        }
-        const startDelta = extendedInputRange.startLineNumber - this.inputRange.startLineNumber;
-        const endDelta = extendedInputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
-        return ( new LineRangeMapping(extendedInputRange, ( new LineRange(
-            this.outputRange.startLineNumber + startDelta,
-            this.outputRange.lineCount - startDelta + endDelta
-        ))));
-    }
-    join(other) {
-        return ( new LineRangeMapping(
-            this.inputRange.join(other.inputRange),
-            this.outputRange.join(other.outputRange)
-        ));
-    }
-    get resultingDeltaFromOriginalToModified() {
-        return this.outputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
-    }
-    toString() {
-        return `${( this.inputRange.toString())} -> ${( this.outputRange.toString())}`;
-    }
-    addOutputLineDelta(delta) {
-        return ( new LineRangeMapping(this.inputRange, this.outputRange.delta(delta)));
-    }
-    addInputLineDelta(delta) {
-        return ( new LineRangeMapping(this.inputRange.delta(delta), this.outputRange));
-    }
-    reverse() {
-        return ( new LineRangeMapping(this.outputRange, this.inputRange));
-    }
-}
-class DocumentLineRangeMap {
-    static betweenOutputs(inputToOutput1, inputToOutput2, inputLineCount) {
-        const alignments = MappingAlignment.compute(inputToOutput1, inputToOutput2);
-        const mappings = ( alignments.map((m) => ( new LineRangeMapping(m.output1Range, m.output2Range))));
-        return ( new DocumentLineRangeMap(mappings, inputLineCount));
-    }
-    constructor(
-    lineRangeMappings, inputLineCount) {
-        this.lineRangeMappings = lineRangeMappings;
-        this.inputLineCount = inputLineCount;
-        assertFn(() => {
-            return checkAdjacentItems(lineRangeMappings, (m1, m2) => m1.inputRange.isBefore(m2.inputRange) && m1.outputRange.isBefore(m2.outputRange) &&
-                m2.inputRange.startLineNumber - m1.inputRange.endLineNumberExclusive === m2.outputRange.startLineNumber - m1.outputRange.endLineNumberExclusive);
-        });
-    }
-    project(lineNumber) {
-        const lastBefore = findLast(this.lineRangeMappings, r => r.inputRange.startLineNumber <= lineNumber);
-        if (!lastBefore) {
-            return ( new LineRangeMapping(( new LineRange(lineNumber, 1)), ( new LineRange(lineNumber, 1))));
-        }
-        if (lastBefore.inputRange.contains(lineNumber)) {
-            return lastBefore;
-        }
-        const containingRange = ( new LineRange(lineNumber, 1));
-        const mappedRange = ( new LineRange(lineNumber +
-            lastBefore.outputRange.endLineNumberExclusive -
-            lastBefore.inputRange.endLineNumberExclusive, 1));
-        return ( new LineRangeMapping(containingRange, mappedRange));
-    }
-    get outputLineCount() {
-        const last = lastOrDefault(this.lineRangeMappings);
-        const diff = last ? last.outputRange.endLineNumberExclusive - last.inputRange.endLineNumberExclusive : 0;
-        return this.inputLineCount + diff;
-    }
-    reverse() {
-        return ( new DocumentLineRangeMap(( this.lineRangeMappings.map(r => r.reverse())), this.outputLineCount));
-    }
-}
-class MappingAlignment {
-    static compute(fromInputToOutput1, fromInputToOutput2) {
-        const compareByStartLineNumber = compareBy((d) => d.inputRange.startLineNumber, numberComparator);
-        const combinedDiffs = concatArrays(( fromInputToOutput1.map((diff) => ({ source: 0, diff }))), ( fromInputToOutput2.map((diff) => ({ source: 1, diff })))).sort(compareBy((d) => d.diff, compareByStartLineNumber));
-        const currentDiffs = [( new Array()), ( new Array())];
-        const deltaFromBaseToInput = [0, 0];
-        const alignments = ( new Array());
-        function pushAndReset(inputRange) {
-            const mapping1 = LineRangeMapping.join(currentDiffs[0]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[0])));
-            const mapping2 = LineRangeMapping.join(currentDiffs[1]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[1])));
-            alignments.push(( new MappingAlignment(
-                currentInputRange,
-                mapping1.extendInputRange(currentInputRange).outputRange,
-                currentDiffs[0],
-                mapping2.extendInputRange(currentInputRange).outputRange,
-                currentDiffs[1]
-            )));
-            currentDiffs[0] = [];
-            currentDiffs[1] = [];
-        }
-        let currentInputRange;
-        for (const diff of combinedDiffs) {
-            const range = diff.diff.inputRange;
-            if (currentInputRange && !currentInputRange.touches(range)) {
-                pushAndReset(currentInputRange);
-                currentInputRange = undefined;
-            }
-            deltaFromBaseToInput[diff.source] =
-                diff.diff.resultingDeltaFromOriginalToModified;
-            currentInputRange = currentInputRange ? currentInputRange.join(range) : range;
-            currentDiffs[diff.source].push(diff.diff);
-        }
-        if (currentInputRange) {
-            pushAndReset(currentInputRange);
-        }
-        return alignments;
-    }
-    constructor(inputRange, output1Range, output1LineMappings, output2Range, output2LineMappings) {
-        this.inputRange = inputRange;
-        this.output1Range = output1Range;
-        this.output1LineMappings = output1LineMappings;
-        this.output2Range = output2Range;
-        this.output2LineMappings = output2LineMappings;
-    }
-    toString() {
-        return `${this.output1Range} <- ${this.inputRange} -> ${this.output2Range}`;
-    }
-}
-class DetailedLineRangeMapping extends LineRangeMapping {
-    static join(mappings) {
-        return mappings.reduce((acc, cur) => acc ? acc.join(cur) : cur, undefined);
-    }
-    constructor(inputRange, inputTextModel, outputRange, outputTextModel, rangeMappings) {
-        super(inputRange, outputRange);
-        this.inputTextModel = inputTextModel;
-        this.outputTextModel = outputTextModel;
-        this.rangeMappings = rangeMappings || [( new RangeMapping(this.inputRange.toRange(), this.outputRange.toRange()))];
-    }
-    addOutputLineDelta(delta) {
-        return ( new DetailedLineRangeMapping(
-            this.inputRange,
-            this.inputTextModel,
-            this.outputRange.delta(delta),
-            this.outputTextModel,
-            ( this.rangeMappings.map(d => d.addOutputLineDelta(delta)))
-        ));
-    }
-    addInputLineDelta(delta) {
-        return ( new DetailedLineRangeMapping(
-            this.inputRange.delta(delta),
-            this.inputTextModel,
-            this.outputRange,
-            this.outputTextModel,
-            ( this.rangeMappings.map(d => d.addInputLineDelta(delta)))
-        ));
-    }
-    join(other) {
-        return ( new DetailedLineRangeMapping(
-            this.inputRange.join(other.inputRange),
-            this.inputTextModel,
-            this.outputRange.join(other.outputRange),
-            this.outputTextModel
-        ));
-    }
-    getLineEdit() {
-        return ( new LineRangeEdit(this.inputRange, this.getOutputLines()));
-    }
-    getReverseLineEdit() {
-        return ( new LineRangeEdit(this.outputRange, this.getInputLines()));
-    }
-    getOutputLines() {
-        return this.outputRange.getLines(this.outputTextModel);
-    }
-    getInputLines() {
-        return this.inputRange.getLines(this.inputTextModel);
-    }
-}
-class RangeMapping {
-    constructor(inputRange, outputRange) {
-        this.inputRange = inputRange;
-        this.outputRange = outputRange;
-    }
-    toString() {
-        function rangeToString(range) {
-            return `[${range.startLineNumber}:${range.startColumn}, ${range.endLineNumber}:${range.endColumn})`;
-        }
-        return `${rangeToString(this.inputRange)} -> ${rangeToString(this.outputRange)}`;
-    }
-    addOutputLineDelta(deltaLines) {
-        return ( new RangeMapping(this.inputRange, ( new Range(
-            this.outputRange.startLineNumber + deltaLines,
-            this.outputRange.startColumn,
-            this.outputRange.endLineNumber + deltaLines,
-            this.outputRange.endColumn
-        ))));
-    }
-    addInputLineDelta(deltaLines) {
-        return ( new RangeMapping(( new Range(
-            this.inputRange.startLineNumber + deltaLines,
-            this.inputRange.startColumn,
-            this.inputRange.endLineNumber + deltaLines,
-            this.inputRange.endColumn
-        )), this.outputRange));
-    }
-    reverse() {
-        return ( new RangeMapping(this.outputRange, this.inputRange));
-    }
-}
-class DocumentRangeMap {
-    constructor(
-    rangeMappings, inputLineCount) {
-        this.rangeMappings = rangeMappings;
-        this.inputLineCount = inputLineCount;
-        assertFn(() => checkAdjacentItems(rangeMappings, (m1, m2) => rangeIsBeforeOrTouching(m1.inputRange, m2.inputRange) &&
-            rangeIsBeforeOrTouching(m1.outputRange, m2.outputRange)
-));
-    }
-    project(position) {
-        const lastBefore = findLast(this.rangeMappings, r => r.inputRange.getStartPosition().isBeforeOrEqual(position));
-        if (!lastBefore) {
-            return ( new RangeMapping(
-                Range.fromPositions(position, position),
-                Range.fromPositions(position, position)
-            ));
-        }
-        if (rangeContainsPosition(lastBefore.inputRange, position)) {
-            return lastBefore;
-        }
-        const dist = lengthBetweenPositions(lastBefore.inputRange.getEndPosition(), position);
-        const outputPos = addLength(lastBefore.outputRange.getEndPosition(), dist);
-        return ( new RangeMapping(Range.fromPositions(position), Range.fromPositions(outputPos)));
-    }
-    projectRange(range) {
-        const start = this.project(range.getStartPosition());
-        const end = this.project(range.getEndPosition());
-        return ( new RangeMapping(
-            start.inputRange.plusRange(end.inputRange),
-            start.outputRange.plusRange(end.outputRange)
-        ));
-    }
-    get outputLineCount() {
-        const last = lastOrDefault(this.rangeMappings);
-        const diff = last ? last.outputRange.endLineNumber - last.inputRange.endLineNumber : 0;
-        return this.inputLineCount + diff;
-    }
-    reverse() {
-        return ( new DocumentRangeMap(( this.rangeMappings.map(m => m.reverse())), this.outputLineCount));
-    }
-}
-
-export { DetailedLineRangeMapping, DocumentLineRangeMap, DocumentRangeMap, LineRangeMapping, MappingAlignment, RangeMapping };