@codingame/monaco-vscode-api 1.79.7-next.1 → 1.79.7-next.2

package/dist/vscode/vs/workbench/contrib/customEditor/common/contributedCustomEditors.js

@@ -0,0 +1,72 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Memento } from '../../../common/memento.js';
+import { CustomEditorInfo } from './customEditor.js';
+import { customEditorsExtensionPoint } from './extensionPoint.js';
+import { RegisteredEditorPriority } from '../../../services/editor/common/editorResolverService.js';
+class ContributedCustomEditors extends Disposable {
+    constructor(storageService) {
+        super();
+        this._editors = ( new Map());
+        this._onChange = this._register(( new Emitter()));
+        this.onChange = this._onChange.event;
+        this._memento = ( new Memento(ContributedCustomEditors.CUSTOM_EDITORS_STORAGE_ID, storageService));
+        const mementoObject = this._memento.getMemento(0 , 1 );
+        for (const info of (mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] || [])) {
+            this.add(( new CustomEditorInfo(info)));
+        }
+        customEditorsExtensionPoint.setHandler(extensions => {
+            this.update(extensions);
+        });
+    }
+    update(extensions) {
+        this._editors.clear();
+        for (const extension of extensions) {
+            for (const webviewEditorContribution of extension.value) {
+                this.add(( new CustomEditorInfo({
+                    id: webviewEditorContribution.viewType,
+                    displayName: webviewEditorContribution.displayName,
+                    providerDisplayName: extension.description.isBuiltin ? ( nls.localize('builtinProviderDisplayName', "Built-in")) : extension.description.displayName || extension.description.identifier.value,
+                    selector: webviewEditorContribution.selector || [],
+                    priority: getPriorityFromContribution(webviewEditorContribution, extension.description),
+                })));
+            }
+        }
+        const mementoObject = this._memento.getMemento(0 , 1 );
+        mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._editors.values()));
+        this._memento.saveMemento();
+        this._onChange.fire();
+    }
+    [Symbol.iterator]() {
+        return ( this._editors.values());
+    }
+    get(viewType) {
+        return this._editors.get(viewType);
+    }
+    getContributedEditors(resource) {
+        return Array.from(( this._editors.values()))
+            .filter(customEditor => customEditor.matches(resource));
+    }
+    add(info) {
+        if (( this._editors.has(info.id))) {
+            console.error(`Custom editor with id '${info.id}' already registered`);
+            return;
+        }
+        this._editors.set(info.id, info);
+    }
+}
+ContributedCustomEditors.CUSTOM_EDITORS_STORAGE_ID = 'customEditors';
+ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID = 'editors';
+function getPriorityFromContribution(contribution, extension) {
+    switch (contribution.priority) {
+        case RegisteredEditorPriority.default:
+        case RegisteredEditorPriority.option:
+            return contribution.priority;
+        case RegisteredEditorPriority.builtin:
+            return extension.isBuiltin ? RegisteredEditorPriority.builtin : RegisteredEditorPriority.default;
+        default:
+            return RegisteredEditorPriority.default;
+    }
+}
+export { ContributedCustomEditors };

package/dist/vscode/vs/workbench/contrib/customEditor/common/customEditor.js

@@ -1,3 +1,55 @@
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { globMatchesResource, RegisteredEditorPriority, priorityToRank } from '../../../services/editor/common/editorResolverService.js';
 const ICustomEditorService = ( createDecorator('customEditorService'));
-export { ICustomEditorService };
+const CONTEXT_ACTIVE_CUSTOM_EDITOR_ID = ( new RawContextKey('activeCustomEditorId', '', {
+    type: 'string',
+    description: ( nls.localize(
+        'context.customEditor',
+        "The viewType of the currently active custom editor."
+    )),
+}));
+const CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE = ( new RawContextKey('focusedCustomEditorIsEditable', false));
+class CustomEditorInfo {
+    constructor(descriptor) {
+        this.id = descriptor.id;
+        this.displayName = descriptor.displayName;
+        this.providerDisplayName = descriptor.providerDisplayName;
+        this.priority = descriptor.priority;
+        this.selector = descriptor.selector;
+    }
+    matches(resource) {
+        return ( this.selector.some(
+            selector => selector.filenamePattern && globMatchesResource(selector.filenamePattern, resource)
+        ));
+    }
+}
+class CustomEditorInfoCollection {
+    constructor(editors) {
+        this.allEditors = distinct(editors, editor => editor.id);
+    }
+    get length() { return this.allEditors.length; }
+    get defaultEditor() {
+        return this.allEditors.find(editor => {
+            switch (editor.priority) {
+                case RegisteredEditorPriority.default:
+                case RegisteredEditorPriority.builtin:
+                    return this.allEditors.every(otherEditor => otherEditor === editor || isLowerPriority(otherEditor, editor));
+                default:
+                    return false;
+            }
+        });
+    }
+    get bestAvailableEditor() {
+        const editors = Array.from(this.allEditors).sort((a, b) => {
+            return priorityToRank(a.priority) - priorityToRank(b.priority);
+        });
+        return editors[0];
+    }
+}
+function isLowerPriority(otherEditor, editor) {
+    return priorityToRank(otherEditor.priority) < priorityToRank(editor.priority);
+}
+export { CONTEXT_ACTIVE_CUSTOM_EDITOR_ID, CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE, CustomEditorInfo, CustomEditorInfoCollection, ICustomEditorService };

