@codingame/monaco-vscode-notebook-service-override 8.0.4 → 9.0.0

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js

@@ -5,7 +5,6 @@ import { NotebookWorkingCopyTypeIdentifier, NotebookSetting, CellUri } from 'vsc
 import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
 import { ReferenceCollection, DisposableStore, dispose, combinedDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Emitter, AsyncEmitter } from 'vscode/vscode/vs/base/common/event';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
@@ -17,15 +16,16 @@ import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
 
 let NotebookModelReferenceCollection = class NotebookModelReferenceCollection extends ReferenceCollection {
-    constructor(_instantiationService, _notebookService, _logService, _configurationService, _telemetryService) {
+    constructor(_instantiationService, _notebookService, _configurationService, _telemetryService, _notebookLoggingService) {
         super();
         this._instantiationService = _instantiationService;
         this._notebookService = _notebookService;
-        this._logService = _logService;
         this._configurationService = _configurationService;
         this._telemetryService = _telemetryService;
+        this._notebookLoggingService = _notebookLoggingService;
         this._disposables = ( new DisposableStore());
         this._workingCopyManagers = ( new Map());
         this._modelListener = ( new Map());
@@ -57,7 +57,7 @@ let NotebookModelReferenceCollection = class NotebookModelReferenceCollection ex
                 this._notebookService,
                 this._configurationService,
                 this._telemetryService,
-                this._logService
+                this._notebookLoggingService
             ));
             workingCopyManager = this._instantiationService.createInstance(FileWorkingCopyManager, workingCopyTypeId, factory, factory);
             this._workingCopyManagers.set(workingCopyTypeId, workingCopyManager);
@@ -99,7 +99,7 @@ let NotebookModelReferenceCollection = class NotebookModelReferenceCollection ex
                 model.dispose();
             }
             catch (err) {
-                this._logService.error('FAILED to destory notebook', err);
+                this._notebookLoggingService.error('NotebookModelCollection', 'FAILED to destory notebook - ' + err);
             }
             finally {
                 this.modelsToDispose.delete(key);
@@ -110,9 +110,9 @@ let NotebookModelReferenceCollection = class NotebookModelReferenceCollection ex
 NotebookModelReferenceCollection = ( __decorate([
     ( __param(0, IInstantiationService)),
     ( __param(1, INotebookService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ITelemetryService))
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, INotebookLoggingService))
 ], NotebookModelReferenceCollection));
 let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
     constructor(instantiationService, _notebookService, _extensionService, _uriIdentService) {
@@ -131,45 +131,33 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
     isDirty(resource) {
         return this._data.isDirty(resource);
     }
-    async resolve(arg0, viewType, options) {
-        let resource;
-        let hasAssociatedFilePath = false;
-        if (URI.isUri(arg0)) {
-            resource = arg0;
+    createUntitledUri(notebookType) {
+        const info = this._notebookService.getContributedNotebookType(assertIsDefined(notebookType));
+        if (!info) {
+            throw ( new Error('UNKNOWN notebook type: ' + notebookType));
         }
-        else {
-            if (!arg0.untitledResource) {
-                const info = this._notebookService.getContributedNotebookType(assertIsDefined(viewType));
-                if (!info) {
-                    throw ( new Error('UNKNOWN view type: ' + viewType));
-                }
-                const suffix = NotebookProviderInfo.possibleFileEnding(info.selectors) ?? '';
-                for (let counter = 1;; counter++) {
-                    const candidate = ( URI.from(
-                        { scheme: Schemas.untitled, path: `Untitled-${counter}${suffix}`, query: viewType }
-                    ));
-                    if (!this._notebookService.getNotebookTextModel(candidate)) {
-                        resource = candidate;
-                        break;
-                    }
-                }
-            }
-            else if (arg0.untitledResource.scheme === Schemas.untitled) {
-                resource = arg0.untitledResource;
-            }
-            else {
-                resource = arg0.untitledResource.with({ scheme: Schemas.untitled });
-                hasAssociatedFilePath = true;
+        const suffix = NotebookProviderInfo.possibleFileEnding(info.selectors) ?? '';
+        for (let counter = 1;; counter++) {
+            const candidate = ( URI.from(
+                { scheme: Schemas.untitled, path: `Untitled-${counter}${suffix}`, query: notebookType }
+            ));
+            if (!this._notebookService.getNotebookTextModel(candidate)) {
+                return candidate;
             }
         }
-        if (resource.scheme === CellUri.scheme) {
-            throw ( new Error(`CANNOT open a cell-uri as notebook. Tried with ${( resource.toString())}`));
+    }
+    async validateResourceViewType(uri, viewType) {
+        if (!uri && !viewType) {
+            throw ( new Error('Must provide at least one of resource or viewType'));
+        }
+        if (uri?.scheme === CellUri.scheme) {
+            throw ( new Error(`CANNOT open a cell-uri as notebook. Tried with ${( uri.toString())}`));
         }
-        resource = this._uriIdentService.asCanonicalUri(resource);
-        const existingViewType = this._notebookService.getNotebookTextModel(resource)?.viewType;
+        const resource = this._uriIdentService.asCanonicalUri(uri ?? this.createUntitledUri(viewType));
+        const existingNotebook = this._notebookService.getNotebookTextModel(resource);
         if (!viewType) {
-            if (existingViewType) {
-                viewType = existingViewType;
+            if (existingNotebook) {
+                viewType = existingNotebook.viewType;
             }
             else {
                 await this._extensionService.whenInstalledExtensionsRegistered();
@@ -182,8 +170,8 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
         if (!viewType) {
             throw ( new Error(`Missing viewType for '${resource}'`));
         }
-        if (existingViewType && existingViewType !== viewType) {
-            await this._onWillFailWithConflict.fireAsync({ resource, viewType }, CancellationToken.None);
+        if (existingNotebook && existingNotebook.viewType !== viewType) {
+            await this._onWillFailWithConflict.fireAsync({ resource: resource, viewType }, CancellationToken.None);
             const existingViewType2 = this._notebookService.getNotebookTextModel(resource)?.viewType;
             if (existingViewType2 && existingViewType2 !== viewType) {
                 throw ( new Error(
@@ -191,7 +179,29 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
                 ));
             }
         }
-        const reference = this._data.acquire(( resource.toString()), viewType, hasAssociatedFilePath, options?.limits, options?.scratchpad);
+        return { resource, viewType };
+    }
+    async createUntitledNotebookTextModel(viewType) {
+        const resource = this._uriIdentService.asCanonicalUri(this.createUntitledUri(viewType));
+        return (await this._notebookService.createNotebookTextModel(viewType, resource));
+    }
+    async resolve(arg0, viewType, options) {
+        let resource;
+        let hasAssociatedFilePath;
+        if (URI.isUri(arg0)) {
+            resource = arg0;
+        }
+        else if (arg0.untitledResource) {
+            if (arg0.untitledResource.scheme === Schemas.untitled) {
+                resource = arg0.untitledResource;
+            }
+            else {
+                resource = arg0.untitledResource.with({ scheme: Schemas.untitled });
+                hasAssociatedFilePath = true;
+            }
+        }
+        const validated = await this.validateResourceViewType(resource, viewType);
+        const reference = this._data.acquire(( validated.resource.toString()), validated.viewType, hasAssociatedFilePath, options?.limits, options?.scratchpad);
         try {
             const model = await reference.object;
             return {

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.js

@@ -152,7 +152,7 @@ class NotebookEditorSimpleWorker {
     }
     dispose() {
     }
-    acceptNewModel(uri, data) {
+    $acceptNewModel(uri, data) {
         this._models[uri] = ( new MirrorNotebookDocument(( URI.parse(uri)), ( data.cells.map(dto => ( new MirrorCell(
             dto.handle,
             dto.source,
@@ -162,17 +162,17 @@ class NotebookEditorSimpleWorker {
             dto.metadata
         )))), data.metadata));
     }
-    acceptModelChanged(strURL, event) {
+    $acceptModelChanged(strURL, event) {
         const model = this._models[strURL];
         model?.acceptModelChanged(event);
     }
-    acceptRemovedModel(strURL) {
+    $acceptRemovedModel(strURL) {
         if (!this._models[strURL]) {
             return;
         }
         delete this._models[strURL];
     }
-    computeDiff(originalUrl, modifiedUrl) {
+    $computeDiff(originalUrl, modifiedUrl) {
         const original = this._getModel(originalUrl);
         const modified = this._getModel(modifiedUrl);
         const diff = ( new LcsDiff(( new CellSequence(original)), ( new CellSequence(modified))));
@@ -181,7 +181,7 @@ class NotebookEditorSimpleWorker {
             cellsDiff: diffResult,
         };
     }
-    canPromptRecommendation(modelUrl) {
+    $canPromptRecommendation(modelUrl) {
         const model = this._getModel(modelUrl);
         const cells = model.cells;
         for (let i = 0; i < cells.length; i++) {
@@ -211,7 +211,7 @@ class NotebookEditorSimpleWorker {
         return this._models[uri];
     }
 }
-function create(host) {
+function create(workerServer) {
     return ( new NotebookEditorSimpleWorker());
 }
 

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.js

@@ -47,8 +47,8 @@ import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/prog
 var FileWorkingCopyManager_1;
 let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
     static { FileWorkingCopyManager_1 = this; }
-    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localize(8049, "File Created"))); }
-    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localize(8050, "File Replaced"))); }
+    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localize(8050, "File Created"))); }
+    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localize(8051, "File Replaced"))); }
     constructor(workingCopyTypeId, storedWorkingCopyModelFactory, untitledWorkingCopyModelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, fileDialogService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService, pathService, environmentService, dialogService, decorationsService, progressService) {
         super();
         this.workingCopyTypeId = workingCopyTypeId;
@@ -103,7 +103,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             constructor(stored) {
                 super();
                 this.stored = stored;
-                this.label = ( localize(8051, "File Working Copy Decorations"));
+                this.label = ( localize(8052, "File Working Copy Decorations"));
                 this._onDidChange = this._register(( (new Emitter())));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
@@ -130,20 +130,20 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(8052, "Deleted, Read-only")),
+                        tooltip: ( localize(8053, "Deleted, Read-only")),
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(8053, "Read-only")),
+                        tooltip: ( localize(8054, "Read-only")),
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(8054, "Deleted")),
+                        tooltip: ( localize(8055, "Deleted")),
                     };
                 }
                 return undefined;
@@ -275,17 +275,17 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                8055,
+                8056,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                8056,
+                8057,
                 "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
                 basename(resource),
                 basename(dirname(resource))
             )),
-            primaryButton: ( localize(8057, "&&Replace"))
+            primaryButton: ( localize(8058, "&&Replace"))
         });
         return confirmed;
     }
@@ -293,12 +293,12 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                8058,
+                8059,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(8059, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(8060, "&&Save Anyway"))
+            detail: ( localize(8060, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(8061, "&&Save Anyway"))
         });
         return confirmed;
     }

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopyManager.js

