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

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

@@ -1,68 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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);

package/dist/vscode/vs/workbench/contrib/outline/browser/outline.contribution.js

@@ -1,261 +0,0 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Extensions } from '../../../common/views.js';
-import { OutlinePane } from './outlinePane.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { VIEW_CONTAINER } from '../../files/browser/explorerViewlet.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { IOutlinePane } from './outline.js';
-const outlineViewIcon = registerIcon('outline-view-icon', Codicon.symbolClass, ( localize('outlineViewIcon', 'View icon of the outline view.')));
-( Registry.as(Extensions.ViewsRegistry)).registerViews([{
-        id: IOutlinePane.Id,
-        name: ( localize('name', "Outline")),
-        containerIcon: outlineViewIcon,
-        ctorDescriptor: ( new SyncDescriptor(OutlinePane)),
-        canToggleVisibility: true,
-        canMoveView: true,
-        hideByDefault: false,
-        collapsed: true,
-        order: 2,
-        weight: 30,
-        focusCommand: { id: 'outline.focus' }
-    }], VIEW_CONTAINER);
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
-    'id': 'outline',
-    'order': 117,
-    'title': ( localize('outlineConfigurationTitle', "Outline")),
-    'type': 'object',
-    'properties': {
-        ["outline.icons" ]: {
-            'description': ( localize('outline.showIcons', "Render Outline elements with icons.")),
-            'type': 'boolean',
-            'default': true
-        },
-        ["outline.collapseItems" ]: {
-            'description': ( localize(
-                'outline.initialState',
-                "Controls whether Outline items are collapsed or expanded."
-            )),
-            'type': 'string',
-            scope: 5 ,
-            'enum': [
-                'alwaysCollapse',
-                'alwaysExpand'
-            ],
-            'enumDescriptions': [
-                ( localize('outline.initialState.collapsed', "Collapse all items.")),
-                ( localize('outline.initialState.expanded', "Expand all items."))
-            ],
-            'default': 'alwaysExpand'
-        },
-        ["outline.problems.enabled" ]: {
-            'description': ( localize('outline.showProblem', "Show errors and warnings on Outline elements.")),
-            'type': 'boolean',
-            'default': true
-        },
-        ["outline.problems.colors" ]: {
-            'description': ( localize(
-                'outline.problem.colors',
-                "Use colors for errors and warnings on Outline elements."
-            )),
-            'type': 'boolean',
-            'default': true
-        },
-        ["outline.problems.badges" ]: {
-            'description': ( localize(
-                'outline.problems.badges',
-                "Use badges for errors and warnings on Outline elements."
-            )),
-            'type': 'boolean',
-            'default': true
-        },
-        'outline.showFiles': {
-            type: 'boolean',
-            scope: 5 ,
-            default: true,
-            markdownDescription: ( localize('filteredTypes.file', "When enabled, Outline shows `file`-symbols."))
-        },
-        'outline.showModules': {
-            type: 'boolean',
-            scope: 5 ,
-            default: true,
-            markdownDescription: ( localize('filteredTypes.module', "When enabled, Outline shows `module`-symbols."))
-        },
-        'outline.showNamespaces': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.namespace',
-                "When enabled, Outline shows `namespace`-symbols."
-            ))
-        },
-        'outline.showPackages': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.package', "When enabled, Outline shows `package`-symbols."))
-        },
-        'outline.showClasses': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.class', "When enabled, Outline shows `class`-symbols."))
-        },
-        'outline.showMethods': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.method', "When enabled, Outline shows `method`-symbols."))
-        },
-        'outline.showProperties': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.property',
-                "When enabled, Outline shows `property`-symbols."
-            ))
-        },
-        'outline.showFields': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.field', "When enabled, Outline shows `field`-symbols."))
-        },
-        'outline.showConstructors': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.constructor',
-                "When enabled, Outline shows `constructor`-symbols."
-            ))
-        },
-        'outline.showEnums': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.enum', "When enabled, Outline shows `enum`-symbols."))
-        },
-        'outline.showInterfaces': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.interface',
-                "When enabled, Outline shows `interface`-symbols."
-            ))
-        },
-        'outline.showFunctions': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.function',
-                "When enabled, Outline shows `function`-symbols."
-            ))
-        },
-        'outline.showVariables': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.variable',
-                "When enabled, Outline shows `variable`-symbols."
-            ))
-        },
-        'outline.showConstants': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.constant',
-                "When enabled, Outline shows `constant`-symbols."
-            ))
-        },
-        'outline.showStrings': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.string', "When enabled, Outline shows `string`-symbols."))
-        },
-        'outline.showNumbers': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.number', "When enabled, Outline shows `number`-symbols."))
-        },
-        'outline.showBooleans': {
-            type: 'boolean',
-            scope: 5 ,
-            default: true,
-            markdownDescription: ( localize('filteredTypes.boolean', "When enabled, Outline shows `boolean`-symbols."))
-        },
-        'outline.showArrays': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.array', "When enabled, Outline shows `array`-symbols."))
-        },
-        'outline.showObjects': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.object', "When enabled, Outline shows `object`-symbols."))
-        },
-        'outline.showKeys': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.key', "When enabled, Outline shows `key`-symbols."))
-        },
-        'outline.showNull': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.null', "When enabled, Outline shows `null`-symbols."))
-        },
-        'outline.showEnumMembers': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.enumMember',
-                "When enabled, Outline shows `enumMember`-symbols."
-            ))
-        },
-        'outline.showStructs': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.struct', "When enabled, Outline shows `struct`-symbols."))
-        },
-        'outline.showEvents': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize('filteredTypes.event', "When enabled, Outline shows `event`-symbols."))
-        },
-        'outline.showOperators': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.operator',
-                "When enabled, Outline shows `operator`-symbols."
-            ))
-        },
-        'outline.showTypeParameters': {
-            type: 'boolean',
-            default: true,
-            scope: 5 ,
-            markdownDescription: ( localize(
-                'filteredTypes.typeParameter',
-                "When enabled, Outline shows `typeParameter`-symbols."
-            ))
-        }
-    }
-});

