monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,413 +0,0 @@
-import { Emitter } from '../../../base/common/event.js';
-import { StringSHA1 } from '../../../base/common/hash.js';
-import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { Schemas } from '../../../base/common/network.js';
-import { equals } from '../../../base/common/objects.js';
-import { OS, isLinux, isMacintosh } from '../../../base/common/platform.js';
-import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
-import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
-import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.js';
-import { clampedInt } from '../config/editorOptions.js';
-import { EDITOR_MODEL_DEFAULTS } from '../core/misc/textModelDefaults.js';
-import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
-import { isEditStackElement } from '../model/editStack.js';
-import { TextModel } from '../model/textModel.js';
-import { ITextResourcePropertiesService } from './textResourceConfiguration.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); }
-};
-var ModelService_1;
-function MODEL_ID(resource) {
-    return resource.toString();
-}
-class ModelData {
-    constructor(model, onWillDispose, onDidChangeLanguage) {
-        this.model = model;
-        this._modelEventListeners = new DisposableStore();
-        this.model = model;
-        this._modelEventListeners.add(model.onWillDispose(() => onWillDispose(model)));
-        this._modelEventListeners.add(model.onDidChangeLanguage((e) => onDidChangeLanguage(model, e)));
-    }
-    dispose() {
-        this._modelEventListeners.dispose();
-    }
-}
-const DEFAULT_EOL = (isLinux || isMacintosh) ? 1 /* DefaultEndOfLine.LF */ : 2 /* DefaultEndOfLine.CRLF */;
-class DisposedModelInfo {
-    constructor(uri, initialUndoRedoSnapshot, time, sharesUndoRedoStack, heapSize, sha1, versionId, alternativeVersionId) {
-        this.uri = uri;
-        this.initialUndoRedoSnapshot = initialUndoRedoSnapshot;
-        this.time = time;
-        this.sharesUndoRedoStack = sharesUndoRedoStack;
-        this.heapSize = heapSize;
-        this.sha1 = sha1;
-        this.versionId = versionId;
-        this.alternativeVersionId = alternativeVersionId;
-    }
-}
-let ModelService = class ModelService extends Disposable {
-    static { ModelService_1 = this; }
-    static { this.MAX_MEMORY_FOR_CLOSED_FILES_UNDO_STACK = 20 * 1024 * 1024; }
-    constructor(_configurationService, _resourcePropertiesService, _undoRedoService, _instantiationService) {
-        super();
-        this._configurationService = _configurationService;
-        this._resourcePropertiesService = _resourcePropertiesService;
-        this._undoRedoService = _undoRedoService;
-        this._instantiationService = _instantiationService;
-        this._onModelAdded = this._register(new Emitter());
-        this.onModelAdded = this._onModelAdded.event;
-        this._onModelRemoved = this._register(new Emitter());
-        this.onModelRemoved = this._onModelRemoved.event;
-        this._onModelModeChanged = this._register(new Emitter());
-        this.onModelLanguageChanged = this._onModelModeChanged.event;
-        this._modelCreationOptionsByLanguageAndResource = Object.create(null);
-        this._models = {};
-        this._disposedModels = new Map();
-        this._disposedModelsHeapSize = 0;
-        this._register(this._configurationService.onDidChangeConfiguration(e => this._updateModelOptions(e)));
-        this._updateModelOptions(undefined);
-    }
-    static _readModelOptions(config, isForSimpleWidget) {
-        let tabSize = EDITOR_MODEL_DEFAULTS.tabSize;
-        if (config.editor && typeof config.editor.tabSize !== 'undefined') {
-            tabSize = clampedInt(config.editor.tabSize, EDITOR_MODEL_DEFAULTS.tabSize, 1, 100);
-        }
-        let indentSize = 'tabSize';
-        if (config.editor && typeof config.editor.indentSize !== 'undefined' && config.editor.indentSize !== 'tabSize') {
-            indentSize = clampedInt(config.editor.indentSize, 'tabSize', 1, 100);
-        }
-        let insertSpaces = EDITOR_MODEL_DEFAULTS.insertSpaces;
-        if (config.editor && typeof config.editor.insertSpaces !== 'undefined') {
-            insertSpaces = (config.editor.insertSpaces === 'false' ? false : Boolean(config.editor.insertSpaces));
-        }
-        let newDefaultEOL = DEFAULT_EOL;
-        const eol = config.eol;
-        if (eol === '\r\n') {
-            newDefaultEOL = 2 /* DefaultEndOfLine.CRLF */;
-        }
-        else if (eol === '\n') {
-            newDefaultEOL = 1 /* DefaultEndOfLine.LF */;
-        }
-        let trimAutoWhitespace = EDITOR_MODEL_DEFAULTS.trimAutoWhitespace;
-        if (config.editor && typeof config.editor.trimAutoWhitespace !== 'undefined') {
-            trimAutoWhitespace = (config.editor.trimAutoWhitespace === 'false' ? false : Boolean(config.editor.trimAutoWhitespace));
-        }
-        let detectIndentation = EDITOR_MODEL_DEFAULTS.detectIndentation;
-        if (config.editor && typeof config.editor.detectIndentation !== 'undefined') {
-            detectIndentation = (config.editor.detectIndentation === 'false' ? false : Boolean(config.editor.detectIndentation));
-        }
-        let largeFileOptimizations = EDITOR_MODEL_DEFAULTS.largeFileOptimizations;
-        if (config.editor && typeof config.editor.largeFileOptimizations !== 'undefined') {
-            largeFileOptimizations = (config.editor.largeFileOptimizations === 'false' ? false : Boolean(config.editor.largeFileOptimizations));
-        }
-        let bracketPairColorizationOptions = EDITOR_MODEL_DEFAULTS.bracketPairColorizationOptions;
-        if (config.editor?.bracketPairColorization && typeof config.editor.bracketPairColorization === 'object') {
-            const bpConfig = config.editor.bracketPairColorization;
-            bracketPairColorizationOptions = {
-                enabled: !!bpConfig.enabled,
-                independentColorPoolPerBracketType: !!bpConfig.independentColorPoolPerBracketType
-            };
-        }
-        return {
-            isForSimpleWidget: isForSimpleWidget,
-            tabSize: tabSize,
-            indentSize: indentSize,
-            insertSpaces: insertSpaces,
-            detectIndentation: detectIndentation,
-            defaultEOL: newDefaultEOL,
-            trimAutoWhitespace: trimAutoWhitespace,
-            largeFileOptimizations: largeFileOptimizations,
-            bracketPairColorizationOptions
-        };
-    }
-    _getEOL(resource, language) {
-        if (resource) {
-            return this._resourcePropertiesService.getEOL(resource, language);
-        }
-        const eol = this._configurationService.getValue('files.eol', { overrideIdentifier: language });
-        if (eol && typeof eol === 'string' && eol !== 'auto') {
-            return eol;
-        }
-        return OS === 3 /* platform.OperatingSystem.Linux */ || OS === 2 /* platform.OperatingSystem.Macintosh */ ? '\n' : '\r\n';
-    }
-    _shouldRestoreUndoStack() {
-        const result = this._configurationService.getValue('files.restoreUndoStack');
-        if (typeof result === 'boolean') {
-            return result;
-        }
-        return true;
-    }
-    getCreationOptions(languageIdOrSelection, resource, isForSimpleWidget) {
-        const language = (typeof languageIdOrSelection === 'string' ? languageIdOrSelection : languageIdOrSelection.languageId);
-        let creationOptions = this._modelCreationOptionsByLanguageAndResource[language + resource];
-        if (!creationOptions) {
-            const editor = this._configurationService.getValue('editor', { overrideIdentifier: language, resource });
-            const eol = this._getEOL(resource, language);
-            creationOptions = ModelService_1._readModelOptions({ editor, eol }, isForSimpleWidget);
-            this._modelCreationOptionsByLanguageAndResource[language + resource] = creationOptions;
-        }
-        return creationOptions;
-    }
-    _updateModelOptions(e) {
-        const oldOptionsByLanguageAndResource = this._modelCreationOptionsByLanguageAndResource;
-        this._modelCreationOptionsByLanguageAndResource = Object.create(null);
-        // Update options on all models
-        const keys = Object.keys(this._models);
-        for (let i = 0, len = keys.length; i < len; i++) {
-            const modelId = keys[i];
-            const modelData = this._models[modelId];
-            const language = modelData.model.getLanguageId();
-            const uri = modelData.model.uri;
-            if (e && !e.affectsConfiguration('editor', { overrideIdentifier: language, resource: uri }) && !e.affectsConfiguration('files.eol', { overrideIdentifier: language, resource: uri })) {
-                continue; // perf: skip if this model is not affected by configuration change
-            }
-            const oldOptions = oldOptionsByLanguageAndResource[language + uri];
-            const newOptions = this.getCreationOptions(language, uri, modelData.model.isForSimpleWidget);
-            ModelService_1._setModelOptionsForModel(modelData.model, newOptions, oldOptions);
-        }
-    }
-    static _setModelOptionsForModel(model, newOptions, currentOptions) {
-        if (currentOptions && currentOptions.defaultEOL !== newOptions.defaultEOL && model.getLineCount() === 1) {
-            model.setEOL(newOptions.defaultEOL === 1 /* DefaultEndOfLine.LF */ ? 0 /* EndOfLineSequence.LF */ : 1 /* EndOfLineSequence.CRLF */);
-        }
-        if (currentOptions
-            && (currentOptions.detectIndentation === newOptions.detectIndentation)
-            && (currentOptions.insertSpaces === newOptions.insertSpaces)
-            && (currentOptions.tabSize === newOptions.tabSize)
-            && (currentOptions.indentSize === newOptions.indentSize)
-            && (currentOptions.trimAutoWhitespace === newOptions.trimAutoWhitespace)
-            && equals(currentOptions.bracketPairColorizationOptions, newOptions.bracketPairColorizationOptions)) {
-            // Same indent opts, no need to touch the model
-            return;
-        }
-        if (newOptions.detectIndentation) {
-            model.detectIndentation(newOptions.insertSpaces, newOptions.tabSize);
-            model.updateOptions({
-                trimAutoWhitespace: newOptions.trimAutoWhitespace,
-                bracketColorizationOptions: newOptions.bracketPairColorizationOptions
-            });
-        }
-        else {
-            model.updateOptions({
-                insertSpaces: newOptions.insertSpaces,
-                tabSize: newOptions.tabSize,
-                indentSize: newOptions.indentSize,
-                trimAutoWhitespace: newOptions.trimAutoWhitespace,
-                bracketColorizationOptions: newOptions.bracketPairColorizationOptions
-            });
-        }
-    }
-    // --- begin IModelService
-    _insertDisposedModel(disposedModelData) {
-        this._disposedModels.set(MODEL_ID(disposedModelData.uri), disposedModelData);
-        this._disposedModelsHeapSize += disposedModelData.heapSize;
-    }
-    _removeDisposedModel(resource) {
-        const disposedModelData = this._disposedModels.get(MODEL_ID(resource));
-        if (disposedModelData) {
-            this._disposedModelsHeapSize -= disposedModelData.heapSize;
-        }
-        this._disposedModels.delete(MODEL_ID(resource));
-        return disposedModelData;
-    }
-    _ensureDisposedModelsHeapSize(maxModelsHeapSize) {
-        if (this._disposedModelsHeapSize > maxModelsHeapSize) {
-            // we must remove some old undo stack elements to free up some memory
-            const disposedModels = [];
-            this._disposedModels.forEach(entry => {
-                if (!entry.sharesUndoRedoStack) {
-                    disposedModels.push(entry);
-                }
-            });
-            disposedModels.sort((a, b) => a.time - b.time);
-            while (disposedModels.length > 0 && this._disposedModelsHeapSize > maxModelsHeapSize) {
-                const disposedModel = disposedModels.shift();
-                this._removeDisposedModel(disposedModel.uri);
-                if (disposedModel.initialUndoRedoSnapshot !== null) {
-                    this._undoRedoService.restoreSnapshot(disposedModel.initialUndoRedoSnapshot);
-                }
-            }
-        }
-    }
-    _createModelData(value, languageIdOrSelection, resource, isForSimpleWidget) {
-        // create & save the model
-        const options = this.getCreationOptions(languageIdOrSelection, resource, isForSimpleWidget);
-        const model = this._instantiationService.createInstance(TextModel, value, languageIdOrSelection, options, resource);
-        if (resource && this._disposedModels.has(MODEL_ID(resource))) {
-            const disposedModelData = this._removeDisposedModel(resource);
-            const elements = this._undoRedoService.getElements(resource);
-            const sha1Computer = this._getSHA1Computer();
-            const sha1IsEqual = (sha1Computer.canComputeSHA1(model)
-                ? sha1Computer.computeSHA1(model) === disposedModelData.sha1
-                : false);
-            if (sha1IsEqual || disposedModelData.sharesUndoRedoStack) {
-                for (const element of elements.past) {
-                    if (isEditStackElement(element) && element.matchesResource(resource)) {
-                        element.setModel(model);
-                    }
-                }
-                for (const element of elements.future) {
-                    if (isEditStackElement(element) && element.matchesResource(resource)) {
-                        element.setModel(model);
-                    }
-                }
-                this._undoRedoService.setElementsValidFlag(resource, true, (element) => (isEditStackElement(element) && element.matchesResource(resource)));
-                if (sha1IsEqual) {
-                    model._overwriteVersionId(disposedModelData.versionId);
-                    model._overwriteAlternativeVersionId(disposedModelData.alternativeVersionId);
-                    model._overwriteInitialUndoRedoSnapshot(disposedModelData.initialUndoRedoSnapshot);
-                }
-            }
-            else {
-                if (disposedModelData.initialUndoRedoSnapshot !== null) {
-                    this._undoRedoService.restoreSnapshot(disposedModelData.initialUndoRedoSnapshot);
-                }
-            }
-        }
-        const modelId = MODEL_ID(model.uri);
-        if (this._models[modelId]) {
-            // There already exists a model with this id => this is a programmer error
-            throw new Error('ModelService: Cannot add model because it already exists!');
-        }
-        const modelData = new ModelData(model, (model) => this._onWillDispose(model), (model, e) => this._onDidChangeLanguage(model, e));
-        this._models[modelId] = modelData;
-        return modelData;
-    }
-    createModel(value, languageSelection, resource, isForSimpleWidget = false) {
-        let modelData;
-        if (languageSelection) {
-            modelData = this._createModelData(value, languageSelection, resource, isForSimpleWidget);
-        }
-        else {
-            modelData = this._createModelData(value, PLAINTEXT_LANGUAGE_ID, resource, isForSimpleWidget);
-        }
-        this._onModelAdded.fire(modelData.model);
-        return modelData.model;
-    }
-    getModels() {
-        const ret = [];
-        const keys = Object.keys(this._models);
-        for (let i = 0, len = keys.length; i < len; i++) {
-            const modelId = keys[i];
-            ret.push(this._models[modelId].model);
-        }
-        return ret;
-    }
-    getModel(resource) {
-        const modelId = MODEL_ID(resource);
-        const modelData = this._models[modelId];
-        if (!modelData) {
-            return null;
-        }
-        return modelData.model;
-    }
-    // --- end IModelService
-    _schemaShouldMaintainUndoRedoElements(resource) {
-        return (resource.scheme === Schemas.file
-            || resource.scheme === Schemas.vscodeRemote
-            || resource.scheme === Schemas.vscodeUserData
-            || resource.scheme === Schemas.vscodeNotebookCell
-            || resource.scheme === 'fake-fs' // for tests
-        );
-    }
-    _onWillDispose(model) {
-        const modelId = MODEL_ID(model.uri);
-        const modelData = this._models[modelId];
-        const sharesUndoRedoStack = (this._undoRedoService.getUriComparisonKey(model.uri) !== model.uri.toString());
-        let maintainUndoRedoStack = false;
-        let heapSize = 0;
-        if (sharesUndoRedoStack || (this._shouldRestoreUndoStack() && this._schemaShouldMaintainUndoRedoElements(model.uri))) {
-            const elements = this._undoRedoService.getElements(model.uri);
-            if (elements.past.length > 0 || elements.future.length > 0) {
-                for (const element of elements.past) {
-                    if (isEditStackElement(element) && element.matchesResource(model.uri)) {
-                        maintainUndoRedoStack = true;
-                        heapSize += element.heapSize(model.uri);
-                        element.setModel(model.uri); // remove reference from text buffer instance
-                    }
-                }
-                for (const element of elements.future) {
-                    if (isEditStackElement(element) && element.matchesResource(model.uri)) {
-                        maintainUndoRedoStack = true;
-                        heapSize += element.heapSize(model.uri);
-                        element.setModel(model.uri); // remove reference from text buffer instance
-                    }
-                }
-            }
-        }
-        const maxMemory = ModelService_1.MAX_MEMORY_FOR_CLOSED_FILES_UNDO_STACK;
-        const sha1Computer = this._getSHA1Computer();
-        if (!maintainUndoRedoStack) {
-            if (!sharesUndoRedoStack) {
-                const initialUndoRedoSnapshot = modelData.model.getInitialUndoRedoSnapshot();
-                if (initialUndoRedoSnapshot !== null) {
-                    this._undoRedoService.restoreSnapshot(initialUndoRedoSnapshot);
-                }
-            }
-        }
-        else if (!sharesUndoRedoStack && (heapSize > maxMemory || !sha1Computer.canComputeSHA1(model))) {
-            // the undo stack for this file would never fit in the configured memory or the file is very large, so don't bother with it.
-            const initialUndoRedoSnapshot = modelData.model.getInitialUndoRedoSnapshot();
-            if (initialUndoRedoSnapshot !== null) {
-                this._undoRedoService.restoreSnapshot(initialUndoRedoSnapshot);
-            }
-        }
-        else {
-            this._ensureDisposedModelsHeapSize(maxMemory - heapSize);
-            // We only invalidate the elements, but they remain in the undo-redo service.
-            this._undoRedoService.setElementsValidFlag(model.uri, false, (element) => (isEditStackElement(element) && element.matchesResource(model.uri)));
-            this._insertDisposedModel(new DisposedModelInfo(model.uri, modelData.model.getInitialUndoRedoSnapshot(), Date.now(), sharesUndoRedoStack, heapSize, sha1Computer.computeSHA1(model), model.getVersionId(), model.getAlternativeVersionId()));
-        }
-        delete this._models[modelId];
-        modelData.dispose();
-        // clean up cache
-        delete this._modelCreationOptionsByLanguageAndResource[model.getLanguageId() + model.uri];
-        this._onModelRemoved.fire(model);
-    }
-    _onDidChangeLanguage(model, e) {
-        const oldLanguageId = e.oldLanguage;
-        const newLanguageId = model.getLanguageId();
-        const oldOptions = this.getCreationOptions(oldLanguageId, model.uri, model.isForSimpleWidget);
-        const newOptions = this.getCreationOptions(newLanguageId, model.uri, model.isForSimpleWidget);
-        ModelService_1._setModelOptionsForModel(model, newOptions, oldOptions);
-        this._onModelModeChanged.fire({ model, oldLanguageId: oldLanguageId });
-    }
-    _getSHA1Computer() {
-        return new DefaultModelSHA1Computer();
-    }
-};
-ModelService = ModelService_1 = __decorate([
-    __param(0, IConfigurationService),
-    __param(1, ITextResourcePropertiesService),
-    __param(2, IUndoRedoService),
-    __param(3, IInstantiationService)
-], ModelService);
-class DefaultModelSHA1Computer {
-    static { this.MAX_MODEL_SIZE = 10 * 1024 * 1024; } // takes 200ms to compute a sha1 on a 10MB model on a new machine
-    canComputeSHA1(model) {
-        return (model.getValueLength() <= DefaultModelSHA1Computer.MAX_MODEL_SIZE);
-    }
-    computeSHA1(model) {
-        // compute the sha1
-        const shaComputer = new StringSHA1();
-        const snapshot = model.createSnapshot();
-        let text;
-        while ((text = snapshot.read())) {
-            shaComputer.update(text);
-        }
-        return shaComputer.digest();
-    }
-}
-
-export { DefaultModelSHA1Computer, ModelService };

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

