monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,137 +0,0 @@
-import { doHash } from '../../../base/common/hash.js';
-import { LRUCache } from '../../../base/common/map.js';
-import { MovingAverage, clamp, SlidingWindowAverage } from '../../../base/common/numbers.js';
-import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
-import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
-import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
-import { ILogService } from '../../../platform/log/common/log.js';
-import { matchesScheme } from '../../../base/common/network.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); }
-};
-const ILanguageFeatureDebounceService = createDecorator('ILanguageFeatureDebounceService');
-var IdentityHash;
-(function (IdentityHash) {
-    const _hashes = new WeakMap();
-    let pool = 0;
-    function of(obj) {
-        let value = _hashes.get(obj);
-        if (value === undefined) {
-            value = ++pool;
-            _hashes.set(obj, value);
-        }
-        return value;
-    }
-    IdentityHash.of = of;
-})(IdentityHash || (IdentityHash = {}));
-class NullDebounceInformation {
-    constructor(_default) {
-        this._default = _default;
-    }
-    get(_model) {
-        return this._default;
-    }
-    update(_model, _value) {
-        return this._default;
-    }
-    default() {
-        return this._default;
-    }
-}
-class FeatureDebounceInformation {
-    constructor(_logService, _name, _registry, _default, _min, _max) {
-        this._logService = _logService;
-        this._name = _name;
-        this._registry = _registry;
-        this._default = _default;
-        this._min = _min;
-        this._max = _max;
-        this._cache = new LRUCache(50, 0.7);
-    }
-    _key(model) {
-        return model.id + this._registry.all(model).reduce((hashVal, obj) => doHash(IdentityHash.of(obj), hashVal), 0);
-    }
-    get(model) {
-        const key = this._key(model);
-        const avg = this._cache.get(key);
-        return avg
-            ? clamp(avg.value, this._min, this._max)
-            : this.default();
-    }
-    update(model, value) {
-        const key = this._key(model);
-        let avg = this._cache.get(key);
-        if (!avg) {
-            avg = new SlidingWindowAverage(6);
-            this._cache.set(key, avg);
-        }
-        const newValue = clamp(avg.update(value), this._min, this._max);
-        if (!matchesScheme(model.uri, 'output')) {
-            this._logService.trace(`[DEBOUNCE: ${this._name}] for ${model.uri.toString()} is ${newValue}ms`);
-        }
-        return newValue;
-    }
-    _overall() {
-        const result = new MovingAverage();
-        for (const [, avg] of this._cache) {
-            result.update(avg.value);
-        }
-        return result.value;
-    }
-    default() {
-        const value = (this._overall() | 0) || this._default;
-        return clamp(value, this._min, this._max);
-    }
-}
-let LanguageFeatureDebounceService = class LanguageFeatureDebounceService {
-    constructor(_logService, envService) {
-        this._logService = _logService;
-        this._data = new Map();
-        this._isDev = envService.isExtensionDevelopment || !envService.isBuilt;
-    }
-    for(feature, name, config) {
-        const min = config?.min ?? 50;
-        const max = config?.max ?? min ** 2;
-        const extra = config?.key ?? undefined;
-        const key = `${IdentityHash.of(feature)},${min}${extra ? ',' + extra : ''}`;
-        let info = this._data.get(key);
-        if (!info) {
-            if (this._isDev) {
-                this._logService.debug(`[DEBOUNCE: ${name}] is disabled in developed mode`);
-                info = new NullDebounceInformation(min * 1.5);
-            }
-            else {
-                info = new FeatureDebounceInformation(this._logService, name, feature, (this._overallAverage() | 0) || (min * 1.5), // default is overall default or derived from min-value
-                min, max);
-            }
-            this._data.set(key, info);
-        }
-        return info;
-    }
-    _overallAverage() {
-        // Average of all language features. Not a great value but an approximation
-        const result = new MovingAverage();
-        for (const info of this._data.values()) {
-            result.update(info.default());
-        }
-        return result.value;
-    }
-};
-LanguageFeatureDebounceService = __decorate([
-    __param(0, ILogService),
-    __param(1, IEnvironmentService)
-], LanguageFeatureDebounceService);
-registerSingleton(ILanguageFeatureDebounceService, LanguageFeatureDebounceService, 1 /* InstantiationType.Delayed */);
-
-export { ILanguageFeatureDebounceService, LanguageFeatureDebounceService };

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

