@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/common/editor/editorOptions.js

@@ -0,0 +1,48 @@
+import { isTextEditorViewState } from '../editor.js';
+function applyTextEditorOptions(options, editor, scrollType) {
+    let applied = false;
+    const viewState = massageEditorViewState(options);
+    if (isTextEditorViewState(viewState)) {
+        editor.restoreViewState(viewState);
+        applied = true;
+    }
+    if (options.selection) {
+        const range = {
+            startLineNumber: options.selection.startLineNumber,
+            startColumn: options.selection.startColumn,
+            endLineNumber: options.selection.endLineNumber ?? options.selection.startLineNumber,
+            endColumn: options.selection.endColumn ?? options.selection.startColumn
+        };
+        editor.setSelection(range, options.selectionSource ?? "code.navigation" );
+        if (options.selectionRevealType === 2 ) {
+            editor.revealRangeNearTop(range, scrollType);
+        }
+        else if (options.selectionRevealType === 3 ) {
+            editor.revealRangeNearTopIfOutsideViewport(range, scrollType);
+        }
+        else if (options.selectionRevealType === 1 ) {
+            editor.revealRangeInCenterIfOutsideViewport(range, scrollType);
+        }
+        else {
+            editor.revealRangeInCenter(range, scrollType);
+        }
+        applied = true;
+    }
+    return applied;
+}
+function massageEditorViewState(options) {
+    if (!options.selection || !options.viewState) {
+        return options.viewState;
+    }
+    const candidateDiffViewState = options.viewState;
+    if (candidateDiffViewState.modified) {
+        candidateDiffViewState.modified.cursorState = [];
+        return candidateDiffViewState;
+    }
+    const candidateEditorViewState = options.viewState;
+    if (candidateEditorViewState.cursorState) {
+        candidateEditorViewState.cursorState = [];
+    }
+    return candidateEditorViewState;
+}
+export { applyTextEditorOptions };

package/dist/vscode/vs/workbench/common/editor/resourceEditorInput.js

@@ -0,0 +1,133 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { EditorInput } from './editorInput.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { isEqual, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+let AbstractResourceEditorInput = class AbstractResourceEditorInput extends EditorInput {
+    get capabilities() {
+        let capabilities = 32 ;
+        if (this.fileService.hasProvider(this.resource)) {
+            if (this.fileService.hasCapability(this.resource, 2048 )) {
+                capabilities |= 2 ;
+            }
+        }
+        else {
+            capabilities |= 4 ;
+        }
+        if (!((capabilities & 2) )) {
+            capabilities |= 128 ;
+        }
+        return capabilities;
+    }
+    get preferredResource() { return this._preferredResource; }
+    constructor(resource, preferredResource, labelService, fileService) {
+        super();
+        this.resource = resource;
+        this.labelService = labelService;
+        this.fileService = fileService;
+        this._name = undefined;
+        this._shortDescription = undefined;
+        this._mediumDescription = undefined;
+        this._longDescription = undefined;
+        this._shortTitle = undefined;
+        this._mediumTitle = undefined;
+        this._longTitle = undefined;
+        this._preferredResource = preferredResource || resource;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.labelService.onDidChangeFormatters(e => this.onLabelEvent(e.scheme)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onLabelEvent(e.scheme)));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onLabelEvent(e.scheme)));
+    }
+    onLabelEvent(scheme) {
+        if (scheme === this._preferredResource.scheme) {
+            this.updateLabel();
+        }
+    }
+    updateLabel() {
+        this._name = undefined;
+        this._shortDescription = undefined;
+        this._mediumDescription = undefined;
+        this._longDescription = undefined;
+        this._shortTitle = undefined;
+        this._mediumTitle = undefined;
+        this._longTitle = undefined;
+        this._onDidChangeLabel.fire();
+    }
+    setPreferredResource(preferredResource) {
+        if (!isEqual(preferredResource, this._preferredResource)) {
+            this._preferredResource = preferredResource;
+            this.updateLabel();
+        }
+    }
+    getName() {
+        if (typeof this._name !== 'string') {
+            this._name = this.labelService.getUriBasenameLabel(this._preferredResource);
+        }
+        return this._name;
+    }
+    getDescription(verbosity = 1 ) {
+        switch (verbosity) {
+            case 0 :
+                return this.shortDescription;
+            case 2 :
+                return this.longDescription;
+            case 1 :
+            default:
+                return this.mediumDescription;
+        }
+    }
+    get shortDescription() {
+        if (typeof this._shortDescription !== 'string') {
+            this._shortDescription = this.labelService.getUriBasenameLabel(dirname(this._preferredResource));
+        }
+        return this._shortDescription;
+    }
+    get mediumDescription() {
+        if (typeof this._mediumDescription !== 'string') {
+            this._mediumDescription = this.labelService.getUriLabel(dirname(this._preferredResource), { relative: true });
+        }
+        return this._mediumDescription;
+    }
+    get longDescription() {
+        if (typeof this._longDescription !== 'string') {
+            this._longDescription = this.labelService.getUriLabel(dirname(this._preferredResource));
+        }
+        return this._longDescription;
+    }
+    get shortTitle() {
+        if (typeof this._shortTitle !== 'string') {
+            this._shortTitle = this.getName();
+        }
+        return this._shortTitle;
+    }
+    get mediumTitle() {
+        if (typeof this._mediumTitle !== 'string') {
+            this._mediumTitle = this.labelService.getUriLabel(this._preferredResource, { relative: true });
+        }
+        return this._mediumTitle;
+    }
+    get longTitle() {
+        if (typeof this._longTitle !== 'string') {
+            this._longTitle = this.labelService.getUriLabel(this._preferredResource);
+        }
+        return this._longTitle;
+    }
+    getTitle(verbosity) {
+        switch (verbosity) {
+            case 0 :
+                return this.shortTitle;
+            case 2 :
+                return this.longTitle;
+            default:
+            case 1 :
+                return this.mediumTitle;
+        }
+    }
+};
+AbstractResourceEditorInput = ( __decorate([
+    ( __param(2, ILabelService)),
+    ( __param(3, IFileService))
+], AbstractResourceEditorInput));
+export { AbstractResourceEditorInput };

