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

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

@@ -0,0 +1,146 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { DEFAULT_EDITOR_ASSOCIATION, isResourceEditorInput } from '../editor.js';
+import { AbstractResourceEditorInput } from './resourceEditorInput.js';
+import { ITextFileService } from '../../services/textfile/common/textfiles.js';
+import { IEditorService } from '../../services/editor/common/editorService.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 { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { TextResourceEditorModel } from './textResourceEditorModel.js';
+import { createTextBufferFactory } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+let AbstractTextResourceEditorInput = class AbstractTextResourceEditorInput extends AbstractResourceEditorInput {
+    constructor(resource, preferredResource, editorService, textFileService, labelService, fileService) {
+        super(resource, preferredResource, labelService, fileService);
+        this.editorService = editorService;
+        this.textFileService = textFileService;
+    }
+    save(group, options) {
+        if (this.resource.scheme !== Schemas.untitled && !this.fileService.hasProvider(this.resource)) {
+            return this.saveAs(group, options);
+        }
+        return this.doSave(options, false, group);
+    }
+    saveAs(group, options) {
+        return this.doSave(options, true, group);
+    }
+    async doSave(options, saveAs, group) {
+        let target;
+        if (saveAs) {
+            target = await this.textFileService.saveAs(this.resource, undefined, { ...options, suggestedTarget: this.preferredResource });
+        }
+        else {
+            target = await this.textFileService.save(this.resource, options);
+        }
+        if (!target) {
+            return undefined;
+        }
+        return { resource: target };
+    }
+    async revert(group, options) {
+        await this.textFileService.revert(this.resource, options);
+    }
+};
+AbstractTextResourceEditorInput = ( __decorate([
+    ( __param(2, IEditorService)),
+    ( __param(3, ITextFileService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, IFileService))
+], AbstractTextResourceEditorInput));
+let TextResourceEditorInput = class TextResourceEditorInput extends AbstractTextResourceEditorInput {
+    get typeId() {
+        return TextResourceEditorInput.ID;
+    }
+    get editorId() {
+        return DEFAULT_EDITOR_ASSOCIATION.id;
+    }
+    constructor(resource, name, description, preferredLanguageId, preferredContents, textModelResolverService, textFileService, editorService, fileService, labelService) {
+        super(resource, undefined, editorService, textFileService, labelService, fileService);
+        this.name = name;
+        this.description = description;
+        this.preferredLanguageId = preferredLanguageId;
+        this.preferredContents = preferredContents;
+        this.textModelResolverService = textModelResolverService;
+        this.cachedModel = undefined;
+        this.modelReference = undefined;
+    }
+    getName() {
+        return this.name || super.getName();
+    }
+    setName(name) {
+        if (this.name !== name) {
+            this.name = name;
+            this._onDidChangeLabel.fire();
+        }
+    }
+    getDescription() {
+        return this.description;
+    }
+    setDescription(description) {
+        if (this.description !== description) {
+            this.description = description;
+            this._onDidChangeLabel.fire();
+        }
+    }
+    setLanguageId(languageId, source) {
+        this.setPreferredLanguageId(languageId);
+        this.cachedModel?.setLanguageId(languageId, source);
+    }
+    setPreferredLanguageId(languageId) {
+        this.preferredLanguageId = languageId;
+    }
+    setPreferredContents(contents) {
+        this.preferredContents = contents;
+    }
+    async resolve() {
+        const preferredContents = this.preferredContents;
+        const preferredLanguageId = this.preferredLanguageId;
+        this.preferredContents = undefined;
+        this.preferredLanguageId = undefined;
+        if (!this.modelReference) {
+            this.modelReference = this.textModelResolverService.createModelReference(this.resource);
+        }
+        const ref = await this.modelReference;
+        const model = ref.object;
+        if (!(model instanceof TextResourceEditorModel)) {
+            ref.dispose();
+            this.modelReference = undefined;
+            throw new Error(`Unexpected model for TextResourceEditorInput: ${this.resource}`);
+        }
+        this.cachedModel = model;
+        if (typeof preferredContents === 'string' || typeof preferredLanguageId === 'string') {
+            model.updateTextEditorModel(typeof preferredContents === 'string' ? createTextBufferFactory(preferredContents) : undefined, preferredLanguageId);
+        }
+        return model;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof TextResourceEditorInput) {
+            return isEqual(otherInput.resource, this.resource);
+        }
+        if (isResourceEditorInput(otherInput)) {
+            return super.matches(otherInput);
+        }
+        return false;
+    }
+    dispose() {
+        if (this.modelReference) {
+            this.modelReference.then(ref => ref.dispose());
+            this.modelReference = undefined;
+        }
+        this.cachedModel = undefined;
+        super.dispose();
+    }
+};
+TextResourceEditorInput.ID = 'workbench.editors.resourceEditorInput';
+TextResourceEditorInput = ( __decorate([
+    ( __param(5, ITextModelService)),
+    ( __param(6, ITextFileService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IFileService)),
+    ( __param(9, ILabelService))
+], TextResourceEditorInput));
+export { AbstractTextResourceEditorInput, TextResourceEditorInput };

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