@@ -1,180 +0,0 @@
-import { Emitter } from '../../base/common/event.js';
-import { toDisposable } from '../../base/common/lifecycle.js';
-import { shouldSynchronizeModel } from './model.js';
-import { score } from './languageSelector.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function isExclusive(selector) {
-    if (typeof selector === 'string') {
-        return false;
-    }
-    else if (Array.isArray(selector)) {
-        return selector.every(isExclusive);
-    }
-    else {
-        return !!selector.exclusive; // TODO: microsoft/TypeScript#42768
-    }
-}
-class MatchCandidate {
-    constructor(uri, languageId, notebookUri, notebookType, recursive) {
-        this.uri = uri;
-        this.languageId = languageId;
-        this.notebookUri = notebookUri;
-        this.notebookType = notebookType;
-        this.recursive = recursive;
-    }
-    equals(other) {
-        return this.notebookType === other.notebookType
-            && this.languageId === other.languageId
-            && this.uri.toString() === other.uri.toString()
-            && this.notebookUri?.toString() === other.notebookUri?.toString()
-            && this.recursive === other.recursive;
-    }
-}
-class LanguageFeatureRegistry {
-    get onDidChange() { return this._onDidChange.event; }
-    constructor(_notebookInfoResolver) {
-        this._notebookInfoResolver = _notebookInfoResolver;
-        this._clock = 0;
-        this._entries = [];
-        this._onDidChange = new Emitter();
-    }
-    register(selector, provider) {
-        let entry = {
-            selector,
-            provider,
-            _score: -1,
-            _time: this._clock++
-        };
-        this._entries.push(entry);
-        this._lastCandidate = undefined;
-        this._onDidChange.fire(this._entries.length);
-        return toDisposable(() => {
-            if (entry) {
-                const idx = this._entries.indexOf(entry);
-                if (idx >= 0) {
-                    this._entries.splice(idx, 1);
-                    this._lastCandidate = undefined;
-                    this._onDidChange.fire(this._entries.length);
-                    entry = undefined;
-                }
-            }
-        });
-    }
-    has(model) {
-        return this.all(model).length > 0;
-    }
-    all(model) {
-        if (!model) {
-            return [];
-        }
-        this._updateScores(model, false);
-        const result = [];
-        // from registry
-        for (const entry of this._entries) {
-            if (entry._score > 0) {
-                result.push(entry.provider);
-            }
-        }
-        return result;
-    }
-    ordered(model, recursive = false) {
-        const result = [];
-        this._orderedForEach(model, recursive, entry => result.push(entry.provider));
-        return result;
-    }
-    orderedGroups(model) {
-        const result = [];
-        let lastBucket;
-        let lastBucketScore;
-        this._orderedForEach(model, false, entry => {
-            if (lastBucket && lastBucketScore === entry._score) {
-                lastBucket.push(entry.provider);
-            }
-            else {
-                lastBucketScore = entry._score;
-                lastBucket = [entry.provider];
-                result.push(lastBucket);
-            }
-        });
-        return result;
-    }
-    _orderedForEach(model, recursive, callback) {
-        this._updateScores(model, recursive);
-        for (const entry of this._entries) {
-            if (entry._score > 0) {
-                callback(entry);
-            }
-        }
-    }
-    _updateScores(model, recursive) {
-        const notebookInfo = this._notebookInfoResolver?.(model.uri);
-        // use the uri (scheme, pattern) of the notebook info iff we have one
-        // otherwise it's the model's/document's uri
-        const candidate = notebookInfo
-            ? new MatchCandidate(model.uri, model.getLanguageId(), notebookInfo.uri, notebookInfo.type, recursive)
-            : new MatchCandidate(model.uri, model.getLanguageId(), undefined, undefined, recursive);
-        if (this._lastCandidate?.equals(candidate)) {
-            // nothing has changed
-            return;
-        }
-        this._lastCandidate = candidate;
-        for (const entry of this._entries) {
-            entry._score = score(entry.selector, candidate.uri, candidate.languageId, shouldSynchronizeModel(model), candidate.notebookUri, candidate.notebookType);
-            if (isExclusive(entry.selector) && entry._score > 0) {
-                if (recursive) {
-                    entry._score = 0;
-                }
-                else {
-                    // support for one exclusive selector that overwrites
-                    // any other selector
-                    for (const entry of this._entries) {
-                        entry._score = 0;
-                    }
-                    entry._score = 1000;
-                    break;
-                }
-            }
-        }
-        // needs sorting
-        this._entries.sort(LanguageFeatureRegistry._compareByScoreAndTime);
-    }
-    static _compareByScoreAndTime(a, b) {
-        if (a._score < b._score) {
-            return 1;
-        }
-        else if (a._score > b._score) {
-            return -1;
-        }
-        // De-prioritize built-in providers
-        if (isBuiltinSelector(a.selector) && !isBuiltinSelector(b.selector)) {
-            return 1;
-        }
-        else if (!isBuiltinSelector(a.selector) && isBuiltinSelector(b.selector)) {
-            return -1;
-        }
-        if (a._time < b._time) {
-            return 1;
-        }
-        else if (a._time > b._time) {
-            return -1;
-        }
-        else {
-            return 0;
-        }
-    }
-}
-function isBuiltinSelector(selector) {
-    if (typeof selector === 'string') {
-        return false;
-    }
-    if (Array.isArray(selector)) {
-        return selector.some(isBuiltinSelector);
-    }
-    return Boolean(selector.isBuiltin);
-}
-
-export { LanguageFeatureRegistry };