@@ -77,7 +77,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
             this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdownWeb(), 'veto.fileWorkingCopyManager')));
         }
         else {
-            this._register(this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), { id: 'join.fileWorkingCopyManager', label: ( localize(10717, "Saving working copies")) })));
+            this._register(this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), { id: 'join.fileWorkingCopyManager', label: ( localize(10755, "Saving working copies")) })));
         }
     }
     onBeforeShutdownWeb() {

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffCellEditorOptions.js

@@ -1,47 +0,0 @@
-const fixedEditorPadding = {
-    top: 12,
-    bottom: 12
-};
-const fixedEditorOptions = {
-    padding: fixedEditorPadding,
-    scrollBeyondLastLine: false,
-    scrollbar: {
-        verticalScrollbarSize: 14,
-        horizontal: 'auto',
-        vertical: 'auto',
-        useShadows: true,
-        verticalHasArrows: false,
-        horizontalHasArrows: false,
-        alwaysConsumeMouseWheel: false,
-    },
-    renderLineHighlightOnlyWhenFocus: true,
-    overviewRulerLanes: 0,
-    overviewRulerBorder: false,
-    selectOnLineNumbers: false,
-    wordWrap: 'off',
-    lineNumbers: 'off',
-    lineDecorationsWidth: 0,
-    glyphMargin: false,
-    fixedOverflowWidgets: true,
-    minimap: { enabled: false },
-    renderValidationDecorations: 'on',
-    renderLineHighlight: 'none',
-    readOnly: true
-};
-const fixedDiffEditorOptions = {
-    ...fixedEditorOptions,
-    glyphMargin: true,
-    enableSplitViewResizing: false,
-    renderIndicators: true,
-    renderMarginRevertIcon: false,
-    readOnly: false,
-    isInEmbeddedEditor: true,
-    renderOverviewRuler: false,
-    wordWrap: 'off',
-    diffWordWrap: 'off',
-    diffAlgorithm: 'advanced',
-    renderSideBySide: true,
-    useInlineViewWhenSpaceIsLimited: false
-};
-
-export { fixedDiffEditorOptions, fixedEditorOptions, fixedEditorPadding };