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

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput.js

@@ -0,0 +1,122 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { DEFAULT_EDITOR_ASSOCIATION, findViewStateForEditor, isUntitledResourceEditorInput } from '../../../common/editor.js';
+import { AbstractTextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
+import { ITextFileService } from '../../textfile/common/textfiles.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { toLocalResource, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IPathService } from '../../path/common/pathService.js';
+let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractTextResourceEditorInput {
+    get typeId() {
+        return UntitledTextEditorInput.ID;
+    }
+    get editorId() {
+        return DEFAULT_EDITOR_ASSOCIATION.id;
+    }
+    constructor(model, textFileService, labelService, editorService, fileService, environmentService, pathService) {
+        super(model.resource, undefined, editorService, textFileService, labelService, fileService);
+        this.model = model;
+        this.environmentService = environmentService;
+        this.pathService = pathService;
+        this.modelResolve = undefined;
+        this.registerModelListeners(model);
+    }
+    registerModelListeners(model) {
+        this._register(model.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this._register(model.onDidChangeName(() => this._onDidChangeLabel.fire()));
+        this._register(model.onDidRevert(() => this.dispose()));
+    }
+    getName() {
+        return this.model.name;
+    }
+    getDescription(verbosity = 1 ) {
+        if (!this.model.hasAssociatedFilePath) {
+            const descriptionCandidate = this.resource.path;
+            if (descriptionCandidate !== this.getName()) {
+                return descriptionCandidate;
+            }
+            return undefined;
+        }
+        return super.getDescription(verbosity);
+    }
+    getTitle(verbosity) {
+        if (!this.model.hasAssociatedFilePath) {
+            const name = this.getName();
+            const description = this.getDescription();
+            if (description && description !== name) {
+                return `${name} • ${description}`;
+            }
+            return name;
+        }
+        return super.getTitle(verbosity);
+    }
+    isDirty() {
+        return this.model.isDirty();
+    }
+    getEncoding() {
+        return this.model.getEncoding();
+    }
+    setEncoding(encoding, mode ) {
+        return this.model.setEncoding(encoding);
+    }
+    setLanguageId(languageId, source) {
+        this.model.setLanguageId(languageId, source);
+    }
+    getLanguageId() {
+        return this.model.getLanguageId();
+    }
+    async resolve() {
+        if (!this.modelResolve) {
+            this.modelResolve = this.model.resolve();
+        }
+        await this.modelResolve;
+        return this.model;
+    }
+    toUntyped(options) {
+        const untypedInput = {
+            resource: this.model.hasAssociatedFilePath ? toLocalResource(this.model.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme) : this.resource,
+            forceUntitled: true,
+            options: {
+                override: this.editorId
+            }
+        };
+        if (typeof options?.preserveViewState === 'number') {
+            untypedInput.encoding = this.getEncoding();
+            untypedInput.languageId = this.getLanguageId();
+            untypedInput.contents = this.model.isDirty() ? this.model.textEditorModel?.getValue() : undefined;
+            untypedInput.options.viewState = findViewStateForEditor(this, options.preserveViewState, this.editorService);
+            if (typeof untypedInput.contents === 'string' && !this.model.hasAssociatedFilePath) {
+                untypedInput.resource = undefined;
+            }
+        }
+        return untypedInput;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof UntitledTextEditorInput) {
+            return isEqual(otherInput.resource, this.resource);
+        }
+        if (isUntitledResourceEditorInput(otherInput)) {
+            return super.matches(otherInput);
+        }
+        return false;
+    }
+    dispose() {
+        this.modelResolve = undefined;
+        super.dispose();
+    }
+};
+UntitledTextEditorInput.ID = 'workbench.editors.untitledEditorInput';
+UntitledTextEditorInput = ( __decorate([
+    ( __param(1, ITextFileService)),
+    ( __param(2, ILabelService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IPathService))
+], UntitledTextEditorInput));
+export { UntitledTextEditorInput };

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorModel.js

@@ -0,0 +1,240 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { BaseTextEditorModel } from '../../../common/editor/textEditorModel.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 { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IWorkingCopyBackupService } from '../../workingCopy/common/workingCopyBackup.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { createTextBufferFactoryFromStream } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { IWorkingCopyService } from '../../workingCopy/common/workingCopyService.js';
+import { NO_TYPE_ID } from '../../workingCopy/common/workingCopy.js';
+import { ITextFileService } from '../../textfile/common/textfiles.js';
+import { withNullAsUndefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ensureValidWordDefinition } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { getCharContainingOffset } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { UTF8 } from '../../textfile/common/encoding.js';
+import { bufferToReadable, VSBuffer, bufferToStream } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { ILanguageDetectionService } from '../../languageDetection/common/languageDetectionWorkerService.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEditorModel {
+    get name() {
+        if (this.configuredLabelFormat === 'content' && !this.hasAssociatedFilePath && this.cachedModelFirstLineWords) {
+            return this.cachedModelFirstLineWords;
+        }
+        return this.labelService.getUriBasenameLabel(this.resource);
+    }
+    constructor(resource, hasAssociatedFilePath, initialValue, preferredLanguageId, preferredEncoding, languageService, modelService, workingCopyBackupService, textResourceConfigurationService, workingCopyService, textFileService, labelService, editorService, languageDetectionService, accessibilityService) {
+        super(modelService, languageService, languageDetectionService, accessibilityService);
+        this.resource = resource;
+        this.hasAssociatedFilePath = hasAssociatedFilePath;
+        this.initialValue = initialValue;
+        this.preferredLanguageId = preferredLanguageId;
+        this.preferredEncoding = preferredEncoding;
+        this.workingCopyBackupService = workingCopyBackupService;
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.workingCopyService = workingCopyService;
+        this.textFileService = textFileService;
+        this.labelService = labelService;
+        this.editorService = editorService;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._onDidChangeName = this._register(( new Emitter()));
+        this.onDidChangeName = this._onDidChangeName.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeEncoding = this._register(( new Emitter()));
+        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
+        this._onDidSave = this._register(( new Emitter()));
+        this.onDidSave = this._onDidSave.event;
+        this._onDidRevert = this._register(( new Emitter()));
+        this.onDidRevert = this._onDidRevert.event;
+        this.typeId = NO_TYPE_ID;
+        this.capabilities = 2 ;
+        this.configuredLabelFormat = 'content';
+        this.cachedModelFirstLineWords = undefined;
+        this.dirty = this.hasAssociatedFilePath || !!this.initialValue;
+        this._register(this.workingCopyService.registerWorkingCopy(this));
+        if (preferredLanguageId) {
+            this.setLanguageId(preferredLanguageId);
+        }
+        this.onConfigurationChange(undefined, false);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.textResourceConfigurationService.onDidChangeConfiguration(e => this.onConfigurationChange(e, true)));
+    }
+    onConfigurationChange(e, fromEvent) {
+        if (!e || e.affectsConfiguration(this.resource, 'files.encoding')) {
+            const configuredEncoding = this.textResourceConfigurationService.getValue(this.resource, 'files.encoding');
+            if (this.configuredEncoding !== configuredEncoding && typeof configuredEncoding === 'string') {
+                this.configuredEncoding = configuredEncoding;
+                if (fromEvent && !this.preferredEncoding) {
+                    this._onDidChangeEncoding.fire();
+                }
+            }
+        }
+        if (!e || e.affectsConfiguration(this.resource, 'workbench.editor.untitled.labelFormat')) {
+            const configuredLabelFormat = this.textResourceConfigurationService.getValue(this.resource, 'workbench.editor.untitled.labelFormat');
+            if (this.configuredLabelFormat !== configuredLabelFormat && (configuredLabelFormat === 'content' || configuredLabelFormat === 'name')) {
+                this.configuredLabelFormat = configuredLabelFormat;
+                if (fromEvent) {
+                    this._onDidChangeName.fire();
+                }
+            }
+        }
+    }
+    setLanguageId(languageId, source) {
+        const actualLanguage = languageId === UntitledTextEditorModel.ACTIVE_EDITOR_LANGUAGE_ID
+            ? this.editorService.activeTextEditorLanguageId
+            : languageId;
+        this.preferredLanguageId = actualLanguage;
+        if (actualLanguage) {
+            super.setLanguageId(actualLanguage, source);
+        }
+    }
+    getLanguageId() {
+        if (this.textEditorModel) {
+            return this.textEditorModel.getLanguageId();
+        }
+        return this.preferredLanguageId;
+    }
+    getEncoding() {
+        return this.preferredEncoding || this.configuredEncoding;
+    }
+    async setEncoding(encoding) {
+        const oldEncoding = this.getEncoding();
+        this.preferredEncoding = encoding;
+        if (oldEncoding !== this.preferredEncoding) {
+            this._onDidChangeEncoding.fire();
+        }
+    }
+    isDirty() {
+        return this.dirty;
+    }
+    setDirty(dirty) {
+        if (this.dirty === dirty) {
+            return;
+        }
+        this.dirty = dirty;
+        this._onDidChangeDirty.fire();
+    }
+    async save(options) {
+        const target = await this.textFileService.save(this.resource, options);
+        if (target) {
+            this._onDidSave.fire({ reason: options?.reason, source: options?.source });
+        }
+        return !!target;
+    }
+    async revert() {
+        this.setDirty(false);
+        this._onDidRevert.fire();
+        this.dispose();
+    }
+    async backup(token) {
+        let content = undefined;
+        if (this.isResolved()) {
+            content = await this.textFileService.getEncodedReadable(this.resource, withNullAsUndefined(this.createSnapshot()), { encoding: UTF8 });
+        }
+        else if (typeof this.initialValue === 'string') {
+            content = bufferToReadable(VSBuffer.fromString(this.initialValue));
+        }
+        return { content };
+    }
+    async resolve() {
+        let createdUntitledModel = false;
+        let hasBackup = false;
+        if (!this.textEditorModel) {
+            let untitledContents;
+            const backup = await this.workingCopyBackupService.resolve(this);
+            if (backup) {
+                untitledContents = backup.value;
+                hasBackup = true;
+            }
+            else {
+                untitledContents = bufferToStream(VSBuffer.fromString(this.initialValue || ''));
+            }
+            const untitledContentsFactory = await createTextBufferFactoryFromStream(await this.textFileService.getDecodedStream(this.resource, untitledContents, { encoding: UTF8 }));
+            this.createTextEditorModel(untitledContentsFactory, this.resource, this.preferredLanguageId);
+            createdUntitledModel = true;
+        }
+        else {
+            this.updateTextEditorModel(undefined, this.preferredLanguageId);
+        }
+        const textEditorModel = assertIsDefined(this.textEditorModel);
+        this.installModelListeners(textEditorModel);
+        if (createdUntitledModel) {
+            if (hasBackup || this.initialValue) {
+                this.updateNameFromFirstLine(textEditorModel);
+            }
+            this.setDirty(this.hasAssociatedFilePath || !!hasBackup || !!this.initialValue);
+            if (hasBackup || this.initialValue) {
+                this._onDidChangeContent.fire();
+            }
+        }
+        return super.resolve();
+    }
+    installModelListeners(model) {
+        this._register(model.onDidChangeContent(e => this.onModelContentChanged(model, e)));
+        this._register(model.onDidChangeLanguage(() => this.onConfigurationChange(undefined, true)));
+        super.installModelListeners(model);
+    }
+    onModelContentChanged(textEditorModel, e) {
+        if (!this.hasAssociatedFilePath && textEditorModel.getLineCount() === 1 && textEditorModel.getLineContent(1) === '') {
+            this.setDirty(false);
+        }
+        else {
+            this.setDirty(true);
+        }
+        if (( e.changes.some(
+            change => (change.range.startLineNumber === 1 || change.range.endLineNumber === 1) && change.range.startColumn <= UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH
+        ))) {
+            this.updateNameFromFirstLine(textEditorModel);
+        }
+        this._onDidChangeContent.fire();
+        this.autoDetectLanguage();
+    }
+    updateNameFromFirstLine(textEditorModel) {
+        if (this.hasAssociatedFilePath) {
+            return;
+        }
+        let modelFirstWordsCandidate = undefined;
+        let firstLineText = textEditorModel
+            .getValueInRange({
+            startLineNumber: 1,
+            endLineNumber: 1,
+            startColumn: 1,
+            endColumn: UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH + 1
+        })
+            .trim().replace(/\s+/g, ' ');
+        firstLineText = firstLineText.substr(0, getCharContainingOffset(
+        firstLineText, UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH)[0]);
+        if (firstLineText && ensureValidWordDefinition().exec(firstLineText)) {
+            modelFirstWordsCandidate = firstLineText;
+        }
+        if (modelFirstWordsCandidate !== this.cachedModelFirstLineWords) {
+            this.cachedModelFirstLineWords = modelFirstWordsCandidate;
+            this._onDidChangeName.fire();
+        }
+    }
+    isReadonly() {
+        return false;
+    }
+};
+UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH = 40;
+UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH = UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH * 10;
+UntitledTextEditorModel.ACTIVE_EDITOR_LANGUAGE_ID = '${activeEditorLanguage}';
+UntitledTextEditorModel = ( __decorate([
+    ( __param(5, ILanguageService)),
+    ( __param(6, IModelService)),
+    ( __param(7, IWorkingCopyBackupService)),
+    ( __param(8, ITextResourceConfigurationService)),
+    ( __param(9, IWorkingCopyService)),
+    ( __param(10, ITextFileService)),
+    ( __param(11, ILabelService)),
+    ( __param(12, IEditorService)),
+    ( __param(13, ILanguageDetectionService)),
+    ( __param(14, IAccessibilityService))
+], UntitledTextEditorModel));
+export { UntitledTextEditorModel };

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IUntitledTextEditorService = ( createDecorator('untitledTextEditorService'));
+export { IUntitledTextEditorService };

