monaco-editor11 1.0.9 → 1.1.0

package/dist/workers/editor/common/markerDecorationsService.js

@@ -1,248 +0,0 @@
-import { IMarkerService, MarkerSeverity } from '../../../platform/markers/common/markers.js';
-import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
-import { OverviewRulerLane } from '../model.js';
-import { themeColorFromId } from '../../../platform/theme/common/themeService.js';
-import { overviewRulerError, overviewRulerWarning, overviewRulerInfo } from '../core/editorColorRegistry.js';
-import { IModelService } from './model.js';
-import { Range } from '../core/range.js';
-import { Schemas } from '../../../base/common/network.js';
-import { Emitter } from '../../../base/common/event.js';
-import '../../../platform/theme/common/colorUtils.js';
-import '../../../platform/theme/common/colors/baseColors.js';
-import '../../../platform/theme/common/colors/chartsColors.js';
-import '../../../platform/theme/common/colors/editorColors.js';
-import '../../../platform/theme/common/colors/inputColors.js';
-import '../../../platform/theme/common/colors/listColors.js';
-import '../../../platform/theme/common/colors/menuColors.js';
-import { minimapError, minimapWarning, minimapInfo } from '../../../platform/theme/common/colors/minimapColors.js';
-import '../../../platform/theme/common/colors/miscColors.js';
-import '../../../platform/theme/common/colors/quickpickColors.js';
-import '../../../platform/theme/common/colors/searchColors.js';
-import { ResourceMap, BidirectionalMap } from '../../../base/common/map.js';
-import { diffSets } from '../../../base/common/collections.js';
-import { Iterable } from '../../../base/common/iterator.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-let MarkerDecorationsService = class MarkerDecorationsService extends Disposable {
-    constructor(modelService, _markerService) {
-        super();
-        this._markerService = _markerService;
-        this._onDidChangeMarker = this._register(new Emitter());
-        this._suppressedRanges = new ResourceMap();
-        this._markerDecorations = new ResourceMap();
-        modelService.getModels().forEach(model => this._onModelAdded(model));
-        this._register(modelService.onModelAdded(this._onModelAdded, this));
-        this._register(modelService.onModelRemoved(this._onModelRemoved, this));
-        this._register(this._markerService.onMarkerChanged(this._handleMarkerChange, this));
-    }
-    dispose() {
-        super.dispose();
-        this._markerDecorations.forEach(value => value.dispose());
-        this._markerDecorations.clear();
-    }
-    getMarker(uri, decoration) {
-        const markerDecorations = this._markerDecorations.get(uri);
-        return markerDecorations ? (markerDecorations.getMarker(decoration) || null) : null;
-    }
-    _handleMarkerChange(changedResources) {
-        changedResources.forEach((resource) => {
-            const markerDecorations = this._markerDecorations.get(resource);
-            if (markerDecorations) {
-                this._updateDecorations(markerDecorations);
-            }
-        });
-    }
-    _onModelAdded(model) {
-        const markerDecorations = new MarkerDecorations(model);
-        this._markerDecorations.set(model.uri, markerDecorations);
-        this._updateDecorations(markerDecorations);
-    }
-    _onModelRemoved(model) {
-        const markerDecorations = this._markerDecorations.get(model.uri);
-        if (markerDecorations) {
-            markerDecorations.dispose();
-            this._markerDecorations.delete(model.uri);
-        }
-        // clean up markers for internal, transient models
-        if (model.uri.scheme === Schemas.inMemory
-            || model.uri.scheme === Schemas.internal
-            || model.uri.scheme === Schemas.vscode) {
-            this._markerService?.read({ resource: model.uri }).map(marker => marker.owner).forEach(owner => this._markerService.remove(owner, [model.uri]));
-        }
-    }
-    _updateDecorations(markerDecorations) {
-        // Limit to the first 500 errors/warnings
-        let markers = this._markerService.read({ resource: markerDecorations.model.uri, take: 500 });
-        // filter markers from suppressed ranges
-        const suppressedRanges = this._suppressedRanges.get(markerDecorations.model.uri);
-        if (suppressedRanges) {
-            markers = markers.filter(marker => {
-                return !Iterable.some(suppressedRanges, candidate => Range.areIntersectingOrTouching(candidate, marker));
-            });
-        }
-        if (markerDecorations.update(markers)) {
-            this._onDidChangeMarker.fire(markerDecorations.model);
-        }
-    }
-};
-MarkerDecorationsService = __decorate([
-    __param(0, IModelService),
-    __param(1, IMarkerService)
-], MarkerDecorationsService);
-class MarkerDecorations extends Disposable {
-    constructor(model) {
-        super();
-        this.model = model;
-        this._map = new BidirectionalMap();
-        this._register(toDisposable(() => {
-            this.model.deltaDecorations([...this._map.values()], []);
-            this._map.clear();
-        }));
-    }
-    update(markers) {
-        // We use the fact that marker instances are not recreated when different owners
-        // update. So we can compare references to find out what changed since the last update.
-        const { added, removed } = diffSets(new Set(this._map.keys()), new Set(markers));
-        if (added.length === 0 && removed.length === 0) {
-            return false;
-        }
-        const oldIds = removed.map(marker => this._map.get(marker));
-        const newDecorations = added.map(marker => {
-            return {
-                range: this._createDecorationRange(this.model, marker),
-                options: this._createDecorationOption(marker)
-            };
-        });
-        const ids = this.model.deltaDecorations(oldIds, newDecorations);
-        for (const removedMarker of removed) {
-            this._map.delete(removedMarker);
-        }
-        for (let index = 0; index < ids.length; index++) {
-            this._map.set(added[index], ids[index]);
-        }
-        return true;
-    }
-    getMarker(decoration) {
-        return this._map.getKey(decoration.id);
-    }
-    _createDecorationRange(model, rawMarker) {
-        let ret = Range.lift(rawMarker);
-        if (rawMarker.severity === MarkerSeverity.Hint && !this._hasMarkerTag(rawMarker, 1 /* MarkerTag.Unnecessary */) && !this._hasMarkerTag(rawMarker, 2 /* MarkerTag.Deprecated */)) {
-            // * never render hints on multiple lines
-            // * make enough space for three dots
-            ret = ret.setEndPosition(ret.startLineNumber, ret.startColumn + 2);
-        }
-        ret = model.validateRange(ret);
-        if (ret.isEmpty()) {
-            const maxColumn = model.getLineLastNonWhitespaceColumn(ret.startLineNumber) ||
-                model.getLineMaxColumn(ret.startLineNumber);
-            if (maxColumn === 1 || ret.endColumn >= maxColumn) {
-                // empty line or behind eol
-                // keep the range as is, it will be rendered 1ch wide
-                return ret;
-            }
-            const word = model.getWordAtPosition(ret.getStartPosition());
-            if (word) {
-                ret = new Range(ret.startLineNumber, word.startColumn, ret.endLineNumber, word.endColumn);
-            }
-        }
-        else if (rawMarker.endColumn === Number.MAX_VALUE && rawMarker.startColumn === 1 && ret.startLineNumber === ret.endLineNumber) {
-            const minColumn = model.getLineFirstNonWhitespaceColumn(rawMarker.startLineNumber);
-            if (minColumn < ret.endColumn) {
-                ret = new Range(ret.startLineNumber, minColumn, ret.endLineNumber, ret.endColumn);
-                rawMarker.startColumn = minColumn;
-            }
-        }
-        return ret;
-    }
-    _createDecorationOption(marker) {
-        let className;
-        let color = undefined;
-        let zIndex;
-        let inlineClassName = undefined;
-        let minimap;
-        switch (marker.severity) {
-            case MarkerSeverity.Hint:
-                if (this._hasMarkerTag(marker, 2 /* MarkerTag.Deprecated */)) {
-                    className = undefined;
-                }
-                else if (this._hasMarkerTag(marker, 1 /* MarkerTag.Unnecessary */)) {
-                    className = "squiggly-unnecessary" /* ClassName.EditorUnnecessaryDecoration */;
-                }
-                else {
-                    className = "squiggly-hint" /* ClassName.EditorHintDecoration */;
-                }
-                zIndex = 0;
-                break;
-            case MarkerSeverity.Info:
-                className = "squiggly-info" /* ClassName.EditorInfoDecoration */;
-                color = themeColorFromId(overviewRulerInfo);
-                zIndex = 10;
-                minimap = {
-                    color: themeColorFromId(minimapInfo),
-                    position: 1 /* MinimapPosition.Inline */
-                };
-                break;
-            case MarkerSeverity.Warning:
-                className = "squiggly-warning" /* ClassName.EditorWarningDecoration */;
-                color = themeColorFromId(overviewRulerWarning);
-                zIndex = 20;
-                minimap = {
-                    color: themeColorFromId(minimapWarning),
-                    position: 1 /* MinimapPosition.Inline */
-                };
-                break;
-            case MarkerSeverity.Error:
-            default:
-                className = "squiggly-error" /* ClassName.EditorErrorDecoration */;
-                color = themeColorFromId(overviewRulerError);
-                zIndex = 30;
-                minimap = {
-                    color: themeColorFromId(minimapError),
-                    position: 1 /* MinimapPosition.Inline */
-                };
-                break;
-        }
-        if (marker.tags) {
-            if (marker.tags.indexOf(1 /* MarkerTag.Unnecessary */) !== -1) {
-                inlineClassName = "squiggly-inline-unnecessary" /* ClassName.EditorUnnecessaryInlineDecoration */;
-            }
-            if (marker.tags.indexOf(2 /* MarkerTag.Deprecated */) !== -1) {
-                inlineClassName = "squiggly-inline-deprecated" /* ClassName.EditorDeprecatedInlineDecoration */;
-            }
-        }
-        return {
-            description: 'marker-decoration',
-            stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
-            className,
-            showIfCollapsed: true,
-            overviewRuler: {
-                color,
-                position: OverviewRulerLane.Right
-            },
-            minimap,
-            zIndex,
-            inlineClassName,
-        };
-    }
-    _hasMarkerTag(marker, tag) {
-        if (marker.tags) {
-            return marker.tags.indexOf(tag) >= 0;
-        }
-        return false;
-    }
-}
-
-export { MarkerDecorationsService };

