@umbraco-cms/backoffice 16.1.1 → 16.2.0-rc

package/dist-cms/monaco-editor/vs/editor/common/services/languagesRegistry.js

@@ -1,236 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Emitter } from '../../../base/common/event.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { regExpLeadsToEndlessLoop } from '../../../base/common/strings.js';
-import { clearPlatformLanguageAssociations, getLanguageIds, registerPlatformLanguageAssociation } from './languagesAssociations.js';
-import { ModesRegistry, PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
-import { Extensions } from '../../../platform/configuration/common/configurationRegistry.js';
-import { Registry } from '../../../platform/registry/common/platform.js';
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-const NULL_LANGUAGE_ID = 'vs.editor.nullLanguage';
-export class LanguageIdCodec {
-    constructor() {
-        this._languageIdToLanguage = [];
-        this._languageToLanguageId = new Map();
-        this._register(NULL_LANGUAGE_ID, 0 /* LanguageId.Null */);
-        this._register(PLAINTEXT_LANGUAGE_ID, 1 /* LanguageId.PlainText */);
-        this._nextLanguageId = 2;
-    }
-    _register(language, languageId) {
-        this._languageIdToLanguage[languageId] = language;
-        this._languageToLanguageId.set(language, languageId);
-    }
-    register(language) {
-        if (this._languageToLanguageId.has(language)) {
-            return;
-        }
-        const languageId = this._nextLanguageId++;
-        this._register(language, languageId);
-    }
-    encodeLanguageId(languageId) {
-        return this._languageToLanguageId.get(languageId) || 0 /* LanguageId.Null */;
-    }
-    decodeLanguageId(languageId) {
-        return this._languageIdToLanguage[languageId] || NULL_LANGUAGE_ID;
-    }
-}
-export class LanguagesRegistry extends Disposable {
-    static { this.instanceCount = 0; }
-    constructor(useModesRegistry = true, warnOnOverwrite = false) {
-        super();
-        this._onDidChange = this._register(new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        LanguagesRegistry.instanceCount++;
-        this._warnOnOverwrite = warnOnOverwrite;
-        this.languageIdCodec = new LanguageIdCodec();
-        this._dynamicLanguages = [];
-        this._languages = {};
-        this._mimeTypesMap = {};
-        this._nameMap = {};
-        this._lowercaseNameMap = {};
-        if (useModesRegistry) {
-            this._initializeFromRegistry();
-            this._register(ModesRegistry.onDidChangeLanguages((m) => {
-                this._initializeFromRegistry();
-            }));
-        }
-    }
-    dispose() {
-        LanguagesRegistry.instanceCount--;
-        super.dispose();
-    }
-    _initializeFromRegistry() {
-        this._languages = {};
-        this._mimeTypesMap = {};
-        this._nameMap = {};
-        this._lowercaseNameMap = {};
-        clearPlatformLanguageAssociations();
-        const desc = [].concat(ModesRegistry.getLanguages()).concat(this._dynamicLanguages);
-        this._registerLanguages(desc);
-    }
-    _registerLanguages(desc) {
-        for (const d of desc) {
-            this._registerLanguage(d);
-        }
-        // Rebuild fast path maps
-        this._mimeTypesMap = {};
-        this._nameMap = {};
-        this._lowercaseNameMap = {};
-        Object.keys(this._languages).forEach((langId) => {
-            const language = this._languages[langId];
-            if (language.name) {
-                this._nameMap[language.name] = language.identifier;
-            }
-            language.aliases.forEach((alias) => {
-                this._lowercaseNameMap[alias.toLowerCase()] = language.identifier;
-            });
-            language.mimetypes.forEach((mimetype) => {
-                this._mimeTypesMap[mimetype] = language.identifier;
-            });
-        });
-        Registry.as(Extensions.Configuration).registerOverrideIdentifiers(this.getRegisteredLanguageIds());
-        this._onDidChange.fire();
-    }
-    _registerLanguage(lang) {
-        const langId = lang.id;
-        let resolvedLanguage;
-        if (hasOwnProperty.call(this._languages, langId)) {
-            resolvedLanguage = this._languages[langId];
-        }
-        else {
-            this.languageIdCodec.register(langId);
-            resolvedLanguage = {
-                identifier: langId,
-                name: null,
-                mimetypes: [],
-                aliases: [],
-                extensions: [],
-                filenames: [],
-                configurationFiles: [],
-                icons: []
-            };
-            this._languages[langId] = resolvedLanguage;
-        }
-        this._mergeLanguage(resolvedLanguage, lang);
-    }
-    _mergeLanguage(resolvedLanguage, lang) {
-        const langId = lang.id;
-        let primaryMime = null;
-        if (Array.isArray(lang.mimetypes) && lang.mimetypes.length > 0) {
-            resolvedLanguage.mimetypes.push(...lang.mimetypes);
-            primaryMime = lang.mimetypes[0];
-        }
-        if (!primaryMime) {
-            primaryMime = `text/x-${langId}`;
-            resolvedLanguage.mimetypes.push(primaryMime);
-        }
-        if (Array.isArray(lang.extensions)) {
-            if (lang.configuration) {
-                // insert first as this appears to be the 'primary' language definition
-                resolvedLanguage.extensions = lang.extensions.concat(resolvedLanguage.extensions);
-            }
-            else {
-                resolvedLanguage.extensions = resolvedLanguage.extensions.concat(lang.extensions);
-            }
-            for (const extension of lang.extensions) {
-                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, extension: extension }, this._warnOnOverwrite);
-            }
-        }
-        if (Array.isArray(lang.filenames)) {
-            for (const filename of lang.filenames) {
-                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, filename: filename }, this._warnOnOverwrite);
-                resolvedLanguage.filenames.push(filename);
-            }
-        }
-        if (Array.isArray(lang.filenamePatterns)) {
-            for (const filenamePattern of lang.filenamePatterns) {
-                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, filepattern: filenamePattern }, this._warnOnOverwrite);
-            }
-        }
-        if (typeof lang.firstLine === 'string' && lang.firstLine.length > 0) {
-            let firstLineRegexStr = lang.firstLine;
-            if (firstLineRegexStr.charAt(0) !== '^') {
-                firstLineRegexStr = '^' + firstLineRegexStr;
-            }
-            try {
-                const firstLineRegex = new RegExp(firstLineRegexStr);
-                if (!regExpLeadsToEndlessLoop(firstLineRegex)) {
-                    registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, firstline: firstLineRegex }, this._warnOnOverwrite);
-                }
-            }
-            catch (err) {
-                // Most likely, the regex was bad
-                console.warn(`[${lang.id}]: Invalid regular expression \`${firstLineRegexStr}\`: `, err);
-            }
-        }
-        resolvedLanguage.aliases.push(langId);
-        let langAliases = null;
-        if (typeof lang.aliases !== 'undefined' && Array.isArray(lang.aliases)) {
-            if (lang.aliases.length === 0) {
-                // signal that this language should not get a name
-                langAliases = [null];
-            }
-            else {
-                langAliases = lang.aliases;
-            }
-        }
-        if (langAliases !== null) {
-            for (const langAlias of langAliases) {
-                if (!langAlias || langAlias.length === 0) {
-                    continue;
-                }
-                resolvedLanguage.aliases.push(langAlias);
-            }
-        }
-        const containsAliases = (langAliases !== null && langAliases.length > 0);
-        if (containsAliases && langAliases[0] === null) {
-            // signal that this language should not get a name
-        }
-        else {
-            const bestName = (containsAliases ? langAliases[0] : null) || langId;
-            if (containsAliases || !resolvedLanguage.name) {
-                resolvedLanguage.name = bestName;
-            }
-        }
-        if (lang.configuration) {
-            resolvedLanguage.configurationFiles.push(lang.configuration);
-        }
-        if (lang.icon) {
-            resolvedLanguage.icons.push(lang.icon);
-        }
-    }
-    isRegisteredLanguageId(languageId) {
-        if (!languageId) {
-            return false;
-        }
-        return hasOwnProperty.call(this._languages, languageId);
-    }
-    getRegisteredLanguageIds() {
-        return Object.keys(this._languages);
-    }
-    getLanguageIdByLanguageName(languageName) {
-        const languageNameLower = languageName.toLowerCase();
-        if (!hasOwnProperty.call(this._lowercaseNameMap, languageNameLower)) {
-            return null;
-        }
-        return this._lowercaseNameMap[languageNameLower];
-    }
-    getLanguageIdByMimeType(mimeType) {
-        if (!mimeType) {
-            return null;
-        }
-        if (hasOwnProperty.call(this._mimeTypesMap, mimeType)) {
-            return this._mimeTypesMap[mimeType];
-        }
-        return null;
-    }
-    guessLanguageIdByFilepathOrFirstLine(resource, firstLine) {
-        if (!resource && !firstLine) {
-            return [];
-        }
-        return getLanguageIds(resource, firstLine);
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/services/markerDecorations.js

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

package/dist-cms/monaco-editor/vs/editor/common/services/markerDecorationsService.js

@@ -1,227 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var __decorate = (this && this.__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 = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-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 { overviewRulerWarning, overviewRulerInfo, overviewRulerError } 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 { minimapInfo, minimapWarning, minimapError } from '../../../platform/theme/common/colorRegistry.js';
-import { BidirectionalMap, ResourceMap } from '../../../base/common/map.js';
-import { diffSets } from '../../../base/common/collections.js';
-let MarkerDecorationsService = class MarkerDecorationsService extends Disposable {
-    constructor(modelService, _markerService) {
-        super();
-        this._markerService = _markerService;
-        this._onDidChangeMarker = this._register(new Emitter());
-        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
-        const markers = this._markerService.read({ resource: markerDecorations.model.uri, take: 500 });
-        if (markerDecorations.update(markers)) {
-            this._onDidChangeMarker.fire(markerDecorations.model);
-        }
-    }
-};
-MarkerDecorationsService = __decorate([
-    __param(0, IModelService),
-    __param(1, IMarkerService)
-], MarkerDecorationsService);
-export { 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;
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/services/model.js

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