package/dist/workers/editor/common/languageFeatures.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 ILanguageFeaturesService = createDecorator('ILanguageFeaturesService');
-
-export { ILanguageFeaturesService };

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

@@ -1,47 +0,0 @@
-import { LanguageFeatureRegistry } from '../languageFeatureRegistry.js';
-import { ILanguageFeaturesService } from './languageFeatures.js';
-import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class LanguageFeaturesService {
-    constructor() {
-        this.referenceProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.renameProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.newSymbolNamesProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.codeActionProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.definitionProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.typeDefinitionProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.declarationProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.implementationProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentSymbolProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.inlayHintsProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.colorProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.codeLensProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentFormattingEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentRangeFormattingEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.onTypeFormattingEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.signatureHelpProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.hoverProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentHighlightProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.multiDocumentHighlightProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.selectionRangeProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.foldingRangeProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.linkProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.inlineCompletionsProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.completionProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.linkedEditingRangeProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentRangeSemanticTokensProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentSemanticTokensProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentDropEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
-        this.documentPasteEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
-    }
-    _score(uri) {
-        return this._notebookTypeResolver?.(uri);
-    }
-}
-registerSingleton(ILanguageFeaturesService, LanguageFeaturesService, 1 /* InstantiationType.Delayed */);
-
-export { LanguageFeaturesService };

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

@@ -1,112 +0,0 @@
-import { match } from '../../base/common/glob.js';
-import { normalize } from '../../base/common/path.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function score(selector, candidateUri, candidateLanguage, candidateIsSynchronized, candidateNotebookUri, candidateNotebookType) {
-    if (Array.isArray(selector)) {
-        // array -> take max individual value
-        let ret = 0;
-        for (const filter of selector) {
-            const value = score(filter, candidateUri, candidateLanguage, candidateIsSynchronized, candidateNotebookUri, candidateNotebookType);
-            if (value === 10) {
-                return value; // already at the highest
-            }
-            if (value > ret) {
-                ret = value;
-            }
-        }
-        return ret;
-    }
-    else if (typeof selector === 'string') {
-        if (!candidateIsSynchronized) {
-            return 0;
-        }
-        // short-hand notion, desugars to
-        // 'fooLang' -> { language: 'fooLang'}
-        // '*' -> { language: '*' }
-        if (selector === '*') {
-            return 5;
-        }
-        else if (selector === candidateLanguage) {
-            return 10;
-        }
-        else {
-            return 0;
-        }
-    }
-    else if (selector) {
-        // filter -> select accordingly, use defaults for scheme
-        const { language, pattern, scheme, hasAccessToAllModels, notebookType } = selector; // TODO: microsoft/TypeScript#42768
-        if (!candidateIsSynchronized && !hasAccessToAllModels) {
-            return 0;
-        }
-        // selector targets a notebook -> use the notebook uri instead
-        // of the "normal" document uri.
-        if (notebookType && candidateNotebookUri) {
-            candidateUri = candidateNotebookUri;
-        }
-        let ret = 0;
-        if (scheme) {
-            if (scheme === candidateUri.scheme) {
-                ret = 10;
-            }
-            else if (scheme === '*') {
-                ret = 5;
-            }
-            else {
-                return 0;
-            }
-        }
-        if (language) {
-            if (language === candidateLanguage) {
-                ret = 10;
-            }
-            else if (language === '*') {
-                ret = Math.max(ret, 5);
-            }
-            else {
-                return 0;
-            }
-        }
-        if (notebookType) {
-            if (notebookType === candidateNotebookType) {
-                ret = 10;
-            }
-            else if (notebookType === '*' && candidateNotebookType !== undefined) {
-                ret = Math.max(ret, 5);
-            }
-            else {
-                return 0;
-            }
-        }
-        if (pattern) {
-            let normalizedPattern;
-            if (typeof pattern === 'string') {
-                normalizedPattern = pattern;
-            }
-            else {
-                // Since this pattern has a `base` property, we need
-                // to normalize this path first before passing it on
-                // because we will compare it against `Uri.fsPath`
-                // which uses platform specific separators.
-                // Refs: https://github.com/microsoft/vscode/issues/99938
-                normalizedPattern = { ...pattern, base: normalize(pattern.base) };
-            }
-            if (normalizedPattern === candidateUri.fsPath || match(normalizedPattern, candidateUri.fsPath)) {
-                ret = 10;
-            }
-            else {
-                return 0;
-            }
-        }
-        return ret;
-    }
-    else {
-        return 0;
-    }
-}
-
-export { score };

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

