@codingame/monaco-vscode-api 2.0.3-improve-modularity.1 → 2.1.0-update-vscode-1.86.1

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

@@ -1,299 +0,0 @@
-import { equals, binarySearch, coalesceInPlace } from '../../../../base/common/arrays.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
-import { Iterable } from '../../../../base/common/iterator.js';
-import { commonPrefixLength } from '../../../../base/common/strings.js';
-import { Position } from '../../../common/core/position.js';
-import { Range } from '../../../common/core/range.js';
-class TreeElement {
-    remove() {
-        this.parent?.children.delete(this.id);
-    }
-    static findId(candidate, container) {
-        let candidateId;
-        if (typeof candidate === 'string') {
-            candidateId = `${container.id}/${candidate}`;
-        }
-        else {
-            candidateId = `${container.id}/${candidate.name}`;
-            if (container.children.get(candidateId) !== undefined) {
-                candidateId = `${container.id}/${candidate.name}_${candidate.range.startLineNumber}_${candidate.range.startColumn}`;
-            }
-        }
-        let id = candidateId;
-        for (let i = 0; container.children.get(id) !== undefined; i++) {
-            id = `${candidateId}_${i}`;
-        }
-        return id;
-    }
-    static getElementById(id, element) {
-        if (!id) {
-            return undefined;
-        }
-        const len = commonPrefixLength(id, element.id);
-        if (len === id.length) {
-            return element;
-        }
-        if (len < element.id.length) {
-            return undefined;
-        }
-        for (const [, child] of element.children) {
-            const candidate = TreeElement.getElementById(id, child);
-            if (candidate) {
-                return candidate;
-            }
-        }
-        return undefined;
-    }
-    static size(element) {
-        let res = 1;
-        for (const [, child] of element.children) {
-            res += TreeElement.size(child);
-        }
-        return res;
-    }
-    static empty(element) {
-        return element.children.size === 0;
-    }
-}
-class OutlineElement extends TreeElement {
-    constructor(id, parent, symbol) {
-        super();
-        this.id = id;
-        this.parent = parent;
-        this.symbol = symbol;
-        this.children = ( new Map());
-    }
-}
-class OutlineGroup extends TreeElement {
-    constructor(id, parent, label, order) {
-        super();
-        this.id = id;
-        this.parent = parent;
-        this.label = label;
-        this.order = order;
-        this.children = ( new Map());
-    }
-    getItemEnclosingPosition(position) {
-        return position ? this._getItemEnclosingPosition(position, this.children) : undefined;
-    }
-    _getItemEnclosingPosition(position, children) {
-        for (const [, item] of children) {
-            if (!item.symbol.range || !Range.containsPosition(item.symbol.range, position)) {
-                continue;
-            }
-            return this._getItemEnclosingPosition(position, item.children) || item;
-        }
-        return undefined;
-    }
-    updateMarker(marker) {
-        for (const [, child] of this.children) {
-            this._updateMarker(marker, child);
-        }
-    }
-    _updateMarker(markers, item) {
-        item.marker = undefined;
-        const idx = binarySearch(markers, item.symbol.range, Range.compareRangesUsingStarts);
-        let start;
-        if (idx < 0) {
-            start = ~idx;
-            if (start > 0 && Range.areIntersecting(markers[start - 1], item.symbol.range)) {
-                start -= 1;
-            }
-        }
-        else {
-            start = idx;
-        }
-        const myMarkers = [];
-        let myTopSev;
-        for (; start < markers.length && Range.areIntersecting(item.symbol.range, markers[start]); start++) {
-            const marker = markers[start];
-            myMarkers.push(marker);
-            markers[start] = undefined;
-            if (!myTopSev || marker.severity > myTopSev) {
-                myTopSev = marker.severity;
-            }
-        }
-        for (const [, child] of item.children) {
-            this._updateMarker(myMarkers, child);
-        }
-        if (myTopSev) {
-            item.marker = {
-                count: myMarkers.length,
-                topSev: myTopSev
-            };
-        }
-        coalesceInPlace(markers);
-    }
-}
-class OutlineModel extends TreeElement {
-    static create(registry, textModel, token) {
-        const cts = ( new CancellationTokenSource(token));
-        const result = ( new OutlineModel(textModel.uri));
-        const provider = registry.ordered(textModel);
-        const promises = ( provider.map((provider, index) => {
-            const id = TreeElement.findId(`provider_${index}`, result);
-            const group = ( new OutlineGroup(id, result, provider.displayName ?? 'Unknown Outline Provider', index));
-            return Promise.resolve(provider.provideDocumentSymbols(textModel, cts.token)).then(result => {
-                for (const info of result || []) {
-                    OutlineModel._makeOutlineElement(info, group);
-                }
-                return group;
-            }, err => {
-                onUnexpectedExternalError(err);
-                return group;
-            }).then(group => {
-                if (!TreeElement.empty(group)) {
-                    result._groups.set(id, group);
-                }
-                else {
-                    group.remove();
-                }
-            });
-        }));
-        const listener = registry.onDidChange(() => {
-            const newProvider = registry.ordered(textModel);
-            if (!equals(newProvider, provider)) {
-                cts.cancel();
-            }
-        });
-        return Promise.all(promises).then(() => {
-            if (cts.token.isCancellationRequested && !token.isCancellationRequested) {
-                return OutlineModel.create(registry, textModel, token);
-            }
-            else {
-                return result._compact();
-            }
-        }).finally(() => {
-            cts.dispose();
-            listener.dispose();
-        });
-    }
-    static _makeOutlineElement(info, container) {
-        const id = TreeElement.findId(info, container);
-        const res = ( new OutlineElement(id, container, info));
-        if (info.children) {
-            for (const childInfo of info.children) {
-                OutlineModel._makeOutlineElement(childInfo, res);
-            }
-        }
-        container.children.set(res.id, res);
-    }
-    static get(element) {
-        while (element) {
-            if (element instanceof OutlineModel) {
-                return element;
-            }
-            element = element.parent;
-        }
-        return undefined;
-    }
-    constructor(uri) {
-        super();
-        this.uri = uri;
-        this.id = 'root';
-        this.parent = undefined;
-        this._groups = ( new Map());
-        this.children = ( new Map());
-        this.id = 'root';
-        this.parent = undefined;
-    }
-    _compact() {
-        let count = 0;
-        for (const [key, group] of this._groups) {
-            if (group.children.size === 0) {
-                this._groups.delete(key);
-            }
-            else {
-                count += 1;
-            }
-        }
-        if (count !== 1) {
-            this.children = this._groups;
-        }
-        else {
-            const group = Iterable.first(( this._groups.values()));
-            for (const [, child] of group.children) {
-                child.parent = this;
-                this.children.set(child.id, child);
-            }
-        }
-        return this;
-    }
-    merge(other) {
-        if (( this.uri.toString()) !== ( other.uri.toString())) {
-            return false;
-        }
-        if (this._groups.size !== other._groups.size) {
-            return false;
-        }
-        this._groups = other._groups;
-        this.children = other.children;
-        return true;
-    }
-    getItemEnclosingPosition(position, context) {
-        let preferredGroup;
-        if (context) {
-            let candidate = context.parent;
-            while (candidate && !preferredGroup) {
-                if (candidate instanceof OutlineGroup) {
-                    preferredGroup = candidate;
-                }
-                candidate = candidate.parent;
-            }
-        }
-        let result = undefined;
-        for (const [, group] of this._groups) {
-            result = group.getItemEnclosingPosition(position);
-            if (result && (!preferredGroup || preferredGroup === group)) {
-                break;
-            }
-        }
-        return result;
-    }
-    getItemById(id) {
-        return TreeElement.getElementById(id, this);
-    }
-    updateMarker(marker) {
-        marker.sort(Range.compareRangesUsingStarts);
-        for (const [, group] of this._groups) {
-            group.updateMarker(marker.slice(0));
-        }
-    }
-    getTopLevelSymbols() {
-        const roots = [];
-        for (const child of ( this.children.values())) {
-            if (child instanceof OutlineElement) {
-                roots.push(child.symbol);
-            }
-            else {
-                roots.push(...( Iterable.map(( child.children.values()), child => child.symbol)));
-            }
-        }
-        return roots.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
-    }
-    asListOfDocumentSymbols() {
-        const roots = this.getTopLevelSymbols();
-        const bucket = [];
-        OutlineModel._flattenDocumentSymbols(bucket, roots, '');
-        return bucket.sort((a, b) => Position.compare(Range.getStartPosition(a.range), Range.getStartPosition(b.range)) || Position.compare(Range.getEndPosition(b.range), Range.getEndPosition(a.range)));
-    }
-    static _flattenDocumentSymbols(bucket, entries, overrideContainerLabel) {
-        for (const entry of entries) {
-            bucket.push({
-                kind: entry.kind,
-                tags: entry.tags,
-                name: entry.name,
-                detail: entry.detail,
-                containerName: entry.containerName || overrideContainerLabel,
-                range: entry.range,
-                selectionRange: entry.selectionRange,
-                children: undefined,
-            });
-            if (entry.children) {
-                OutlineModel._flattenDocumentSymbols(bucket, entry.children, entry.name);
-            }
-        }
-    }
-}
-export { OutlineElement, OutlineGroup, OutlineModel, TreeElement };

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