package/dist/workers/editor/common/minimapTokensColorTracker.js

@@ -1,58 +0,0 @@
-import { Emitter } from '../../../base/common/event.js';
-import { Disposable, markAsSingleton } from '../../../base/common/lifecycle.js';
-import { RGBA8 } from '../core/misc/rgba.js';
-import { TokenizationRegistry } from '../languages.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class MinimapTokensColorTracker extends Disposable {
-    static { this._INSTANCE = null; }
-    static getInstance() {
-        if (!this._INSTANCE) {
-            this._INSTANCE = markAsSingleton(new MinimapTokensColorTracker());
-        }
-        return this._INSTANCE;
-    }
-    constructor() {
-        super();
-        this._onDidChange = new Emitter();
-        this.onDidChange = this._onDidChange.event;
-        this._updateColorMap();
-        this._register(TokenizationRegistry.onDidChange(e => {
-            if (e.changedColorMap) {
-                this._updateColorMap();
-            }
-        }));
-    }
-    _updateColorMap() {
-        const colorMap = TokenizationRegistry.getColorMap();
-        if (!colorMap) {
-            this._colors = [RGBA8.Empty];
-            this._backgroundIsLight = true;
-            return;
-        }
-        this._colors = [RGBA8.Empty];
-        for (let colorId = 1; colorId < colorMap.length; colorId++) {
-            const source = colorMap[colorId].rgba;
-            // Use a VM friendly data-type
-            this._colors[colorId] = new RGBA8(source.r, source.g, source.b, Math.round(source.a * 255));
-        }
-        const backgroundLuminosity = colorMap[2 /* ColorId.DefaultBackground */].getRelativeLuminance();
-        this._backgroundIsLight = backgroundLuminosity >= 0.5;
-        this._onDidChange.fire(undefined);
-    }
-    getColor(colorId) {
-        if (colorId < 1 || colorId >= this._colors.length) {
-            // background color (basically invisible)
-            colorId = 2 /* ColorId.DefaultBackground */;
-        }
-        return this._colors[colorId];
-    }
-    backgroundIsLight() {
-        return this._backgroundIsLight;
-    }
-}
-
-export { MinimapTokensColorTracker };