package/dist/vscode/vs/workbench/services/userData/browser/userDataInit.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IUserDataInitializationService = ( createDecorator('IUserDataInitializationService'));
+export { IUserDataInitializationService };

package/dist/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.js

@@ -0,0 +1,7 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+const IUserDataProfileService = ( createDecorator('IUserDataProfileService'));
+const defaultUserDataProfileIcon = ( registerIcon('defaultProfile-icon', Codicon.settings, ( localize('defaultProfileIcon', 'Icon for Default Profile.'))));
+export { IUserDataProfileService, defaultUserDataProfileIcon };

package/dist/vscode/vs/workbench/services/userDataProfile/common/userDataProfileService.js

@@ -0,0 +1,52 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+import { defaultUserDataProfileIcon } from './userDataProfile.js';
+let UserDataProfileService = class UserDataProfileService extends Disposable {
+    get currentProfile() { return this._currentProfile; }
+    constructor(currentProfile, userDataProfilesService) {
+        super();
+        this._onDidChangeCurrentProfile = this._register(( new Emitter()));
+        this.onDidChangeCurrentProfile = this._onDidChangeCurrentProfile.event;
+        this._onDidUpdateCurrentProfile = this._register(( new Emitter()));
+        this.onDidUpdateCurrentProfile = this._onDidUpdateCurrentProfile.event;
+        this._currentProfile = currentProfile;
+        this._register(userDataProfilesService.onDidChangeProfiles(e => {
+            const updatedCurrentProfile = e.updated.find(p => this._currentProfile.id === p.id);
+            if (updatedCurrentProfile) {
+                this._currentProfile = updatedCurrentProfile;
+                this._onDidUpdateCurrentProfile.fire();
+            }
+        }));
+    }
+    async updateCurrentProfile(userDataProfile, preserveData) {
+        if (this._currentProfile.id === userDataProfile.id) {
+            return;
+        }
+        const previous = this._currentProfile;
+        this._currentProfile = userDataProfile;
+        const joiners = [];
+        this._onDidChangeCurrentProfile.fire({
+            preserveData,
+            previous,
+            profile: userDataProfile,
+            join(promise) {
+                joiners.push(promise);
+            }
+        });
+        await Promises.settled(joiners);
+    }
+    getShortName(profile) {
+        if (!profile.isDefault && profile.shortName && ThemeIcon.fromId(profile.shortName)) {
+            return profile.shortName;
+        }
+        return `$(${defaultUserDataProfileIcon.id})`;
+    }
+};
+UserDataProfileService = ( __decorate([
+    ( __param(1, IUserDataProfilesService))
+], UserDataProfileService));
+export { UserDataProfileService };