@@ -1,101 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { StopWatch } from '../../../../base/common/stopwatch.js';
-import { LineRange } from '../../../common/core/lineRange.js';
-import { DetailedLineRangeMapping, RangeMapping } from '../../../common/diff/rangeMapping.js';
-import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-var WorkerBasedDocumentDiffProvider_1;
-let WorkerBasedDocumentDiffProvider = class WorkerBasedDocumentDiffProvider {
-    static { WorkerBasedDocumentDiffProvider_1 = this; }
-    static { this.diffCache = ( new Map()); }
-    constructor(options, editorWorkerService, telemetryService) {
-        this.editorWorkerService = editorWorkerService;
-        this.telemetryService = telemetryService;
-        this.onDidChangeEventEmitter = ( new Emitter());
-        this.onDidChange = this.onDidChangeEventEmitter.event;
-        this.diffAlgorithm = 'advanced';
-        this.diffAlgorithmOnDidChangeSubscription = undefined;
-        this.setOptions(options);
-    }
-    dispose() {
-        this.diffAlgorithmOnDidChangeSubscription?.dispose();
-    }
-    async computeDiff(original, modified, options, cancellationToken) {
-        if (typeof this.diffAlgorithm !== 'string') {
-            return this.diffAlgorithm.computeDiff(original, modified, options, cancellationToken);
-        }
-        if (original.getLineCount() === 1 && original.getLineMaxColumn(1) === 1) {
-            if (modified.getLineCount() === 1 && modified.getLineMaxColumn(1) === 1) {
-                return {
-                    changes: [],
-                    identical: true,
-                    quitEarly: false,
-                    moves: [],
-                };
-            }
-            return {
-                changes: [
-                    ( new DetailedLineRangeMapping(( new LineRange(1, 2)), ( new LineRange(1, modified.getLineCount() + 1)), [
-                        ( new RangeMapping(original.getFullModelRange(), modified.getFullModelRange()))
-                    ]))
-                ],
-                identical: false,
-                quitEarly: false,
-                moves: [],
-            };
-        }
-        const uriKey = JSON.stringify([( original.uri.toString()), ( modified.uri.toString())]);
-        const context = JSON.stringify([original.id, modified.id, original.getAlternativeVersionId(), modified.getAlternativeVersionId(), JSON.stringify(options)]);
-        const c = WorkerBasedDocumentDiffProvider_1.diffCache.get(uriKey);
-        if (c && c.context === context) {
-            return c.result;
-        }
-        const sw = StopWatch.create();
-        const result = await this.editorWorkerService.computeDiff(original.uri, modified.uri, options, this.diffAlgorithm);
-        const timeMs = sw.elapsed();
-        this.telemetryService.publicLog2('diffEditor.computeDiff', {
-            timeMs,
-            timedOut: result?.quitEarly ?? true,
-            detectedMoves: options.computeMoves ? (result?.moves.length ?? 0) : -1,
-        });
-        if (cancellationToken.isCancellationRequested) {
-            return {
-                changes: [],
-                identical: false,
-                quitEarly: true,
-                moves: [],
-            };
-        }
-        if (!result) {
-            throw new Error('no diff result available');
-        }
-        if (WorkerBasedDocumentDiffProvider_1.diffCache.size > 10) {
-            WorkerBasedDocumentDiffProvider_1.diffCache.delete(( WorkerBasedDocumentDiffProvider_1.diffCache.keys()).next().value);
-        }
-        WorkerBasedDocumentDiffProvider_1.diffCache.set(uriKey, { result, context });
-        return result;
-    }
-    setOptions(newOptions) {
-        let didChange = false;
-        if (newOptions.diffAlgorithm) {
-            if (this.diffAlgorithm !== newOptions.diffAlgorithm) {
-                this.diffAlgorithmOnDidChangeSubscription?.dispose();
-                this.diffAlgorithmOnDidChangeSubscription = undefined;
-                this.diffAlgorithm = newOptions.diffAlgorithm;
-                if (typeof newOptions.diffAlgorithm !== 'string') {
-                    this.diffAlgorithmOnDidChangeSubscription = newOptions.diffAlgorithm.onDidChange(() => this.onDidChangeEventEmitter.fire());
-                }
-                didChange = true;
-            }
-        }
-        if (didChange) {
-            this.onDidChangeEventEmitter.fire();
-        }
-    }
-};
-WorkerBasedDocumentDiffProvider = WorkerBasedDocumentDiffProvider_1 = ( __decorate([
-    ( __param(1, IEditorWorkerService)),
-    ( __param(2, ITelemetryService))
-], WorkerBasedDocumentDiffProvider));
-export { WorkerBasedDocumentDiffProvider };