@codingame/monaco-vscode-notebook-service-override 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants.js

@@ -26,6 +26,7 @@ import { NotebookFileWorkingCopyModel } from 'vscode/vscode/vs/workbench/contrib
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants";
 let FormatOnSaveParticipant = class FormatOnSaveParticipant {
     constructor(editorWorkerService, languageFeaturesService, textModelService, bulkEditService, configurationService) {
         this.editorWorkerService = editorWorkerService;
@@ -46,30 +47,24 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
             return undefined;
         }
         const notebook = workingCopy.model.notebookModel;
-        progress.report({ message: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-            'notebookFormatSave.formatting',
-            "Formatting"
-        )) });
-        const disposable = ( new DisposableStore());
+        progress.report({ message: ( localizeWithPath(_moduleId, 0, "Formatting")) });
+        const disposable = ( (new DisposableStore()));
         try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+            const allCellEdits = await Promise.all(( (notebook.cells.map(async (cell) => {
                 const ref = await this.textModelService.createModelReference(cell.uri);
                 disposable.add(ref);
                 const model = ref.object.textEditorModel;
                 const formatEdits = await getDocumentFormattingEditsUntilResult(this.editorWorkerService, this.languageFeaturesService, model, model.getOptions(), token);
                 const edits = [];
                 if (formatEdits) {
-                    edits.push(...( formatEdits.map(edit => ( new ResourceTextEdit(model.uri, edit, model.getVersionId())))));
+                    edits.push(...( (formatEdits.map(
+                        edit => ( (new ResourceTextEdit(model.uri, edit, model.getVersionId())))
+                    ))));
                     return edits;
                 }
                 return [];
-            })));
-            await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'formatNotebook',
-                "Format Notebook"
-            )), code: 'undoredo.formatNotebook', });
+            }))));
+            await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(_moduleId, 1, "Format Notebook")), code: 'undoredo.formatNotebook', });
         }
         finally {
             progress.report({ increment: 100 });
@@ -77,13 +72,13 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
         }
     }
 };
-FormatOnSaveParticipant = ( __decorate([
-    ( __param(0, IEditorWorkerService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IBulkEditService)),
-    ( __param(4, IConfigurationService))
-], FormatOnSaveParticipant));
+FormatOnSaveParticipant = ( (__decorate([
+    ( (__param(0, IEditorWorkerService))),
+    ( (__param(1, ILanguageFeaturesService))),
+    ( (__param(2, ITextModelService))),
+    ( (__param(3, IBulkEditService))),
+    ( (__param(4, IConfigurationService)))
+], FormatOnSaveParticipant)));
 let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
     constructor(configurationService, editorService, textModelService, bulkEditService) {
         this.configurationService = configurationService;
@@ -102,28 +97,28 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return;
         }
-        const disposable = ( new DisposableStore());
+        const disposable = ( (new DisposableStore()));
         const notebook = workingCopy.model.notebookModel;
         const activeCellEditor = getActiveCellCodeEditor(this.editorService);
         let cursors = [];
         let prevSelection = [];
         try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+            const allCellEdits = await Promise.all(( (notebook.cells.map(async (cell) => {
                 if (cell.cellKind !== CellKind.Code) {
                     return [];
                 }
                 const ref = await this.textModelService.createModelReference(cell.uri);
                 disposable.add(ref);
                 const model = ref.object.textEditorModel;
-                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
+                const isActiveCell = (activeCellEditor && ( (cell.uri.toString())) === activeCellEditor.getModel()?.uri.toString());
                 if (isActiveCell) {
                     prevSelection = activeCellEditor.getSelections() ?? [];
                     if (isAutoSaved) {
-                        cursors = ( prevSelection.map(s => s.getPosition()));
+                        cursors = ( (prevSelection.map(s => s.getPosition())));
                         const snippetsRange = SnippetController2.get(activeCellEditor)?.getSessionEnclosingRange();
                         if (snippetsRange) {
                             for (let lineNumber = snippetsRange.startLineNumber; lineNumber <= snippetsRange.endLineNumber; lineNumber++) {
-                                cursors.push(( new Position(lineNumber, model.getLineMaxColumn(lineNumber))));
+                                cursors.push(( (new Position(lineNumber, model.getLineMaxColumn(lineNumber)))));
                             }
                         }
                     }
@@ -132,14 +127,14 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
                 if (!ops.length) {
                     return [];
                 }
-                return ( ops.map(op => ( new ResourceTextEdit(model.uri, { ...op, text: op.text || '' }, model.getVersionId()))));
-            })));
+                return (
+                     (ops.map(
+                        op => ( (new ResourceTextEdit(model.uri, { ...op, text: op.text || '' }, model.getVersionId())))
+                    ))
+                );
+            }))));
             const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