package/dist/vscode/vs/workbench/contrib/customEditor/common/customEditorModelManager.js

@@ -0,0 +1,61 @@
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+class CustomEditorModelManager {
+    constructor() {
+        this._references = ( (new Map()));
+    }
+    async getAllModels(resource) {
+        const keyStart = `${( ( resource.toString()))}@@@`;
+        const models = [];
+        for (const [key, entry] of this._references) {
+            if (key.startsWith(keyStart) && entry.model) {
+                models.push(await entry.model);
+            }
+        }
+        return models;
+    }
+    async get(resource, viewType) {
+        const key = this.key(resource, viewType);
+        const entry = this._references.get(key);
+        return entry?.model;
+    }
+    tryRetain(resource, viewType) {
+        const key = this.key(resource, viewType);
+        const entry = this._references.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        entry.counter++;
+        return entry.model.then(model => {
+            return {
+                object: model,
+                dispose: once(() => {
+                    if (--entry.counter <= 0) {
+                        entry.model.then(x => x.dispose());
+                        this._references.delete(key);
+                    }
+                }),
+            };
+        });
+    }
+    add(resource, viewType, model) {
+        const key = this.key(resource, viewType);
+        const existing = this._references.get(key);
+        if (existing) {
+            throw new Error('Model already exists');
+        }
+        this._references.set(key, { viewType, model, counter: 0 });
+        return this.tryRetain(resource, viewType);
+    }
+    disposeAllModelsForView(viewType) {
+        for (const [key, value] of this._references) {
+            if (value.viewType === viewType) {
+                value.model.then(x => x.dispose());
+                this._references.delete(key);
+            }
+        }
+    }
+    key(resource, viewType) {
+        return `${( ( resource.toString()))}@@@${viewType}`;
+    }
+}
+export { CustomEditorModelManager };

package/dist/vscode/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -0,0 +1,70 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.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 { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+let CustomTextEditorModel = class CustomTextEditorModel extends Disposable {
+    static async create(instantiationService, viewType, resource) {
+        return instantiationService.invokeFunction(async (accessor) => {
+            const textModelResolverService = accessor.get(ITextModelService);
+            const model = await textModelResolverService.createModelReference(resource);
+            return instantiationService.createInstance(CustomTextEditorModel, viewType, resource, model);
+        });
+    }
+    constructor(viewType, _resource, _model, textFileService) {
+        super();
+        this.viewType = viewType;
+        this._resource = _resource;
+        this._model = _model;
+        this.textFileService = textFileService;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._register(_model);
+        this._textFileModel = this.textFileService.files.get(_resource);
+        if (this._textFileModel) {
+            this._register(this._textFileModel.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire()));
+            this._register(this._textFileModel.onDidChangeReadonly(() => this._onDidChangeReadonly.fire()));
+        }
+        this._register(this.textFileService.files.onDidChangeDirty(e => {
+            if (isEqual(this.resource, e.resource)) {
+                this._onDidChangeDirty.fire();
+                this._onDidChangeContent.fire();
+            }
+        }));
+    }
+    get resource() {
+        return this._resource;
+    }
+    isReadonly() {
+        return this._model.object.isReadonly();
+    }
+    get backupId() {
+        return undefined;
+    }
+    isDirty() {
+        return this.textFileService.isDirty(this.resource);
+    }
+    isOrphaned() {
+        return !!this._textFileModel?.hasState(4 );
+    }
+    async revert(options) {
+        return this.textFileService.revert(this.resource, options);
+    }
+    saveCustomEditor(options) {
+        return this.textFileService.save(this.resource, options);
+    }
+    async saveCustomEditorAs(resource, targetResource, options) {
+        return !!(await this.textFileService.saveAs(resource, targetResource, options));
+    }
+};
+CustomTextEditorModel = ( __decorate([
+    ( __param(3, ITextFileService))
+], CustomTextEditorModel));
+export { CustomTextEditorModel };

package/dist/vscode/vs/workbench/contrib/customEditor/common/extensionPoint.js

