@codingame/monaco-vscode-view-common-service-override 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/callHierarchyTree.js

@@ -8,6 +8,7 @@ import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 
+const _moduleId = "vs/workbench/contrib/callHierarchy/browser/callHierarchyTree";
 class Call {
     constructor(item, locations, model, parent) {
         this.item = item;
@@ -16,7 +17,7 @@ class Call {
         this.parent = parent;
     }
     static compare(a, b) {
-        let res = compare(( a.item.uri.toString()), ( b.item.uri.toString()));
+        let res = compare(( (a.item.uri.toString())), ( (b.item.uri.toString())));
         if (res === 0) {
             res = Range.compareRangesUsingStarts(a.item.range, b.item.range);
         }
@@ -32,18 +33,38 @@ class DataSource {
     }
     async getChildren(element) {
         if (element instanceof CallHierarchyModel) {
-            return ( element.roots.map(root => ( new Call(root, undefined, element, undefined))));
+            return (
+                 (element.roots.map(root => ( (new Call(root, undefined, element, undefined)))))
+            );
         }
         const { model, item } = element;
         if (this.getDirection() === "outgoingCalls" ) {
-            return ( (await model.resolveOutgoingCalls(item, CancellationToken.None)).map(call => {
-                return ( new Call(call.to, ( call.fromRanges.map(range => ({ range, uri: item.uri }))), model, element));
-            }));
+            return (
+                 ((await model.resolveOutgoingCalls(item, CancellationToken.None)).map(call => {
+                    return (
+                         (new Call(
+                            call.to,
+                             (call.fromRanges.map(range => ({ range, uri: item.uri }))),
+                            model,
+                            element
+                        ))
+                    );
+                }))
+            );
         }
         else {
-            return ( (await model.resolveIncomingCalls(item, CancellationToken.None)).map(call => {
-                return ( new Call(call.from, ( call.fromRanges.map(range => ({ range, uri: call.from.uri }))), model, element));
-            }));
+            return (
+                 ((await model.resolveIncomingCalls(item, CancellationToken.None)).map(call => {
+                    return (
+                         (new Call(
+                            call.from,
+                             (call.fromRanges.map(range => ({ range, uri: call.from.uri }))),
+                            model,
+                            element
+                        ))
+                    );
+                }))
+            );
         }
     }
 }
@@ -79,8 +100,10 @@ class CallRenderer {
         container.classList.add('callhierarchy-element');
         const icon = document.createElement('div');
         container.appendChild(icon);
-        const label = ( new IconLabel(container, { supportHighlights: true }));
-        return ( new CallRenderingTemplate(icon, label));
+        const label = ( (new IconLabel(container, { supportHighlights: true })));
+        return (
+             (new CallRenderingTemplate(icon, label))
+        );
     }
     renderElement(node, _index, template) {
         const { element, filterData } = node;
@@ -106,28 +129,14 @@ class AccessibilityProvider {
         this.getDirection = getDirection;
     }
     getWidgetAriaLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
-            'tree.aria',
-            "Call Hierarchy"
-        ));
+        return ( localizeWithPath(_moduleId, 0, "Call Hierarchy"));
     }
     getAriaLabel(element) {
         if (this.getDirection() === "outgoingCalls" ) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
-                'from',
-                "calls from {0}",
-                element.item.name
-            ));
+            return ( localizeWithPath(_moduleId, 1, "calls from {0}", element.item.name));
         }
         else {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
-                'to',
-                "callers of {0}",
-                element.item.name
-            ));
+            return ( localizeWithPath(_moduleId, 2, "callers of {0}", element.item.name));
         }
     }
 }

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInputFactory.js