@@ -1,92 +0,0 @@
-import { Emitter, Event } from '../../../base/common/event.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { LanguagesRegistry } from './languagesRegistry.js';
-import { TokenizationRegistry } from '../languages.js';
-import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
-import '../../../base/common/observableInternal/index.js';
-import { observableFromEvent } from '../../../base/common/observableInternal/observables/observableFromEvent.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class LanguageService extends Disposable {
-    static { this.instanceCount = 0; }
-    constructor(warnOnOverwrite = false) {
-        super();
-        this._onDidRequestBasicLanguageFeatures = this._register(new Emitter());
-        this.onDidRequestBasicLanguageFeatures = this._onDidRequestBasicLanguageFeatures.event;
-        this._onDidRequestRichLanguageFeatures = this._register(new Emitter());
-        this.onDidRequestRichLanguageFeatures = this._onDidRequestRichLanguageFeatures.event;
-        this._onDidChange = this._register(new Emitter({ leakWarningThreshold: 200 /* https://github.com/microsoft/vscode/issues/119968 */ }));
-        this.onDidChange = this._onDidChange.event;
-        this._requestedBasicLanguages = new Set();
-        this._requestedRichLanguages = new Set();
-        LanguageService.instanceCount++;
-        this._registry = this._register(new LanguagesRegistry(true, warnOnOverwrite));
-        this.languageIdCodec = this._registry.languageIdCodec;
-        this._register(this._registry.onDidChange(() => this._onDidChange.fire()));
-    }
-    dispose() {
-        LanguageService.instanceCount--;
-        super.dispose();
-    }
-    isRegisteredLanguageId(languageId) {
-        return this._registry.isRegisteredLanguageId(languageId);
-    }
-    getLanguageIdByLanguageName(languageName) {
-        return this._registry.getLanguageIdByLanguageName(languageName);
-    }
-    getLanguageIdByMimeType(mimeType) {
-        return this._registry.getLanguageIdByMimeType(mimeType);
-    }
-    guessLanguageIdByFilepathOrFirstLine(resource, firstLine) {
-        const languageIds = this._registry.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
-        return languageIds.at(0) ?? null;
-    }
-    createById(languageId) {
-        return new LanguageSelection(this.onDidChange, () => {
-            return this._createAndGetLanguageIdentifier(languageId);
-        });
-    }
-    createByFilepathOrFirstLine(resource, firstLine) {
-        return new LanguageSelection(this.onDidChange, () => {
-            const languageId = this.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
-            return this._createAndGetLanguageIdentifier(languageId);
-        });
-    }
-    _createAndGetLanguageIdentifier(languageId) {
-        if (!languageId || !this.isRegisteredLanguageId(languageId)) {
-            // Fall back to plain text if language is unknown
-            languageId = PLAINTEXT_LANGUAGE_ID;
-        }
-        return languageId;
-    }
-    requestBasicLanguageFeatures(languageId) {
-        if (!this._requestedBasicLanguages.has(languageId)) {
-            this._requestedBasicLanguages.add(languageId);
-            this._onDidRequestBasicLanguageFeatures.fire(languageId);
-        }
-    }
-    requestRichLanguageFeatures(languageId) {
-        if (!this._requestedRichLanguages.has(languageId)) {
-            this._requestedRichLanguages.add(languageId);
-            // Ensure basic features are requested
-            this.requestBasicLanguageFeatures(languageId);
-            // Ensure tokenizers are created
-            TokenizationRegistry.getOrCreate(languageId);
-            this._onDidRequestRichLanguageFeatures.fire(languageId);
-        }
-    }
-}
-class LanguageSelection {
-    constructor(onDidChangeLanguages, selector) {
-        this._value = observableFromEvent(this, onDidChangeLanguages, () => selector());
-        this.onDidChange = Event.fromObservable(this._value);
-    }
-    get languageId() {
-        return this._value.get();
-    }
-}
-
-export { LanguageService };