@@ -0,0 +1,24 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { BaseTextEditorModel } from './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 { ILanguageDetectionService } from '../../services/languageDetection/common/languageDetectionWorkerService.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+let TextResourceEditorModel = class TextResourceEditorModel extends BaseTextEditorModel {
+    constructor(resource, languageService, modelService, languageDetectionService, accessibilityService) {
+        super(modelService, languageService, languageDetectionService, accessibilityService, resource);
+    }
+    dispose() {
+        if (this.textEditorModelHandle) {
+            this.modelService.destroyModel(this.textEditorModelHandle);
+        }
+        super.dispose();
+    }
+};
+TextResourceEditorModel = ( __decorate([
+    ( __param(1, ILanguageService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ILanguageDetectionService)),
+    ( __param(4, IAccessibilityService))
+], TextResourceEditorModel));
+export { TextResourceEditorModel };

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

@@ -0,0 +1,307 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { toDisposable, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { createErrorWithActions } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { toAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+const EditorExtensions = {
+    EditorPane: 'workbench.contributions.editors',
+    EditorFactory: 'workbench.contributions.editor.inputFactories'
+};
+const DEFAULT_EDITOR_ASSOCIATION = {
+    id: 'default',
+    displayName: ( localize('promptOpenWith.defaultEditor.displayName', "Text Editor")),
+    providerDisplayName: ( localize('builtinProviderDisplayName', "Built-in"))
+};
+const SIDE_BY_SIDE_EDITOR_ID = 'workbench.editor.sidebysideEditor';
+const TEXT_DIFF_EDITOR_ID = 'workbench.editors.textDiffEditor';
+const BINARY_DIFF_EDITOR_ID = 'workbench.editors.binaryResourceDiffEditor';
+function isEditorPaneWithSelection(editorPane) {
+    const candidate = editorPane;
+    return !!candidate && typeof candidate.getSelection === 'function' && !!candidate.onDidChangeSelection;
+}
+function findViewStateForEditor(input, group, editorService) {
+    for (const editorPane of editorService.visibleEditorPanes) {
+        if (editorPane.group.id === group && input.matches(editorPane.input)) {
+            return editorPane.getViewState();
+        }
+    }
+    return undefined;
+}
+function isResourceEditorInput(editor) {
+    if (isEditorInput(editor)) {
+        return false;
+    }
+    const candidate = editor;
+    return URI.isUri(candidate?.resource);
+}
+function isResourceDiffEditorInput(editor) {
+    if (isEditorInput(editor)) {
+        return false;
+    }
+    const candidate = editor;
+    return candidate?.original !== undefined && candidate.modified !== undefined;
+}
+function isResourceSideBySideEditorInput(editor) {
+    if (isEditorInput(editor)) {
+        return false;
+    }
+    if (isResourceDiffEditorInput(editor)) {
+        return false;
+    }
+    const candidate = editor;
+    return candidate?.primary !== undefined && candidate.secondary !== undefined;
+}
+function isUntitledResourceEditorInput(editor) {
+    if (isEditorInput(editor)) {
+        return false;
+    }
+    const candidate = editor;
+    if (!candidate) {
+        return false;
+    }
+    return candidate.resource === undefined || candidate.resource.scheme === Schemas.untitled || candidate.forceUntitled === true;
+}
+const UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/;
+function isUntitledWithAssociatedResource(resource) {
+    return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
+}
+function isResourceMergeEditorInput(editor) {
+    if (isEditorInput(editor)) {
+        return false;
+    }
+    const candidate = editor;
+    return URI.isUri(candidate?.base?.resource) && URI.isUri(candidate?.input1?.resource) && URI.isUri(candidate?.input2?.resource) && URI.isUri(candidate?.result?.resource);
+}
+class SaveSourceFactory {
+    constructor() {
+        this.mapIdToSaveSource = ( new Map());
+    }
+    registerSource(id, label) {
+        let sourceDescriptor = this.mapIdToSaveSource.get(id);
+        if (!sourceDescriptor) {
+            sourceDescriptor = { source: id, label };
+            this.mapIdToSaveSource.set(id, sourceDescriptor);
+        }
+        return sourceDescriptor.source;
+    }
+    getSourceLabel(source) {
+        return this.mapIdToSaveSource.get(source)?.label ?? source;
+    }
+}
+const SaveSourceRegistry = ( new SaveSourceFactory());
+class AbstractEditorInput extends Disposable {
+}
+function isEditorInput(editor) {
+    return editor instanceof AbstractEditorInput;
+}
+function isEditorInputWithPreferredResource(editor) {
+    const candidate = editor;
+    return URI.isUri(candidate?.preferredResource);
+}
+function isSideBySideEditorInput(editor) {
+    const candidate = editor;
+    return isEditorInput(candidate?.primary) && isEditorInput(candidate?.secondary);
+}
+function isDiffEditorInput(editor) {
+    const candidate = editor;
+    return isEditorInput(candidate?.modified) && isEditorInput(candidate?.original);
+}
+function createTooLargeFileError(group, input, options, message, preferencesService) {
+    return createEditorOpenError(message, [
+        toAction({
+            id: 'workbench.action.openLargeFile', label: ( localize('openLargeFile', "Open Anyway")), run: () => {
+                const fileEditorOptions = {
+                    ...options,
+                    limits: {
+                        size: Number.MAX_VALUE
+                    }
+                };
+                group.openEditor(input, fileEditorOptions);
+            }
+        }),
+        toAction({
+            id: 'workbench.action.configureEditorLargeFileConfirmation', label: ( localize('configureEditorLargeFileConfirmation', "Configure Limit")), run: () => {
+                return preferencesService.openUserSettings({ query: 'workbench.editorLargeFileConfirmation' });
+            }
+        }),
+    ], {
+        forceMessage: true,
+        forceSeverity: Severity.Warning
+    });
+}
+function isEditorInputWithOptions(editor) {
+    const candidate = editor;
+    return isEditorInput(candidate?.editor);
+}
+function isEditorInputWithOptionsAndGroup(editor) {
+    const candidate = editor;
+    return isEditorInputWithOptions(editor) && candidate?.group !== undefined;
+}
+function isEditorIdentifier(identifier) {
+    const candidate = identifier;
+    return typeof candidate?.groupId === 'number' && isEditorInput(candidate.editor);
+}
+var SideBySideEditor;
+( (function(SideBySideEditor) {
+    SideBySideEditor[SideBySideEditor["PRIMARY"] = 1] = "PRIMARY";
+    SideBySideEditor[SideBySideEditor["SECONDARY"] = 2] = "SECONDARY";
+    SideBySideEditor[SideBySideEditor["BOTH"] = 3] = "BOTH";
+    SideBySideEditor[SideBySideEditor["ANY"] = 4] = "ANY";
+})(SideBySideEditor || (SideBySideEditor = {})));
+class EditorResourceAccessorImpl {
+    getOriginalUri(editor, options) {
+        if (!editor) {
+            return undefined;
+        }
+        if (isResourceMergeEditorInput(editor)) {
+            return EditorResourceAccessor.getOriginalUri(editor.result, options);
+        }
+        if (options?.supportSideBySide) {
+            const { primary, secondary } = this.getSideEditors(editor);
+            if (primary && secondary) {
+                if (options?.supportSideBySide === SideBySideEditor.BOTH) {
+                    return {
+                        primary: this.getOriginalUri(primary, { filterByScheme: options.filterByScheme }),
+                        secondary: this.getOriginalUri(secondary, { filterByScheme: options.filterByScheme })
+                    };
+                }
+                else if (options?.supportSideBySide === SideBySideEditor.ANY) {
+                    return this.getOriginalUri(primary, { filterByScheme: options.filterByScheme }) ?? this.getOriginalUri(secondary, { filterByScheme: options.filterByScheme });
+                }
+                editor = options.supportSideBySide === SideBySideEditor.PRIMARY ? primary : secondary;
+            }
+        }
+        if (isResourceDiffEditorInput(editor) || isResourceSideBySideEditorInput(editor) || isResourceMergeEditorInput(editor)) {
+            return undefined;
+        }
+        const originalResource = isEditorInputWithPreferredResource(editor) ? editor.preferredResource : editor.resource;
+        if (!originalResource || !options || !options.filterByScheme) {
+            return originalResource;
+        }
+        return this.filterUri(originalResource, options.filterByScheme);
+    }
+    getSideEditors(editor) {
+        if (isSideBySideEditorInput(editor) || isResourceSideBySideEditorInput(editor)) {
+            return { primary: editor.primary, secondary: editor.secondary };
+        }
+        if (isDiffEditorInput(editor) || isResourceDiffEditorInput(editor)) {
+            return { primary: editor.modified, secondary: editor.original };
+        }
+        return { primary: undefined, secondary: undefined };
+    }
+    getCanonicalUri(editor, options) {
+        if (!editor) {
+            return undefined;
+        }
+        if (isResourceMergeEditorInput(editor)) {
+            return EditorResourceAccessor.getCanonicalUri(editor.result, options);
+        }
+        if (options?.supportSideBySide) {
+            const { primary, secondary } = this.getSideEditors(editor);
+            if (primary && secondary) {
+                if (options?.supportSideBySide === SideBySideEditor.BOTH) {
+                    return {
+                        primary: this.getCanonicalUri(primary, { filterByScheme: options.filterByScheme }),
+                        secondary: this.getCanonicalUri(secondary, { filterByScheme: options.filterByScheme })
+                    };
+                }
+                else if (options?.supportSideBySide === SideBySideEditor.ANY) {
+                    return this.getCanonicalUri(primary, { filterByScheme: options.filterByScheme }) ?? this.getCanonicalUri(secondary, { filterByScheme: options.filterByScheme });
+                }
+                editor = options.supportSideBySide === SideBySideEditor.PRIMARY ? primary : secondary;
+            }
+        }
+        if (isResourceDiffEditorInput(editor) || isResourceSideBySideEditorInput(editor) || isResourceMergeEditorInput(editor)) {
+            return undefined;
+        }
+        const canonicalResource = editor.resource;
+        if (!canonicalResource || !options || !options.filterByScheme) {
+            return canonicalResource;
+        }
+        return this.filterUri(canonicalResource, options.filterByScheme);
+    }
+    filterUri(resource, filter) {
+        if (Array.isArray(filter)) {
+            if (( filter.some(scheme => resource.scheme === scheme))) {
+                return resource;
+            }
+        }
+        else {
+            if (filter === resource.scheme) {
+                return resource;
+            }
+        }
+        return undefined;
+    }
+}
+const EditorResourceAccessor = ( new EditorResourceAccessorImpl());
+class EditorFactoryRegistry {
+    constructor() {
+        this.editorSerializerConstructors = ( new Map());
+        this.editorSerializerInstances = ( new Map());
+    }
+    start(accessor) {
+        const instantiationService = this.instantiationService = accessor.get(IInstantiationService);
+        for (const [key, ctor] of this.editorSerializerConstructors) {
+            this.createEditorSerializer(key, ctor, instantiationService);
+        }
+        this.editorSerializerConstructors.clear();
+    }
+    createEditorSerializer(editorTypeId, ctor, instantiationService) {
+        const instance = instantiationService.createInstance(ctor);
+        this.editorSerializerInstances.set(editorTypeId, instance);
+    }
+    registerFileEditorFactory(factory) {
+        if (this.fileEditorFactory) {
+            throw new Error('Can only register one file editor factory.');
+        }
+        this.fileEditorFactory = factory;
+    }
+    getFileEditorFactory() {
+        return assertIsDefined(this.fileEditorFactory);
+    }
+    registerEditorSerializer(editorTypeId, ctor) {
+        if (this.editorSerializerConstructors.has(editorTypeId) || this.editorSerializerInstances.has(editorTypeId)) {
+            throw new Error(`A editor serializer with type ID '${editorTypeId}' was already registered.`);
+        }
+        if (!this.instantiationService) {
+            this.editorSerializerConstructors.set(editorTypeId, ctor);
+        }
+        else {
+            this.createEditorSerializer(editorTypeId, ctor, this.instantiationService);
+        }
+        return toDisposable(() => {
+            this.editorSerializerConstructors.delete(editorTypeId);
+            this.editorSerializerInstances.delete(editorTypeId);
+        });
+    }
+    getEditorSerializer(arg1) {
+        return this.editorSerializerInstances.get(typeof arg1 === 'string' ? arg1 : arg1.typeId);
+    }
+}
+Registry.add(EditorExtensions.EditorFactory, ( new EditorFactoryRegistry()));
+function isTextEditorViewState(candidate) {
+    const viewState = candidate;
+    if (!viewState) {
+        return false;
+    }
+    const diffEditorViewState = viewState;
+    if (diffEditorViewState.modified) {
+        return isTextEditorViewState(diffEditorViewState.modified);
+    }
+    const codeEditorViewState = viewState;
+    return !!(codeEditorViewState.contributionsState && codeEditorViewState.viewState && Array.isArray(codeEditorViewState.cursorState));
+}
+function createEditorOpenError(messageOrError, actions, options) {
+    const error = createErrorWithActions(messageOrError, actions);
+    error.forceMessage = options?.forceMessage;
+    error.forceSeverity = options?.forceSeverity;
+    error.allowDialog = options?.allowDialog;
+    return error;
+}
+export { AbstractEditorInput, BINARY_DIFF_EDITOR_ID, DEFAULT_EDITOR_ASSOCIATION, EditorExtensions, EditorResourceAccessor, SIDE_BY_SIDE_EDITOR_ID, SaveSourceRegistry, SideBySideEditor, TEXT_DIFF_EDITOR_ID, createEditorOpenError, createTooLargeFileError, findViewStateForEditor, isDiffEditorInput, isEditorIdentifier, isEditorInput, isEditorInputWithOptions, isEditorInputWithOptionsAndGroup, isEditorPaneWithSelection, isResourceDiffEditorInput, isResourceEditorInput, isResourceMergeEditorInput, isResourceSideBySideEditorInput, isSideBySideEditorInput, isTextEditorViewState, isUntitledResourceEditorInput, isUntitledWithAssociatedResource };

package/dist/{memento.js → vscode/vs/workbench/common/memento.js}

@@ -1,4 +1,4 @@
-import { isEmptyObject } from './polyfill.js';
+import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 class Memento {
     constructor(id, storageService) {