-            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'trimNotebookWhitespace',
-                "Notebook Trim Trailing Whitespace"
-            )), code: 'undoredo.notebookTrimTrailingWhitespace' });
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(_moduleId, 2, "Notebook Trim Trailing Whitespace")), code: 'undoredo.notebookTrimTrailingWhitespace' });
         }
         finally {
             progress.report({ increment: 100 });
@@ -147,12 +142,12 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
         }
     }
 };
-TrimWhitespaceParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IBulkEditService))
-], TrimWhitespaceParticipant));
+TrimWhitespaceParticipant = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, IEditorService))),
+    ( (__param(2, ITextModelService))),
+    ( (__param(3, IBulkEditService)))
+], TrimWhitespaceParticipant)));
 let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
     constructor(configurationService, editorService, bulkEditService) {
         this.configurationService = configurationService;
@@ -177,16 +172,16 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return;
         }
-        const disposable = ( new DisposableStore());
+        const disposable = ( (new DisposableStore()));
         const notebook = workingCopy.model.notebookModel;
         const activeCellEditor = getActiveCellCodeEditor(this.editorService);
         try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+            const allCellEdits = await Promise.all(( (notebook.cells.map(async (cell) => {
                 if (cell.cellKind !== CellKind.Code) {
                     return;
                 }
                 let cannotTouchLineNumber = 0;
-                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
+                const isActiveCell = (activeCellEditor && ( (cell.uri.toString())) === activeCellEditor.getModel()?.uri.toString());
                 if (isAutoSaved && isActiveCell) {
                     const selections = activeCellEditor.getSelections() ?? [];
                     for (const sel of selections) {
@@ -199,27 +194,25 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
                 if (deleteFromLineNumber > textBuffer.getLineCount()) {
                     return;
                 }
-                const deletionRange = ( new Range(
+                const deletionRange = ( (new Range(
                     deleteFromLineNumber,
                     1,
                     textBuffer.getLineCount(),
                     textBuffer.getLineLastNonWhitespaceColumn(textBuffer.getLineCount())
-                ));
+                )));
                 if (deletionRange.isEmpty()) {
                     return;
                 }
-                return ( new ResourceTextEdit(
-                    cell.uri,
-                    { range: deletionRange, text: '' },
-                    cell.textModel?.getVersionId()
-                ));
-            })));
+                return (
+                     (new ResourceTextEdit(
+                        cell.uri,
+                        { range: deletionRange, text: '' },
+                        cell.textModel?.getVersionId()
+                    ))
+                );
+            }))));
             const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
-            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'trimNotebookNewlines',
-                "Trim Final New Lines"
-            )), code: 'undoredo.trimFinalNewLines' });
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(_moduleId, 3, "Trim Final New Lines")), code: 'undoredo.trimFinalNewLines' });
         }
         finally {
             progress.report({ increment: 100 });
@@ -227,11 +220,11 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
         }
     }
 };
-TrimFinalNewLinesParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, IBulkEditService))
-], TrimFinalNewLinesParticipant));
+TrimFinalNewLinesParticipant = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, IEditorService))),
+    ( (__param(2, IBulkEditService)))
+], TrimFinalNewLinesParticipant)));
 let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
     constructor(configurationService, bulkEditService, editorService) {
         this.configurationService = configurationService;
@@ -247,7 +240,7 @@ let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return;
         }
-        const disposable = ( new DisposableStore());
+        const disposable = ( (new DisposableStore()));
         const notebook = workingCopy.model.notebookModel;
         const activeCellEditor = getActiveCellCodeEditor(this.editorService);
         let selections;
@@ -255,7 +248,7 @@ let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
             selections = activeCellEditor.getSelections() ?? [];
         }
         try {
-            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+            const allCellEdits = await Promise.all(( (notebook.cells.map(async (cell) => {
                 if (cell.cellKind !== CellKind.Code) {
                     return;
                 }
@@ -264,19 +257,17 @@ let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
                 if (!lineCount || lastLineIsEmptyOrWhitespace) {
                     return;
                 }
-                return ( new ResourceTextEdit(cell.uri, { range: ( new Range(
-                    lineCount + 1,
-                    cell.textBuffer.getLineLength(lineCount),
-                    lineCount + 1,
-                    cell.textBuffer.getLineLength(lineCount)
-                )), text: cell.textBuffer.getEOL() }, cell.textModel?.getVersionId()));
-            })));
+                return (
+                     (new ResourceTextEdit(cell.uri, { range: ( (new Range(
+                        lineCount + 1,
+                        cell.textBuffer.getLineLength(lineCount),
+                        lineCount + 1,
+                        cell.textBuffer.getLineLength(lineCount)
+                    ))), text: cell.textBuffer.getEOL() }, cell.textModel?.getVersionId()))
+                );
+            }))));
             const filteredEdits = allCellEdits.filter(edit => edit !== undefined);