package/dist/vscode/vs/workbench/common/editor/sideBySideEditorInput.js

@@ -0,0 +1,228 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { isResourceDiffEditorInput, isResourceSideBySideEditorInput, isResourceMergeEditorInput, isEditorInput, findViewStateForEditor, isResourceEditorInput, isDiffEditorInput } from '../editor.js';
+import { EditorInput } from './editorInput.js';
+import { IEditorService } from '../../services/editor/common/editorService.js';
+let SideBySideEditorInput = class SideBySideEditorInput extends EditorInput {
+    get typeId() {
+        return SideBySideEditorInput.ID;
+    }
+    get capabilities() {
+        let capabilities = this.primary.capabilities;
+        capabilities &= ~32 ;
+        if (this.secondary.hasCapability(16 )) {
+            capabilities |= 16 ;
+        }
+        if (this.secondary.hasCapability(8 )) {
+            capabilities |= 8 ;
+        }
+        capabilities |= 256 ;
+        return capabilities;
+    }
+    get resource() {
+        if (this.hasIdenticalSides) {
+            return this.primary.resource;
+        }
+        return undefined;
+    }
+    constructor(preferredName, preferredDescription, secondary, primary, editorService) {
+        super();
+        this.preferredName = preferredName;
+        this.preferredDescription = preferredDescription;
+        this.secondary = secondary;
+        this.primary = primary;
+        this.editorService = editorService;
+        this.hasIdenticalSides = this.primary.matches(this.secondary);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(Event.once(Event.any(this.primary.onWillDispose, this.secondary.onWillDispose))(() => {
+            if (!this.isDisposed()) {
+                this.dispose();
+            }
+        }));
+        this._register(this.primary.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this._register(this.primary.onDidChangeCapabilities(() => this._onDidChangeCapabilities.fire()));
+        this._register(this.secondary.onDidChangeCapabilities(() => this._onDidChangeCapabilities.fire()));
+        this._register(this.primary.onDidChangeLabel(() => this._onDidChangeLabel.fire()));
+        this._register(this.secondary.onDidChangeLabel(() => this._onDidChangeLabel.fire()));
+    }
+    getName() {
+        const preferredName = this.getPreferredName();
+        if (preferredName) {
+            return preferredName;
+        }
+        if (this.hasIdenticalSides) {
+            return this.primary.getName();
+        }
+        return ( localize(
+            'sideBySideLabels',
+            "{0} - {1}",
+            this.secondary.getName(),
+            this.primary.getName()
+        ));
+    }
+    getPreferredName() {
+        return this.preferredName;
+    }
+    getDescription(verbosity) {
+        const preferredDescription = this.getPreferredDescription();
+        if (preferredDescription) {
+            return preferredDescription;
+        }
+        if (this.hasIdenticalSides) {
+            return this.primary.getDescription(verbosity);
+        }
+        return super.getDescription(verbosity);
+    }
+    getPreferredDescription() {
+        return this.preferredDescription;
+    }
+    getTitle(verbosity) {
+        if (this.hasIdenticalSides) {
+            return this.primary.getTitle(verbosity) ?? this.getName();
+        }
+        return super.getTitle(verbosity);
+    }
+    getLabelExtraClasses() {
+        if (this.hasIdenticalSides) {
+            return this.primary.getLabelExtraClasses();
+        }
+        return super.getLabelExtraClasses();
+    }
+    getAriaLabel() {
+        if (this.hasIdenticalSides) {
+            return this.primary.getAriaLabel();
+        }
+        return super.getAriaLabel();
+    }
+    getTelemetryDescriptor() {
+        const descriptor = this.primary.getTelemetryDescriptor();
+        return { ...descriptor, ...super.getTelemetryDescriptor() };
+    }
+    isDirty() {
+        return this.primary.isDirty();
+    }
+    isSaving() {
+        return this.primary.isSaving();
+    }
+    async save(group, options) {
+        const primarySaveResult = await this.primary.save(group, options);
+        return this.saveResultToEditor(primarySaveResult);
+    }
+    async saveAs(group, options) {
+        const primarySaveResult = await this.primary.saveAs(group, options);
+        return this.saveResultToEditor(primarySaveResult);
+    }
+    saveResultToEditor(primarySaveResult) {
+        if (!primarySaveResult || !this.hasIdenticalSides) {
+            return primarySaveResult;
+        }
+        if (this.primary.matches(primarySaveResult)) {
+            return this;
+        }
+        if (primarySaveResult instanceof EditorInput) {
+            return ( new SideBySideEditorInput(
+                this.preferredName,
+                this.preferredDescription,
+                primarySaveResult,
+                primarySaveResult,
+                this.editorService
+            ));
+        }
+        if (!isResourceDiffEditorInput(primarySaveResult) && !isResourceSideBySideEditorInput(primarySaveResult) && !isResourceMergeEditorInput(primarySaveResult)) {
+            return {
+                primary: primarySaveResult,
+                secondary: primarySaveResult,
+                label: this.preferredName,
+                description: this.preferredDescription
+            };
+        }
+        return undefined;
+    }
+    revert(group, options) {
+        return this.primary.revert(group, options);
+    }
+    async rename(group, target) {
+        if (!this.hasIdenticalSides) {
+            return;
+        }
+        const renameResult = await this.primary.rename(group, target);
+        if (!renameResult) {
+            return undefined;
+        }
+        if (isEditorInput(renameResult.editor)) {
+            return {
+                editor: ( new SideBySideEditorInput(
+                    this.preferredName,
+                    this.preferredDescription,
+                    renameResult.editor,
+                    renameResult.editor,
+                    this.editorService
+                )),
+                options: {
+                    ...renameResult.options,
+                    viewState: findViewStateForEditor(this, group, this.editorService)
+                }
+            };
+        }
+        if (isResourceEditorInput(renameResult.editor)) {
+            return {
+                editor: {
+                    label: this.preferredName,
+                    description: this.preferredDescription,
+                    primary: renameResult.editor,
+                    secondary: renameResult.editor,
+                    options: {
+                        ...renameResult.options,
+                        viewState: findViewStateForEditor(this, group, this.editorService)
+                    }
+                }
+            };
+        }
+        return undefined;
+    }
+    toUntyped(options) {
+        const primaryResourceEditorInput = this.primary.toUntyped(options);
+        const secondaryResourceEditorInput = this.secondary.toUntyped(options);
+        if (primaryResourceEditorInput && secondaryResourceEditorInput &&
+            !isResourceDiffEditorInput(primaryResourceEditorInput) && !isResourceDiffEditorInput(secondaryResourceEditorInput) &&
+            !isResourceSideBySideEditorInput(primaryResourceEditorInput) && !isResourceSideBySideEditorInput(secondaryResourceEditorInput) &&
+            !isResourceMergeEditorInput(primaryResourceEditorInput) && !isResourceMergeEditorInput(secondaryResourceEditorInput)) {
+            const untypedInput = {
+                label: this.preferredName,
+                description: this.preferredDescription,
+                primary: primaryResourceEditorInput,
+                secondary: secondaryResourceEditorInput
+            };
+            if (typeof options?.preserveViewState === 'number') {
+                untypedInput.options = {
+                    viewState: findViewStateForEditor(this, options.preserveViewState, this.editorService)
+                };
+            }
+            return untypedInput;
+        }
+        return undefined;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (isDiffEditorInput(otherInput) || isResourceDiffEditorInput(otherInput)) {
+            return false;
+        }
+        if (otherInput instanceof SideBySideEditorInput) {
+            return this.primary.matches(otherInput.primary) && this.secondary.matches(otherInput.secondary);
+        }
+        if (isResourceSideBySideEditorInput(otherInput)) {
+            return this.primary.matches(otherInput.primary) && this.secondary.matches(otherInput.secondary);
+        }
+        return false;
+    }
+};
+SideBySideEditorInput.ID = 'workbench.editorinputs.sidebysideEditorInput';
+SideBySideEditorInput = ( __decorate([
+    ( __param(4, IEditorService))
+], SideBySideEditorInput));
+export { SideBySideEditorInput };

package/dist/vscode/vs/workbench/common/editor/textDiffEditorModel.js

@@ -0,0 +1,42 @@
+import { DiffEditorModel } from './diffEditorModel.js';
+class TextDiffEditorModel extends DiffEditorModel {
+    get originalModel() { return this._originalModel; }
+    get modifiedModel() { return this._modifiedModel; }
+    get textDiffEditorModel() { return this._textDiffEditorModel; }
+    constructor(originalModel, modifiedModel) {
+        super(originalModel, modifiedModel);
+        this._textDiffEditorModel = undefined;
+        this._originalModel = originalModel;
+        this._modifiedModel = modifiedModel;
+        this.updateTextDiffEditorModel();
+    }
+    async resolve() {
+        await super.resolve();
+        this.updateTextDiffEditorModel();
+    }
+    updateTextDiffEditorModel() {
+        if (this.originalModel?.isResolved() && this.modifiedModel?.isResolved()) {
+            if (!this._textDiffEditorModel) {
+                this._textDiffEditorModel = {
+                    original: this.originalModel.textEditorModel,
+                    modified: this.modifiedModel.textEditorModel
+                };
+            }
+            else {
+                this._textDiffEditorModel.original = this.originalModel.textEditorModel;
+                this._textDiffEditorModel.modified = this.modifiedModel.textEditorModel;
+            }
+        }
+    }
+    isResolved() {
+        return !!this._textDiffEditorModel;
+    }
+    isReadonly() {
+        return !!this.modifiedModel && this.modifiedModel.isReadonly();
+    }
+    dispose() {
+        this._textDiffEditorModel = undefined;
+        super.dispose();
+    }
+}
+export { TextDiffEditorModel };

package/dist/vscode/vs/workbench/common/editor/textEditorModel.js

@@ -0,0 +1,165 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { EditorModel } from './editorModel.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { LanguageDetectionLanguageEventSource, ILanguageDetectionService } from '../../services/languageDetection/common/languageDetectionWorkerService.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
+    constructor(modelService, languageService, languageDetectionService, accessibilityService, textEditorModelHandle) {
+        super();
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.languageDetectionService = languageDetectionService;
+        this.accessibilityService = accessibilityService;
+        this.textEditorModelHandle = undefined;
+        this.modelDisposeListener = this._register(( new MutableDisposable()));
+        this.autoDetectLanguageThrottler = this._register(( new ThrottledDelayer(BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY)));
+        this._hasLanguageSetExplicitly = false;
+        if (textEditorModelHandle) {
+            this.handleExistingModel(textEditorModelHandle);
+        }
+    }
+    handleExistingModel(textEditorModelHandle) {
+        const model = this.modelService.getModel(textEditorModelHandle);
+        if (!model) {
+            throw new Error(`Document with resource ${textEditorModelHandle.toString(true)} does not exist`);
+        }
+        this.textEditorModelHandle = textEditorModelHandle;
+        this.registerModelDisposeListener(model);
+    }
+    registerModelDisposeListener(model) {
+        this.modelDisposeListener.value = model.onWillDispose(() => {
+            this.textEditorModelHandle = undefined;
+            this.dispose();
+        });
+    }
+    get textEditorModel() {
+        return this.textEditorModelHandle ? this.modelService.getModel(this.textEditorModelHandle) : null;
+    }
+    isReadonly() {
+        return true;
+    }
+    get hasLanguageSetExplicitly() { return this._hasLanguageSetExplicitly; }
+    setLanguageId(languageId, source) {
+        this._hasLanguageSetExplicitly = true;
+        this.setLanguageIdInternal(languageId, source);
+    }
+    setLanguageIdInternal(languageId, source) {
+        if (!this.isResolved()) {
+            return;
+        }
+        if (!languageId || languageId === this.textEditorModel.getLanguageId()) {
+            return;
+        }
+        this.textEditorModel.setLanguage(this.languageService.createById(languageId), source);
+    }
+    installModelListeners(model) {
+        const disposable = this._register(model.onDidChangeLanguage((e) => {
+            if (e.source === LanguageDetectionLanguageEventSource) {
+                return;
+            }
+            this._hasLanguageSetExplicitly = true;
+            disposable.dispose();
+        }));
+    }
+    getLanguageId() {
+        return this.textEditorModel?.getLanguageId();
+    }
+    autoDetectLanguage() {
+        return this.autoDetectLanguageThrottler.trigger(() => this.doAutoDetectLanguage());
+    }
+    async doAutoDetectLanguage() {
+        if (this.hasLanguageSetExplicitly ||
+            !this.textEditorModelHandle ||
+            !this.languageDetectionService.isEnabledForLanguage(this.getLanguageId() ?? PLAINTEXT_LANGUAGE_ID)
+        ) {
+            return;
+        }
+        const lang = await this.languageDetectionService.detectLanguage(this.textEditorModelHandle);
+        if (lang && !this.isDisposed()) {
+            this.setLanguageIdInternal(lang, LanguageDetectionLanguageEventSource);
+            const languageName = this.languageService.getLanguageName(lang);
+            if (languageName) {
+                this.accessibilityService.alert(( localize(
+                    'languageAutoDetected',
+                    "Language {0} was automatically detected and set as the language mode.",
+                    languageName
+                )));
+            }
+        }
+    }
+    createTextEditorModel(value, resource, preferredLanguageId) {
+        const firstLineText = this.getFirstLineText(value);
+        const languageSelection = this.getOrCreateLanguage(resource, this.languageService, preferredLanguageId, firstLineText);
+        return this.doCreateTextEditorModel(value, languageSelection, resource);
+    }
+    doCreateTextEditorModel(value, languageSelection, resource) {
+        let model = resource && this.modelService.getModel(resource);
+        if (!model) {
+            model = this.modelService.createModel(value, languageSelection, resource);
+            this.createdEditorModel = true;
+            this.registerModelDisposeListener(model);
+        }
+        else {
+            this.updateTextEditorModel(value, languageSelection.languageId);
+        }
+        this.textEditorModelHandle = model.uri;
+        return model;
+    }
+    getFirstLineText(value) {
+        const textBufferFactory = value;
+        if (typeof textBufferFactory.getFirstLineText === 'function') {
+            return textBufferFactory.getFirstLineText(1000 );
+        }
+        const textSnapshot = value;
+        return textSnapshot.getLineContent(1).substr(0, 1000 );
+    }
+    getOrCreateLanguage(resource, languageService, preferredLanguage, firstLineText) {
+        if (!preferredLanguage || preferredLanguage === PLAINTEXT_LANGUAGE_ID) {
+            return languageService.createByFilepathOrFirstLine(withUndefinedAsNull(resource), firstLineText);
+        }
+        return languageService.createById(preferredLanguage);
+    }
+    updateTextEditorModel(newValue, preferredLanguageId) {
+        if (!this.isResolved()) {
+            return;
+        }
+        if (newValue) {
+            this.modelService.updateModel(this.textEditorModel, newValue);
+        }
+        if (preferredLanguageId && preferredLanguageId !== PLAINTEXT_LANGUAGE_ID && this.textEditorModel.getLanguageId() !== preferredLanguageId) {
+            this.textEditorModel.setLanguage(this.languageService.createById(preferredLanguageId));
+        }
+    }
+    createSnapshot() {
+        if (!this.textEditorModel) {
+            return null;
+        }
+        return this.textEditorModel.createSnapshot(true );
+    }
+    isResolved() {
+        return !!this.textEditorModelHandle;
+    }
+    dispose() {
+        this.modelDisposeListener.dispose();
+        if (this.textEditorModelHandle && this.createdEditorModel) {
+            this.modelService.destroyModel(this.textEditorModelHandle);
+        }
+        this.textEditorModelHandle = undefined;
+        this.createdEditorModel = false;
+        super.dispose();
+    }
+};
+BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY = 600;
+BaseTextEditorModel = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, ILanguageDetectionService)),
+    ( __param(3, IAccessibilityService))
+], BaseTextEditorModel));
+export { BaseTextEditorModel };