@@ -0,0 +1,106 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+import { languagesExtPoint } from '../../../services/language/common/languageService.js';
+const Fields = ( Object.freeze({
+    viewType: 'viewType',
+    displayName: 'displayName',
+    selector: 'selector',
+    priority: 'priority',
+}));
+const CustomEditorsContribution = {
+    description: ( nls.localize('contributes.customEditors', 'Contributed custom editors.')),
+    type: 'array',
+    defaultSnippets: [{
+            body: [{
+                    [Fields.viewType]: '$1',
+                    [Fields.displayName]: '$2',
+                    [Fields.selector]: [{
+                            filenamePattern: '$3'
+                        }],
+                }]
+        }],
+    items: {
+        type: 'object',
+        required: [
+            Fields.viewType,
+            Fields.displayName,
+            Fields.selector,
+        ],
+        properties: {
+            [Fields.viewType]: {
+                type: 'string',
+                markdownDescription: ( nls.localize(
+                    'contributes.viewType',
+                    'Identifier for the custom editor. This must be unique across all custom editors, so we recommend including your extension id as part of `viewType`. The `viewType` is used when registering custom editors with `vscode.registerCustomEditorProvider` and in the `onCustomEditor:${id}` [activation event](https://code.visualstudio.com/api/references/activation-events).'
+                )),
+            },
+            [Fields.displayName]: {
+                type: 'string',
+                description: ( nls.localize(
+                    'contributes.displayName',
+                    'Human readable name of the custom editor. This is displayed to users when selecting which editor to use.'
+                )),
+            },
+            [Fields.selector]: {
+                type: 'array',
+                description: ( nls.localize(
+                    'contributes.selector',
+                    'Set of globs that the custom editor is enabled for.'
+                )),
+                items: {
+                    type: 'object',
+                    defaultSnippets: [{
+                            body: {
+                                filenamePattern: '$1',
+                            }
+                        }],
+                    properties: {
+                        filenamePattern: {
+                            type: 'string',
+                            description: ( nls.localize(
+                                'contributes.selector.filenamePattern',
+                                'Glob that the custom editor is enabled for.'
+                            )),
+                        },
+                    }
+                }
+            },
+            [Fields.priority]: {
+                type: 'string',
+                markdownDeprecationMessage: ( nls.localize(
+                    'contributes.priority',
+                    'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
+                )),
+                enum: [
+                    "default" ,
+                    "option" ,
+                ],
+                markdownEnumDescriptions: [
+                    ( nls.localize(
+                        'contributes.priority.default',
+                        'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
+                    )),
+                    ( nls.localize(
+                        'contributes.priority.option',
+                        'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
+                    )),
+                ],
+                default: 'default'
+            }
+        }
+    }
+};
+const customEditorsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'customEditors',
+    deps: [languagesExtPoint],
+    jsonSchema: CustomEditorsContribution,
+    activationEventsGenerator: (contribs, result) => {
+        for (const contrib of contribs) {
+            const viewType = contrib[Fields.viewType];
+            if (viewType) {
+                result.push(`onCustomEditor:${viewType}`);
+            }
+        }
+    },
+}));
+export { customEditorsExtensionPoint };

package/dist/vscode/vs/workbench/contrib/externalUriOpener/common/configuration.js

@@ -0,0 +1,68 @@
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+const defaultExternalUriOpenerId = 'default';
+const externalUriOpenersSettingId = 'workbench.externalUriOpeners';
+const externalUriOpenerIdSchemaAddition = {
+    type: 'string',
+    enum: []
+};
+const exampleUriPatterns = `
+- \`https://microsoft.com\`: Matches this specific domain using https
+- \`https://microsoft.com:8080\`: Matches this specific domain on this port using https
+- \`https://microsoft.com:*\`: Matches this specific domain on any port using https
+- \`https://microsoft.com/foo\`: Matches \`https://microsoft.com/foo\` and \`https://microsoft.com/foo/bar\`, but not \`https://microsoft.com/foobar\` or \`https://microsoft.com/bar\`
+- \`https://*.microsoft.com\`: Match all domains ending in \`microsoft.com\` using https
+- \`microsoft.com\`: Match this specific domain using either http or https
+- \`*.microsoft.com\`: Match all domains ending in \`microsoft.com\` using either http or https
+- \`http://192.168.0.1\`: Matches this specific IP using http
+- \`http://192.168.0.*\`: Matches all IP's with this prefix using http
+- \`*\`: Match all domains using either http or https`;
+const externalUriOpenersConfigurationNode = {
+    ...workbenchConfigurationNodeBase,
+    properties: {
+        [externalUriOpenersSettingId]: {
+            type: 'object',
+            markdownDescription: ( nls.localize(
+                'externalUriOpeners',
+                "Configure the opener to use for external URIs (http, https)."
+            )),
+            defaultSnippets: [{
+                    body: {
+                        'example.com': '$1'
+                    }
+                }],
+            additionalProperties: {
+                anyOf: [
+                    {
+                        type: 'string',
+                        markdownDescription: ( nls.localize(
+                            'externalUriOpeners.uri',
+                            "Map URI pattern to an opener id.\nExample patterns: \n{0}",
+                            exampleUriPatterns
+                        )),
+                    },
+                    {
+                        type: 'string',
+                        markdownDescription: ( nls.localize(
+                            'externalUriOpeners.uri',
+                            "Map URI pattern to an opener id.\nExample patterns: \n{0}",
+                            exampleUriPatterns
+                        )),
+                        enum: [defaultExternalUriOpenerId],
+                        enumDescriptions: [( nls.localize('externalUriOpeners.defaultId', "Open using VS Code's standard opener."))],
+                    },
+                    externalUriOpenerIdSchemaAddition
+                ]
+            }
+        }
+    }
+};
+function updateContributedOpeners(enumValues, enumDescriptions) {
+    externalUriOpenerIdSchemaAddition.enum = enumValues;
+    externalUriOpenerIdSchemaAddition.enumDescriptions = enumDescriptions;
+    ( Registry.as(Extensions.Configuration))
+        .notifyConfigurationSchemaUpdated(externalUriOpenersConfigurationNode);
+}
+export { defaultExternalUriOpenerId, externalUriOpenersConfigurationNode, externalUriOpenersSettingId, updateContributedOpeners };