package/dist/workers/editor/common/mirrorTextModel.js

@@ -1,117 +0,0 @@
-import { splitLines } from '../../../base/common/strings.js';
-import { Position } from '../core/position.js';
-import { PrefixSumComputer } from './prefixSumComputer.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class MirrorTextModel {
-    constructor(uri, lines, eol, versionId) {
-        this._uri = uri;
-        this._lines = lines;
-        this._eol = eol;
-        this._versionId = versionId;
-        this._lineStarts = null;
-        this._cachedTextValue = null;
-    }
-    dispose() {
-        this._lines.length = 0;
-    }
-    get version() {
-        return this._versionId;
-    }
-    getText() {
-        if (this._cachedTextValue === null) {
-            this._cachedTextValue = this._lines.join(this._eol);
-        }
-        return this._cachedTextValue;
-    }
-    onEvents(e) {
-        if (e.eol && e.eol !== this._eol) {
-            this._eol = e.eol;
-            this._lineStarts = null;
-        }
-        // Update my lines
-        const changes = e.changes;
-        for (const change of changes) {
-            this._acceptDeleteRange(change.range);
-            this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);
-        }
-        this._versionId = e.versionId;
-        this._cachedTextValue = null;
-    }
-    _ensureLineStarts() {
-        if (!this._lineStarts) {
-            const eolLength = this._eol.length;
-            const linesLength = this._lines.length;
-            const lineStartValues = new Uint32Array(linesLength);
-            for (let i = 0; i < linesLength; i++) {
-                lineStartValues[i] = this._lines[i].length + eolLength;
-            }
-            this._lineStarts = new PrefixSumComputer(lineStartValues);
-        }
-    }
-    /**
-     * All changes to a line's text go through this method
-     */
-    _setLineText(lineIndex, newValue) {
-        this._lines[lineIndex] = newValue;
-        if (this._lineStarts) {
-            // update prefix sum
-            this._lineStarts.setValue(lineIndex, this._lines[lineIndex].length + this._eol.length);
-        }
-    }
-    _acceptDeleteRange(range) {
-        if (range.startLineNumber === range.endLineNumber) {
-            if (range.startColumn === range.endColumn) {
-                // Nothing to delete
-                return;
-            }
-            // Delete text on the affected line
-            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)
-                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));
-            return;
-        }
-        // Take remaining text on last line and append it to remaining text on first line
-        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)
-            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));
-        // Delete middle lines
-        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);
-        if (this._lineStarts) {
-            // update prefix sum
-            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);
-        }
-    }
-    _acceptInsertText(position, insertText) {
-        if (insertText.length === 0) {
-            // Nothing to insert
-            return;
-        }
-        const insertLines = splitLines(insertText);
-        if (insertLines.length === 1) {
-            // Inserting text on one line
-            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)
-                + insertLines[0]
-                + this._lines[position.lineNumber - 1].substring(position.column - 1));
-            return;
-        }
-        // Append overflowing text from first line to the end of text to insert
-        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);
-        // Delete overflowing text from first line and insert text on first line
-        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)
-            + insertLines[0]);
-        // Insert new lines & store lengths
-        const newLengths = new Uint32Array(insertLines.length - 1);
-        for (let i = 1; i < insertLines.length; i++) {
-            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);
-            newLengths[i - 1] = insertLines[i].length + this._eol.length;
-        }
-        if (this._lineStarts) {
-            // update prefix sum
-            this._lineStarts.insertValues(position.lineNumber, newLengths);
-        }
-    }
-}
-
-export { MirrorTextModel };

package/dist/workers/editor/common/model.js

@@ -1,9 +0,0 @@
-import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const IModelService = createDecorator('modelService');
-
-export { IModelService };