package/dist/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopySaveParticipant.js

@@ -0,0 +1,55 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { insert } from 'monaco-editor/esm/vs/base/common/arrays.js';
+let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySaveParticipant extends Disposable {
+    get length() { return this.saveParticipants.length; }
+    constructor(progressService, logService) {
+        super();
+        this.progressService = progressService;
+        this.logService = logService;
+        this.saveParticipants = [];
+    }
+    addSaveParticipant(participant) {
+        const remove = insert(this.saveParticipants, participant);
+        return toDisposable(() => remove());
+    }
+    participate(workingCopy, context, token) {
+        const cts = ( new CancellationTokenSource(token));
+        return this.progressService.withProgress({
+            title: ( localize('saveParticipants', "Saving '{0}'", workingCopy.name)),
+            location: 15 ,
+            cancellable: true,
+            delay: workingCopy.isDirty() ? 3000 : 5000
+        }, async (progress) => {
+            workingCopy.model?.pushStackElement();
+            for (const saveParticipant of this.saveParticipants) {
+                if (cts.token.isCancellationRequested || workingCopy.isDisposed()) {
+                    break;
+                }
+                try {
+                    const promise = saveParticipant.participate(workingCopy, context, progress, cts.token);
+                    await raceCancellation(promise, cts.token);
+                }
+                catch (err) {
+                    this.logService.warn(err);
+                }
+            }
+            workingCopy.model?.pushStackElement();
+        }, () => {
+            cts.dispose(true);
+        });
+    }
+    dispose() {
+        this.saveParticipants.splice(0, this.saveParticipants.length);
+    }
+};
+StoredFileWorkingCopySaveParticipant = ( __decorate([
+    ( __param(0, IProgressService)),
+    ( __param(1, ILogService))
+], StoredFileWorkingCopySaveParticipant));
+export { StoredFileWorkingCopySaveParticipant };

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopy.js

@@ -0,0 +1,2 @@
+const NO_TYPE_ID = '';
+export { NO_TYPE_ID };

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IWorkingCopyBackupService = ( createDecorator('workingCopyBackupService'));
+export { IWorkingCopyBackupService };