-            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                'insertFinalNewLine',
-                "Insert Final New Line"
-            )), code: 'undoredo.insertFinalNewLine' });
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(_moduleId, 4, "Insert Final New Line")), code: 'undoredo.insertFinalNewLine' });
             if (activeCellEditor && selections) {
                 activeCellEditor.setSelections(selections);
             }
@@ -287,11 +278,11 @@ let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
         }
     }
 };
-InsertFinalNewLineParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IBulkEditService)),
-    ( __param(2, IEditorService))
-], InsertFinalNewLineParticipant));
+InsertFinalNewLineParticipant = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, IBulkEditService))),
+    ( (__param(2, IEditorService)))
+], InsertFinalNewLineParticipant)));
 let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
     constructor(configurationService, logService, workspaceTrustManagementService, languageFeaturesService, textModelService, instantiationService) {
         this.configurationService = configurationService;
@@ -302,7 +293,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         this.instantiationService = instantiationService;
     }
     async participate(workingCopy, context, progress, token) {
-        const nbDisposable = ( new DisposableStore());
+        const nbDisposable = ( (new DisposableStore()));
         const isTrusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
         if (!isTrusted) {
             return;
@@ -327,7 +318,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         }
         const settingItems = Array.isArray(setting)
             ? setting
-            : ( Object.keys(setting)).filter(x => setting[x]);
+            : ( (Object.keys(setting))).filter(x => setting[x]);
         if (!settingItems.length) {
             return undefined;
         }
@@ -355,11 +346,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
                 return 0;
             });
         }
-        progress.report({ message: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-            'notebookSaveParticipants.notebookCodeActions',
-            "Running 'Notebook' code actions"
-        )) });
+        progress.report({ message: ( localizeWithPath(_moduleId, 5, "Running 'Notebook' code actions")) });
         try {
             const cell = notebookModel.cells[0];
             const ref = await this.textModelService.createModelReference(cell.uri);
@@ -374,19 +361,15 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
             progress.report({ increment: 100 });
             nbDisposable.dispose();
         }
-        const disposable = ( new DisposableStore());
-        progress.report({ message: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-            'notebookSaveParticipants.cellCodeActions',
-            "Running 'Cell' code actions"
-        )) });
+        const disposable = ( (new DisposableStore()));
+        progress.report({ message: ( localizeWithPath(_moduleId, 6, "Running 'Cell' code actions")) });
         try {
-            await Promise.all(( notebookModel.cells.map(async (cell) => {
+            await Promise.all(( (notebookModel.cells.map(async (cell) => {
                 const ref = await this.textModelService.createModelReference(cell.uri);
                 disposable.add(ref);
                 const textEditorModel = ref.object.textEditorModel;
                 await this.applyOnSaveActions(textEditorModel, editorCodeActionsOnSave, excludedActions, progress, token);
-            })));
+            }))));
         }
         catch {
             this.logService.error('Failed to apply code action on save');
@@ -397,7 +380,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         }
     }
     createCodeActionsOnSave(settingItems) {
-        const kinds = ( settingItems.map(x => ( new HierarchicalKind(x))));
+        const kinds = ( (settingItems.map(x => ( (new HierarchicalKind(x))))));
         return kinds.filter(kind => {
             return kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind));
         });