package/dist/vscode/vs/workbench/contrib/outline/browser/outline.js

@@ -1,10 +0,0 @@
-import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-var IOutlinePane;
-( (function(IOutlinePane) {
-    IOutlinePane.Id = 'outline';
-})(IOutlinePane || (IOutlinePane = {})));
-const ctxFollowsCursor = ( new RawContextKey('outlineFollowsCursor', false));
-const ctxFilterOnType = ( new RawContextKey('outlineFiltersOnType', false));
-const ctxSortMode = ( new RawContextKey('outlineSortMode', 0 ));
-const ctxAllCollapsed = ( new RawContextKey('outlineAllCollapsed', false));
-export { IOutlinePane, ctxAllCollapsed, ctxFilterOnType, ctxFollowsCursor, ctxSortMode };

package/dist/vscode/vs/workbench/contrib/outline/browser/outlinePane.css.js

@@ -1,4 +0,0 @@
-import n from '../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".monaco-workbench .outline-pane{display:flex;flex-direction:column}.monaco-workbench .outline-pane .outline-progress{height:2px;padding-bottom:3px;position:absolute;width:100%}.monaco-workbench .outline-pane .outline-progress .monaco-progress-container,.monaco-workbench .outline-pane .outline-progress .monaco-progress-container .progress-bit{height:2px}.monaco-workbench .outline-pane .outline-tree{height:100%}.monaco-workbench .outline-pane .outline-message{display:none;opacity:.5;padding:10px 22px 0;pointer-events:none;position:absolute;z-index:1}.monaco-workbench .outline-pane.message .outline-message{display:inherit}.monaco-workbench .outline-pane.message .outline-progress{display:none}";
-n(css,{});
-export { css, css as default };