@@ -1,75 +0,0 @@
-import { localize } from '../../../nls.js';
-import { Emitter } from '../../../base/common/event.js';
-import { Registry } from '../../../platform/registry/common/platform.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { Mimes } from '../../../base/common/mime.js';
-import { Extensions as Extensions$1 } from '../../../platform/configuration/common/configurationRegistry.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-// Define extension point ids
-const Extensions = {
-    ModesRegistry: 'editor.modesRegistry'
-};
-class EditorModesRegistry extends Disposable {
-    constructor() {
-        super();
-        this._onDidChangeLanguages = this._register(new Emitter());
-        this.onDidChangeLanguages = this._onDidChangeLanguages.event;
-        this._languages = [];
-    }
-    registerLanguage(def) {
-        this._languages.push(def);
-        this._onDidChangeLanguages.fire(undefined);
-        return {
-            dispose: () => {
-                for (let i = 0, len = this._languages.length; i < len; i++) {
-                    if (this._languages[i] === def) {
-                        this._languages.splice(i, 1);
-                        return;
-                    }
-                }
-            }
-        };
-    }
-    getLanguages() {
-        return this._languages;
-    }
-}
-const ModesRegistry = new EditorModesRegistry();
-Registry.add(Extensions.ModesRegistry, ModesRegistry);
-const PLAINTEXT_LANGUAGE_ID = 'plaintext';
-const PLAINTEXT_EXTENSION = '.txt';
-ModesRegistry.registerLanguage({
-    id: PLAINTEXT_LANGUAGE_ID,
-    extensions: [PLAINTEXT_EXTENSION],
-    aliases: [localize(784, "Plain Text"), 'text'],
-    mimetypes: [Mimes.text]
-});
-Registry.as(Extensions$1.Configuration)
-    .registerDefaultConfigurations([{
-        overrides: {
-            '[plaintext]': {
-                'editor.unicodeHighlight.ambiguousCharacters': false,
-                'editor.unicodeHighlight.invisibleCharacters': false
-            },
-            // TODO: Below is a workaround for: https://github.com/microsoft/vscode/issues/240567
-            '[go]': {
-                'editor.insertSpaces': false
-            },
-            '[makefile]': {
-                'editor.insertSpaces': false,
-            },
-            '[shellscript]': {
-                'files.eol': '\n'
-            },
-            '[yaml]': {
-                'editor.insertSpaces': true,
-                'editor.tabSize': 2
-            }
-        }
-    }]);
-
-export { EditorModesRegistry, Extensions, ModesRegistry, PLAINTEXT_EXTENSION, PLAINTEXT_LANGUAGE_ID };