monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/outlineModel.js

@@ -0,0 +1,265 @@
+import { equals } 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 { LRUCache } from '../../../../base/common/map.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { IModelService } from '../../../common/services/model.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.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); }
+};
+class TreeElement {
+    remove() {
+        this.parent?.children.delete(this.id);
+    }
+    static findId(candidate, container) {
+        // complex id-computation which contains the origin/extension,
+        // the parent path, and some dedupe logic when names collide
+        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 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();
+    }
+}
+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();
+            cts.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);
+    }
+    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) { // empty
+                this._groups.delete(key);
+            }
+            else {
+                count += 1;
+            }
+        }
+        if (count !== 1) {
+            //
+            this.children = this._groups;
+        }
+        else {
+            // adopt all elements of the first group
+            const group = Iterable.first(this._groups.values());
+            for (const [, child] of group.children) {
+                child.parent = this;
+                this.children.set(child.id, child);
+            }
+        }
+        return this;
+    }
+    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, // we flatten it...
+            });
+            // Recurse over children
+            if (entry.children) {
+                OutlineModel._flattenDocumentSymbols(bucket, entry.children, entry.name);
+            }
+        }
+    }
+}
+const IOutlineModelService = createDecorator('IOutlineModelService');
+let OutlineModelService = class OutlineModelService {
+    constructor(_languageFeaturesService, debounces, modelService) {
+        this._languageFeaturesService = _languageFeaturesService;
+        this._disposables = new DisposableStore();
+        this._cache = new LRUCache(15, 0.7);
+        this._debounceInformation = debounces.for(_languageFeaturesService.documentSymbolProvider, 'DocumentSymbols', { min: 350 });
+        // don't cache outline models longer than their text model
+        this._disposables.add(modelService.onModelRemoved(textModel => {
+            this._cache.delete(textModel.id);
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    async getOrCreate(textModel, token) {
+        const registry = this._languageFeaturesService.documentSymbolProvider;
+        const provider = registry.ordered(textModel);
+        let data = this._cache.get(textModel.id);
+        if (!data || data.versionId !== textModel.getVersionId() || !equals(data.provider, provider)) {
+            const source = new CancellationTokenSource();
+            data = {
+                versionId: textModel.getVersionId(),
+                provider,
+                promiseCnt: 0,
+                source,
+                promise: OutlineModel.create(registry, textModel, source.token),
+                model: undefined,
+            };
+            this._cache.set(textModel.id, data);
+            const now = Date.now();
+            data.promise.then(outlineModel => {
+                data.model = outlineModel;
+                this._debounceInformation.update(textModel, Date.now() - now);
+            }).catch(_err => {
+                this._cache.delete(textModel.id);
+            });
+        }
+        if (data.model) {
+            // resolved -> return data
+            return data.model;
+        }
+        // increase usage counter
+        data.promiseCnt += 1;
+        const listener = token.onCancellationRequested(() => {
+            // last -> cancel provider request, remove cached promise
+            if (--data.promiseCnt === 0) {
+                data.source.cancel();
+                this._cache.delete(textModel.id);
+            }
+        });
+        try {
+            return await data.promise;
+        }
+        finally {
+            listener.dispose();
+        }
+    }
+};
+OutlineModelService = __decorate([
+    __param(0, ILanguageFeaturesService),
+    __param(1, ILanguageFeatureDebounceService),
+    __param(2, IModelService)
+], OutlineModelService);
+registerSingleton(IOutlineModelService, OutlineModelService, 1 /* InstantiationType.Delayed */);
+
+export { IOutlineModelService, OutlineElement, OutlineGroup, OutlineModel, OutlineModelService, TreeElement };

package/dist/workers/overlayWidgets.js

@@ -0,0 +1,181 @@
+import './overlayWidgets.css';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { ViewPart, PartFingerprints } from '../../view/viewPart.js';
+import { getDomNodePagePosition } from '../../../../base/browser/dom.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/*
+ * This view part for rendering the overlay widgets, which are
+ * floating widgets positioned based on the editor's viewport,
+ * such as the find widget.
+ */
+class ViewOverlayWidgets extends ViewPart {
+    constructor(context, viewDomNode) {
+        super(context);
+        this._viewDomNode = viewDomNode;
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        this._widgets = {};
+        this._verticalScrollbarWidth = layoutInfo.verticalScrollbarWidth;
+        this._minimapWidth = layoutInfo.minimap.minimapWidth;
+        this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
+        this._editorHeight = layoutInfo.height;
+        this._editorWidth = layoutInfo.width;
+        this._viewDomNodeRect = { top: 0, left: 0, width: 0, height: 0 };
+        this._domNode = createFastDomNode(document.createElement('div'));
+        PartFingerprints.write(this._domNode, 4 /* PartFingerprint.OverlayWidgets */);
+        this._domNode.setClassName('overlayWidgets');
+        this.overflowingOverlayWidgetsDomNode = createFastDomNode(document.createElement('div'));
+        PartFingerprints.write(this.overflowingOverlayWidgetsDomNode, 5 /* PartFingerprint.OverflowingOverlayWidgets */);
+        this.overflowingOverlayWidgetsDomNode.setClassName('overflowingOverlayWidgets');
+    }
+    dispose() {
+        super.dispose();
+        this._widgets = {};
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    // ---- begin view event handlers
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        this._verticalScrollbarWidth = layoutInfo.verticalScrollbarWidth;
+        this._minimapWidth = layoutInfo.minimap.minimapWidth;
+        this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
+        this._editorHeight = layoutInfo.height;
+        this._editorWidth = layoutInfo.width;
+        return true;
+    }
+    // ---- end view event handlers
+    _widgetCanOverflow(widget) {
+        const options = this._context.configuration.options;
+        const allowOverflow = options.get(4 /* EditorOption.allowOverflow */);
+        return (widget.allowEditorOverflow || false) && allowOverflow;
+    }
+    addWidget(widget) {
+        const domNode = createFastDomNode(widget.getDomNode());
+        this._widgets[widget.getId()] = {
+            widget: widget,
+            preference: null,
+            domNode: domNode
+        };
+        // This is sync because a widget wants to be in the dom
+        domNode.setPosition('absolute');
+        domNode.setAttribute('widgetId', widget.getId());
+        if (this._widgetCanOverflow(widget)) {
+            this.overflowingOverlayWidgetsDomNode.appendChild(domNode);
+        }
+        else {
+            this._domNode.appendChild(domNode);
+        }
+        this.setShouldRender();
+        this._updateMaxMinWidth();
+    }
+    setWidgetPosition(widget, position) {
+        const widgetData = this._widgets[widget.getId()];
+        const preference = position ? position.preference : null;
+        const stack = position?.stackOridinal;
+        if (widgetData.preference === preference && widgetData.stack === stack) {
+            this._updateMaxMinWidth();
+            return false;
+        }
+        widgetData.preference = preference;
+        widgetData.stack = stack;
+        this.setShouldRender();
+        this._updateMaxMinWidth();
+        return true;
+    }
+    removeWidget(widget) {
+        const widgetId = widget.getId();
+        if (this._widgets.hasOwnProperty(widgetId)) {
+            const widgetData = this._widgets[widgetId];
+            const domNode = widgetData.domNode.domNode;
+            delete this._widgets[widgetId];
+            domNode.remove();
+            this.setShouldRender();
+            this._updateMaxMinWidth();
+        }
+    }
+    _updateMaxMinWidth() {
+        let maxMinWidth = 0;
+        const keys = Object.keys(this._widgets);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const widgetId = keys[i];
+            const widget = this._widgets[widgetId];
+            const widgetMinWidthInPx = widget.widget.getMinContentWidthInPx?.();
+            if (typeof widgetMinWidthInPx !== 'undefined') {
+                maxMinWidth = Math.max(maxMinWidth, widgetMinWidthInPx);
+            }
+        }
+        this._context.viewLayout.setOverlayWidgetsMinWidth(maxMinWidth);
+    }
+    _renderWidget(widgetData, stackCoordinates) {
+        const domNode = widgetData.domNode;
+        if (widgetData.preference === null) {
+            domNode.setTop('');
+            return;
+        }
+        const maxRight = (2 * this._verticalScrollbarWidth) + this._minimapWidth;
+        if (widgetData.preference === 0 /* OverlayWidgetPositionPreference.TOP_RIGHT_CORNER */ || widgetData.preference === 1 /* OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER */) {
+            if (widgetData.preference === 1 /* OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER */) {
+                const widgetHeight = domNode.domNode.clientHeight;
+                domNode.setTop((this._editorHeight - widgetHeight - 2 * this._horizontalScrollbarHeight));
+            }
+            else {
+                domNode.setTop(0);
+            }
+            if (widgetData.stack !== undefined) {
+                domNode.setTop(stackCoordinates[widgetData.preference]);
+                stackCoordinates[widgetData.preference] += domNode.domNode.clientWidth;
+            }
+            else {
+                domNode.setRight(maxRight);
+            }
+        }
+        else if (widgetData.preference === 2 /* OverlayWidgetPositionPreference.TOP_CENTER */) {
+            domNode.domNode.style.right = '50%';
+            if (widgetData.stack !== undefined) {
+                domNode.setTop(stackCoordinates[2 /* OverlayWidgetPositionPreference.TOP_CENTER */]);
+                stackCoordinates[2 /* OverlayWidgetPositionPreference.TOP_CENTER */] += domNode.domNode.clientHeight;
+            }
+            else {
+                domNode.setTop(0);
+            }
+        }
+        else {
+            const { top, left } = widgetData.preference;
+            const fixedOverflowWidgets = this._context.configuration.options.get(51 /* EditorOption.fixedOverflowWidgets */);
+            if (fixedOverflowWidgets && this._widgetCanOverflow(widgetData.widget)) {
+                // top, left are computed relative to the editor and we need them relative to the page
+                const editorBoundingBox = this._viewDomNodeRect;
+                domNode.setTop(top + editorBoundingBox.top);
+                domNode.setLeft(left + editorBoundingBox.left);
+                domNode.setPosition('fixed');
+            }
+            else {
+                domNode.setTop(top);
+                domNode.setLeft(left);
+                domNode.setPosition('absolute');
+            }
+        }
+    }
+    prepareRender(ctx) {
+        this._viewDomNodeRect = getDomNodePagePosition(this._viewDomNode.domNode);
+    }
+    render(ctx) {
+        this._domNode.setWidth(this._editorWidth);
+        const keys = Object.keys(this._widgets);
+        const stackCoordinates = Array.from({ length: 2 /* OverlayWidgetPositionPreference.TOP_CENTER */ + 1 }, () => 0);
+        keys.sort((a, b) => (this._widgets[a].stack || 0) - (this._widgets[b].stack || 0));
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const widgetId = keys[i];
+            this._renderWidget(this._widgets[widgetId], stackCoordinates);
+        }
+    }
+}
+
+export { ViewOverlayWidgets };

package/dist/workers/overviewRuler.js

@@ -0,0 +1,134 @@
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { OverviewZoneManager } from '../../../common/viewModel/overviewZoneManager.js';
+import { ViewEventHandler } from '../../../common/viewEventHandler.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * The overview ruler appears underneath the editor scroll bar and shows things
+ * like the cursor, various decorations, etc.
+ */
+class OverviewRuler extends ViewEventHandler {
+    constructor(context, cssClassName) {
+        super();
+        this._context = context;
+        const options = this._context.configuration.options;
+        this._domNode = createFastDomNode(document.createElement('canvas'));
+        this._domNode.setClassName(cssClassName);
+        this._domNode.setPosition('absolute');
+        this._domNode.setLayerHinting(true);
+        this._domNode.setContain('strict');
+        this._zoneManager = new OverviewZoneManager((lineNumber) => this._context.viewLayout.getVerticalOffsetForLineNumber(lineNumber));
+        this._zoneManager.setDOMWidth(0);
+        this._zoneManager.setDOMHeight(0);
+        this._zoneManager.setOuterHeight(this._context.viewLayout.getScrollHeight());
+        this._zoneManager.setLineHeight(options.get(75 /* EditorOption.lineHeight */));
+        this._zoneManager.setPixelRatio(options.get(163 /* EditorOption.pixelRatio */));
+        this._context.addEventHandler(this);
+    }
+    dispose() {
+        this._context.removeEventHandler(this);
+        super.dispose();
+    }
+    // ---- begin view event handlers
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        if (e.hasChanged(75 /* EditorOption.lineHeight */)) {
+            this._zoneManager.setLineHeight(options.get(75 /* EditorOption.lineHeight */));
+            this._render();
+        }
+        if (e.hasChanged(163 /* EditorOption.pixelRatio */)) {
+            this._zoneManager.setPixelRatio(options.get(163 /* EditorOption.pixelRatio */));
+            this._domNode.setWidth(this._zoneManager.getDOMWidth());
+            this._domNode.setHeight(this._zoneManager.getDOMHeight());
+            this._domNode.domNode.width = this._zoneManager.getCanvasWidth();
+            this._domNode.domNode.height = this._zoneManager.getCanvasHeight();
+            this._render();
+        }
+        return true;
+    }
+    onFlushed(e) {
+        this._render();
+        return true;
+    }
+    onScrollChanged(e) {
+        if (e.scrollHeightChanged) {
+            this._zoneManager.setOuterHeight(e.scrollHeight);
+            this._render();
+        }
+        return true;
+    }
+    onZonesChanged(e) {
+        this._render();
+        return true;
+    }
+    // ---- end view event handlers
+    getDomNode() {
+        return this._domNode.domNode;
+    }
+    setLayout(position) {
+        this._domNode.setTop(position.top);
+        this._domNode.setRight(position.right);
+        let hasChanged = false;
+        hasChanged = this._zoneManager.setDOMWidth(position.width) || hasChanged;
+        hasChanged = this._zoneManager.setDOMHeight(position.height) || hasChanged;
+        if (hasChanged) {
+            this._domNode.setWidth(this._zoneManager.getDOMWidth());
+            this._domNode.setHeight(this._zoneManager.getDOMHeight());
+            this._domNode.domNode.width = this._zoneManager.getCanvasWidth();
+            this._domNode.domNode.height = this._zoneManager.getCanvasHeight();
+            this._render();
+        }
+    }
+    setZones(zones) {
+        this._zoneManager.setZones(zones);
+        this._render();
+    }
+    _render() {
+        if (this._zoneManager.getOuterHeight() === 0) {
+            return false;
+        }
+        const width = this._zoneManager.getCanvasWidth();
+        const height = this._zoneManager.getCanvasHeight();
+        const colorZones = this._zoneManager.resolveColorZones();
+        const id2Color = this._zoneManager.getId2Color();
+        const ctx = this._domNode.domNode.getContext('2d');
+        ctx.clearRect(0, 0, width, height);
+        if (colorZones.length > 0) {
+            this._renderOneLane(ctx, colorZones, id2Color, width);
+        }
+        return true;
+    }
+    _renderOneLane(ctx, colorZones, id2Color, width) {
+        let currentColorId = 0;
+        let currentFrom = 0;
+        let currentTo = 0;
+        for (const zone of colorZones) {
+            const zoneColorId = zone.colorId;
+            const zoneFrom = zone.from;
+            const zoneTo = zone.to;
+            if (zoneColorId !== currentColorId) {
+                ctx.fillRect(0, currentFrom, width, currentTo - currentFrom);
+                currentColorId = zoneColorId;
+                ctx.fillStyle = id2Color[currentColorId];
+                currentFrom = zoneFrom;
+                currentTo = zoneTo;
+            }
+            else {
+                if (currentTo >= zoneFrom) {
+                    currentTo = Math.max(currentTo, zoneTo);
+                }
+                else {
+                    ctx.fillRect(0, currentFrom, width, currentTo - currentFrom);
+                    currentFrom = zoneFrom;
+                    currentTo = zoneTo;
+                }
+            }
+        }
+        ctx.fillRect(0, currentFrom, width, currentTo - currentFrom);
+    }
+}
+
+export { OverviewRuler };