@@ -118,7 +118,7 @@ let ComplexCustomWorkingCopyEditorHandler = class ComplexCustomWorkingCopyEditor
     async createEditor(workingCopy) {
         const backup = await this._workingCopyBackupService.resolve(workingCopy);
         if (!backup?.meta) {
-            throw new Error(`No backup found for custom editor: ${workingCopy.resource}`);
+            throw ( new Error(`No backup found for custom editor: ${workingCopy.resource}`));
         }
         const backupData = backup.meta;
         const extension = reviveWebviewExtensionDescription(backupData.extension?.id, backupData.extension?.location);

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditors.js

@@ -133,7 +133,7 @@ let CustomEditorService = class CustomEditorService extends Disposable {
     }
     registerCustomEditorCapabilities(viewType, options) {
         if (( this._editorCapabilities.has(viewType))) {
-            throw new Error(`Capabilities for ${viewType} already set`);
+            throw ( new Error(`Capabilities for ${viewType} already set`));
         }
         this._editorCapabilities.set(viewType, options);
         return toDisposable(() => {

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

@@ -6,18 +6,19 @@ import { CustomEditorInfo } from './customEditor.js';
 import { customEditorsExtensionPoint } from './extensionPoint.js';
 import { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
 
+const _moduleId = "vs/workbench/contrib/customEditor/common/contributedCustomEditors";
 class ContributedCustomEditors extends Disposable {
     static { this.CUSTOM_EDITORS_STORAGE_ID = 'customEditors'; }
     static { this.CUSTOM_EDITORS_ENTRY_ID = 'editors'; }
     constructor(storageService) {
         super();
-        this._editors = ( new Map());
-        this._onChange = this._register(( new Emitter()));
+        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));
+        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)));
+            this.add(( (new CustomEditorInfo(info))));
         }
         customEditorsExtensionPoint.setHandler(extensions => {
             this.update(extensions);
@@ -27,36 +28,34 @@ class ContributedCustomEditors extends Disposable {
         this._editors.clear();
         for (const extension of extensions) {
             for (const webviewEditorContribution of extension.value) {
-                this.add(( new CustomEditorInfo({
+                this.add(( (new CustomEditorInfo({
                     id: webviewEditorContribution.viewType,
                     displayName: webviewEditorContribution.displayName,
-                    providerDisplayName: extension.description.isBuiltin ? ( localizeWithPath(
-                        'vs/workbench/contrib/customEditor/common/contributedCustomEditors',
-                        'builtinProviderDisplayName',
-                        "Built-in"
-                    )) : extension.description.displayName || extension.description.identifier.value,
+                    providerDisplayName: extension.description.isBuiltin ? ( localizeWithPath(_moduleId, 0, "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()));
+        mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( (this._editors.values())));
         this._memento.saveMemento();
         this._onChange.fire();
     }
     [Symbol.iterator]() {
-        return ( this._editors.values());
+        return (
+             (this._editors.values())
+        );
     }
     get(viewType) {
         return this._editors.get(viewType);
     }
     getContributedEditors(resource) {
-        return Array.from(( this._editors.values()))
+        return Array.from(( (this._editors.values())))
             .filter(customEditor => customEditor.matches(resource));
     }
     add(info) {
-        if (( this._editors.has(info.id))) {
+        if (( (this._editors.has(info.id)))) {
             console.error(`Custom editor with id '${info.id}' already registered`);
             return;
         }

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

@@ -3,15 +3,12 @@ import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { RawContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { globMatchesResource, RegisteredEditorPriority, priorityToRank } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
 
-const CONTEXT_ACTIVE_CUSTOM_EDITOR_ID = ( new RawContextKey('activeCustomEditorId', '', {
+const _moduleId = "vs/workbench/contrib/customEditor/common/customEditor";
+const CONTEXT_ACTIVE_CUSTOM_EDITOR_ID = ( (new RawContextKey('activeCustomEditorId', '', {
     type: 'string',
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/customEditor/common/customEditor',
-        'context.customEditor',
-        "The viewType of the currently active custom editor."
-    )),
-}));
-const CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE = ( new RawContextKey('focusedCustomEditorIsEditable', false));
+    description: ( localizeWithPath(_moduleId, 0, "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;
@@ -21,9 +18,11 @@ class CustomEditorInfo {
         this.selector = descriptor.selector;
     }
     matches(resource) {
-        return ( this.selector.some(
-            selector => selector.filenamePattern && globMatchesResource(selector.filenamePattern, resource)
-        ));
+        return (
+             (this.selector.some(
+                selector => selector.filenamePattern && globMatchesResource(selector.filenamePattern, resource)
+            ))
+        );
     }
 }
 class CustomEditorInfoCollection {

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

@@ -42,7 +42,7 @@ class CustomEditorModelManager {
         const key = this.key(resource, viewType);
         const existing = this._references.get(key);
         if (existing) {
-            throw new Error('Model already exists');
+            throw ( new Error('Model already exists'));
         }
         this._references.set(key, { viewType, model, counter: 0 });
         return this.tryRetain(resource, viewType);

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

@@ -7,18 +7,15 @@ import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagem
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { languagesExtPoint } from 'vscode/vscode/vs/workbench/services/language/common/languageService';
 
-const Fields = ( Object.freeze({
+const _moduleId = "vs/workbench/contrib/customEditor/common/extensionPoint";
+const Fields = ( (Object.freeze({
     viewType: 'viewType',
     displayName: 'displayName',
     selector: 'selector',
     priority: 'priority',
-}));
+})));
 const CustomEditorsContribution = {
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/customEditor/common/extensionPoint',
-        'contributes.customEditors',
-        'Contributed custom editors.'
-    )),
+    description: ( localizeWithPath(_moduleId, 0, 'Contributed custom editors.')),
     type: 'array',
     defaultSnippets: [{
             body: [{
@@ -40,26 +37,22 @@ const CustomEditorsContribution = {
             [Fields.viewType]: {
                 type: 'string',
                 markdownDescription: ( localizeWithPath(
-                    'vs/workbench/contrib/customEditor/common/extensionPoint',
-                    'contributes.viewType',
+                    _moduleId,
+                    1,
                     '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: ( localizeWithPath(
-                    'vs/workbench/contrib/customEditor/common/extensionPoint',
-                    'contributes.displayName',
+                    _moduleId,
+                    2,
                     'Human readable name of the custom editor. This is displayed to users when selecting which editor to use.'
                 )),
             },
             [Fields.selector]: {
                 type: 'array',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/customEditor/common/extensionPoint',
-                    'contributes.selector',
-                    'Set of globs that the custom editor is enabled for.'
-                )),
+                description: ( localizeWithPath(_moduleId, 3, 'Set of globs that the custom editor is enabled for.')),
                 items: {
                     type: 'object',
                     defaultSnippets: [{
@@ -70,11 +63,7 @@ const CustomEditorsContribution = {
                     properties: {
                         filenamePattern: {
                             type: 'string',
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/customEditor/common/extensionPoint',
-                                'contributes.selector.filenamePattern',
-                                'Glob that the custom editor is enabled for.'
-                            )),
+                            description: ( localizeWithPath(_moduleId, 4, 'Glob that the custom editor is enabled for.')),
                         },
                     }
                 }
@@ -82,8 +71,8 @@ const CustomEditorsContribution = {
             [Fields.priority]: {
                 type: 'string',
                 markdownDeprecationMessage: ( localizeWithPath(
-                    'vs/workbench/contrib/customEditor/common/extensionPoint',
-                    'contributes.priority',
+                    _moduleId,
+                    5,
                     '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: [
@@ -92,13 +81,13 @@ const CustomEditorsContribution = {
                 ],
                 markdownEnumDescriptions: [
                     ( localizeWithPath(
-                        'vs/workbench/contrib/customEditor/common/extensionPoint',
-                        'contributes.priority.default',
+                        _moduleId,
+                        6,
                         'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
                     )),
                     ( localizeWithPath(
-                        'vs/workbench/contrib/customEditor/common/extensionPoint',
-                        'contributes.priority.option',
+                        _moduleId,
+                        7,
                         '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.'
                     )),
                 ],
@@ -134,30 +123,18 @@ class CustomEditorsDataRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localizeWithPath(
-                'vs/workbench/contrib/customEditor/common/extensionPoint',
-                'customEditors view type',
-                "View Type"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/customEditor/common/extensionPoint',
-                'customEditors priority',
-                "Priority"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/customEditor/common/extensionPoint',
-                'customEditors filenamePattern',
-                "Filename Pattern"
-            )),
+            ( localizeWithPath(_moduleId, 8, "View Type")),
+            ( localizeWithPath(_moduleId, 9, "Priority")),
+            ( localizeWithPath(_moduleId, 10, "Filename Pattern")),
         ];
-        const rows = ( customEditors
+        const rows = ( (customEditors
             .map(customEditor => {
             return [
                 customEditor.viewType,
                 customEditor.priority ?? '',
-                coalesce(( customEditor.selector.map(x => x.filenamePattern))).join(', ')
+                coalesce(( (customEditor.selector.map(x => x.filenamePattern)))).join(', ')
             ];
-        }));
+        })));
         return {
             data: {
                 headers,
@@ -167,17 +144,13 @@ class CustomEditorsDataRenderer extends Disposable {
         };
     }
 }
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'customEditors',
-    label: ( localizeWithPath(
-        'vs/workbench/contrib/customEditor/common/extensionPoint',
-        'customEditors',
-        "Custom Editors"
-    )),
+    label: ( localizeWithPath(_moduleId, 11, "Custom Editors")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(CustomEditorsDataRenderer)),
+    renderer: ( (new SyncDescriptor(CustomEditorsDataRenderer))),
 });
 
 export { customEditorsExtensionPoint };