package/dist/vscode/vs/workbench/contrib/externalUriOpener/common/contributedOpeners.js

@@ -0,0 +1,79 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Memento } from '../../../common/memento.js';
+import { updateContributedOpeners } from './configuration.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStore extends Disposable {
+    constructor(storageService, _extensionService) {
+        super();
+        this._extensionService = _extensionService;
+        this._openers = ( new Map());
+        this._memento = ( new Memento(ContributedExternalUriOpenersStore.STORAGE_ID, storageService));
+        this._mementoObject = this._memento.getMemento(0 , 1 );
+        for (const [id, value] of Object.entries(this._mementoObject || {})) {
+            this.add(id, value.extensionId, { isCurrentlyRegistered: false });
+        }
+        this.invalidateOpenersOnExtensionsChanged();
+        this._register(this._extensionService.onDidChangeExtensions(() => this.invalidateOpenersOnExtensionsChanged()));
+        this._register(this._extensionService.onDidChangeExtensionsStatus(() => this.invalidateOpenersOnExtensionsChanged()));
+    }
+    didRegisterOpener(id, extensionId) {
+        this.add(id, extensionId, {
+            isCurrentlyRegistered: true
+        });
+    }
+    add(id, extensionId, options) {
+        const existing = this._openers.get(id);
+        if (existing) {
+            existing.isCurrentlyRegistered = existing.isCurrentlyRegistered || options.isCurrentlyRegistered;
+            return;
+        }
+        const entry = {
+            extensionId,
+            isCurrentlyRegistered: options.isCurrentlyRegistered
+        };
+        this._openers.set(id, entry);
+        this._mementoObject[id] = entry;
+        this._memento.saveMemento();
+        this.updateSchema();
+    }
+    delete(id) {
+        this._openers.delete(id);
+        delete this._mementoObject[id];
+        this._memento.saveMemento();
+        this.updateSchema();
+    }
+    async invalidateOpenersOnExtensionsChanged() {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const registeredExtensions = this._extensionService.extensions;
+        for (const [id, entry] of this._openers) {
+            const extension = registeredExtensions.find(r => r.identifier.value === entry.extensionId);
+            if (extension) {
+                if (!this._extensionService.canRemoveExtension(extension)) {
+                    if (!entry.isCurrentlyRegistered) {
+                        this.delete(id);
+                    }
+                }
+            }
+            else {
+                this.delete(id);
+            }
+        }
+    }
+    updateSchema() {
+        const ids = [];
+        const descriptions = [];
+        for (const [id, entry] of this._openers) {
+            ids.push(id);
+            descriptions.push(entry.extensionId);
+        }
+        updateContributedOpeners(ids, descriptions);
+    }
+};
+ContributedExternalUriOpenersStore.STORAGE_ID = 'externalUriOpeners';
+ContributedExternalUriOpenersStore = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IExtensionService))
+], ContributedExternalUriOpenersStore));
+export { ContributedExternalUriOpenersStore };

package/dist/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpener.contribution.js

@@ -0,0 +1,5 @@
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { externalUriOpenersConfigurationNode } from './configuration.js';
+( Registry.as(Extensions.Configuration))
+    .registerConfiguration(externalUriOpenersConfigurationNode);