@@ -405,21 +388,21 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
     async applyOnSaveActions(model, codeActionsOnSave, excludes, progress, token) {
         const getActionProgress = new (class {
             constructor() {
-                this._names = ( new Set());
+                this._names = ( (new Set()));
             }
             _report() {
                 progress.report({
                     message: ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                        { key: 'codeaction.get2', comment: ['[configure]({1}) is a link. Only translate `configure`. Do not change brackets and parentheses or {1}'] },
+                        _moduleId,
+                        7,
                         "Getting code actions from '{0}' ([configure]({1})).",
-                        ( [...this._names].map(name => `'${name}'`)).join(', '),
+                        ( ([...this._names].map(name => `'${name}'`))).join(', '),
                         'command:workbench.action.openSettings?%5B%22editor.codeActionsOnSave%22%5D'
                     ))
                 });
             }
             report(provider) {
-                if (provider.displayName && !( this._names.has(provider.displayName))) {
+                if (provider.displayName && !( (this._names.has(provider.displayName)))) {
                     this._names.add(provider.displayName);
                     this._report();
                 }
@@ -451,12 +434,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
                         this.logService.warn('Failed to apply code action on save, applied to multiple resources.');
                         continue;
                     }
-                    progress.report({ message: ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
-                        'codeAction.apply',
-                        "Applying code action '{0}'.",
-                        action.action.title
-                    )) });
+                    progress.report({ message: ( localizeWithPath(_moduleId, 8, "Applying code action '{0}'.", action.action.title)) });
                     await this.instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
                     if (token.isCancellationRequested) {
                         return;
@@ -478,14 +456,14 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         }, progress, token);
     }
 };
-CodeActionOnSaveParticipant = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IWorkspaceTrustManagementService)),
-    ( __param(3, ILanguageFeaturesService)),
-    ( __param(4, ITextModelService)),
-    ( __param(5, IInstantiationService))
-], CodeActionOnSaveParticipant));
+CodeActionOnSaveParticipant = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, ILogService))),
+    ( (__param(2, IWorkspaceTrustManagementService))),
+    ( (__param(3, ILanguageFeaturesService))),
+    ( (__param(4, ITextModelService))),
+    ( (__param(5, IInstantiationService)))
+], CodeActionOnSaveParticipant)));
 function getActiveCellCodeEditor(editorService) {
     const activePane = editorService.activeEditorPane;
     const notebookEditor = getNotebookEditorFromEditorPane(activePane);
@@ -507,11 +485,11 @@ let SaveParticipantsContribution = class SaveParticipantsContribution extends Di
         this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimFinalNewLinesParticipant)));
     }
 };
-SaveParticipantsContribution = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkingCopyFileService))
-], SaveParticipantsContribution));
-const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+SaveParticipantsContribution = ( (__decorate([
+    ( (__param(0, IInstantiationService))),
+    ( (__param(1, IWorkingCopyFileService)))
+], SaveParticipantsContribution)));
+const workbenchContributionsRegistry = ( (Registry.as(Extensions.Workbench)));
 workbenchContributionsRegistry.registerWorkbenchContribution(SaveParticipantsContribution, 3 );
 
 export { SaveParticipantsContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout.js

@@ -7,12 +7,13 @@ import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout";
 class TroubleshootController extends Disposable {
     static { this.id = 'workbench.notebook.troubleshoot'; }
     constructor(_notebookEditor) {
         super();
         this._notebookEditor = _notebookEditor;
-        this._localStore = this._register(( new DisposableStore()));
+        this._localStore = this._register(( (new DisposableStore())));
         this._cellStateListeners = [];
         this._enabled = false;
         this._cellStatusItems = [];
@@ -52,11 +53,11 @@ class TroubleshootController extends Disposable {
         this._localStore.add(this._notebookEditor.onDidChangeViewCells(e => {
             [...e.splices].reverse().forEach(splice => {
                 const [start, deleted, newCells] = splice;
-                const deletedCells = this._cellStateListeners.splice(start, deleted, ...( newCells.map(cell => {
+                const deletedCells = this._cellStateListeners.splice(start, deleted, ...( (newCells.map(cell => {
                     return cell.onDidChangeLayout((e) => {
                         this._log(cell, e);
                     });
-                })));
+                }))));
                 dispose(deletedCells);
             });
         }));
@@ -93,11 +94,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.toggleLayoutTroubleshoot',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
-                'workbench.notebook.toggleLayoutTroubleshoot',
-                "Toggle Layout Troubleshoot"
-            )),
+            title: ( localize2WithPath(_moduleId, 0, "Toggle Layout Troubleshoot")),
             category: Categories.Developer,
             f1: true
         });
@@ -116,11 +113,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.inspectLayout',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
-                'workbench.notebook.inspectLayout',
-                "Inspect Notebook Layout"
-            )),
+            title: ( localize2WithPath(_moduleId, 1, "Inspect Notebook Layout")),
             category: Categories.Developer,
             f1: true
         });
@@ -141,11 +134,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.clearNotebookEdtitorTypeCache',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
-                'workbench.notebook.clearNotebookEdtitorTypeCache',
-                "Clear Notebook Editor Type Cache"
-            )),
+            title: ( localize2WithPath(_moduleId, 2, "Clear Notebook Editor Type Cache")),
             category: Categories.Developer,
             f1: true
         });