@codingame/monaco-vscode-notebook-service-override 1.85.1

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

@@ -0,0 +1,407 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { StoredFileWorkingCopy } from './storedFileWorkingCopy.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { ResourceQueue, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { BaseFileWorkingCopyManager } from './abstractFileWorkingCopyManager.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IElevatedFileService } from 'vscode/vscode/vs/workbench/services/files/common/elevatedFileService';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+
+let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends BaseFileWorkingCopyManager {
+    constructor(workingCopyTypeId, modelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService) {
+        super(fileService, logService, workingCopyBackupService);
+        this.workingCopyTypeId = workingCopyTypeId;
+        this.modelFactory = modelFactory;
+        this.lifecycleService = lifecycleService;
+        this.labelService = labelService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.uriIdentityService = uriIdentityService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.workingCopyService = workingCopyService;
+        this.notificationService = notificationService;
+        this.workingCopyEditorService = workingCopyEditorService;
+        this.editorService = editorService;
+        this.elevatedFileService = elevatedFileService;
+        this._onDidResolve = this._register(( new Emitter()));
+        this.onDidResolve = this._onDidResolve.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidSaveError = this._register(( new Emitter()));
+        this.onDidSaveError = this._onDidSaveError.event;
+        this._onDidSave = this._register(( new Emitter()));
+        this.onDidSave = this._onDidSave.event;
+        this._onDidRevert = this._register(( new Emitter()));
+        this.onDidRevert = this._onDidRevert.event;
+        this._onDidRemove = this._register(( new Emitter()));
+        this.onDidRemove = this._onDidRemove.event;
+        this.mapResourceToWorkingCopyListeners = ( new ResourceMap());
+        this.mapResourceToPendingWorkingCopyResolve = ( new ResourceMap());
+        this.workingCopyResolveQueue = this._register(( new ResourceQueue()));
+        this.mapCorrelationIdToWorkingCopiesToRestore = ( new Map());
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e)));
+        this._register(this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e)));
+        if (isWeb) {
+            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: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/storedFileWorkingCopyManager',
+                'join.fileWorkingCopyManager',
+                "Saving working copies"
+            )) })));
+        }
+    }
+    onBeforeShutdownWeb() {
+        if (( this.workingCopies.some(
+            workingCopy => workingCopy.hasState(2 )
+        ))) {
+            return true;
+        }
+        return false;
+    }
+    async onWillShutdownDesktop() {
+        let pendingSavedWorkingCopies;
+        while ((pendingSavedWorkingCopies = this.workingCopies.filter(workingCopy => workingCopy.hasState(2 ))).length > 0) {
+            await Promises.settled(( pendingSavedWorkingCopies.map(
+                workingCopy => workingCopy.joinState(2 )
+            )));
+        }
+    }
+    onDidChangeFileSystemProviderCapabilities(e) {
+        this.queueWorkingCopyReloads(e.scheme);
+    }
+    onDidChangeFileSystemProviderRegistrations(e) {
+        if (!e.added) {
+            return;
+        }
+        this.queueWorkingCopyReloads(e.scheme);
+    }
+    onDidFilesChange(e) {
+        this.queueWorkingCopyReloads(e);
+    }
+    queueWorkingCopyReloads(schemeOrEvent) {
+        for (const workingCopy of this.workingCopies) {
+            if (workingCopy.isDirty()) {
+                continue;
+            }
+            let resolveWorkingCopy = false;
+            if (typeof schemeOrEvent === 'string') {
+                resolveWorkingCopy = schemeOrEvent === workingCopy.resource.scheme;
+            }
+            else {
+                resolveWorkingCopy = schemeOrEvent.contains(workingCopy.resource, 0 , 1 );
+            }
+            if (resolveWorkingCopy) {
+                this.queueWorkingCopyReload(workingCopy);
+            }
+        }
+    }
+    queueWorkingCopyReload(workingCopy) {
+        const queue = this.workingCopyResolveQueue.queueFor(workingCopy.resource);
+        if (queue.size <= 1) {
+            queue.queue(async () => {
+                try {
+                    await this.reload(workingCopy);
+                }
+                catch (error) {
+                    this.logService.error(error);
+                }
+            });
+        }
+    }
+    onWillRunWorkingCopyFileOperation(e) {
+        if (e.operation === 2  || e.operation === 3 ) {
+            e.waitUntil((async () => {
+                const workingCopiesToRestore = [];
+                for (const { source, target } of e.files) {
+                    if (source) {
+                        if (this.uriIdentityService.extUri.isEqual(source, target)) {
+                            continue;
+                        }
+                        const sourceWorkingCopies = [];
+                        for (const workingCopy of this.workingCopies) {
+                            if (this.uriIdentityService.extUri.isEqualOrParent(workingCopy.resource, source)) {
+                                sourceWorkingCopies.push(workingCopy);
+                            }
+                        }
+                        for (const sourceWorkingCopy of sourceWorkingCopies) {
+                            const sourceResource = sourceWorkingCopy.resource;
+                            let targetResource;
+                            if (this.uriIdentityService.extUri.isEqual(sourceResource, source)) {
+                                targetResource = target;
+                            }
+                            else {
+                                targetResource = joinPath(target, sourceResource.path.substr(source.path.length + 1));
+                            }
+                            workingCopiesToRestore.push({
+                                source: sourceResource,
+                                target: targetResource,
+                                snapshot: sourceWorkingCopy.isDirty() ? await sourceWorkingCopy.model?.snapshot(CancellationToken.None) : undefined
+                            });
+                        }
+                    }
+                }
+                this.mapCorrelationIdToWorkingCopiesToRestore.set(e.correlationId, workingCopiesToRestore);
+            })());
+        }
+    }
+    onDidFailWorkingCopyFileOperation(e) {
+        if (((e.operation === 2  || e.operation === 3) )) {
+            const workingCopiesToRestore = this.mapCorrelationIdToWorkingCopiesToRestore.get(e.correlationId);
+            if (workingCopiesToRestore) {
+                this.mapCorrelationIdToWorkingCopiesToRestore.delete(e.correlationId);
+                for (const workingCopy of workingCopiesToRestore) {
+                    if (workingCopy.snapshot) {
+                        this.get(workingCopy.source)?.markModified();
+                    }
+                }
+            }
+        }
+    }
+    onDidRunWorkingCopyFileOperation(e) {
+        switch (e.operation) {
+            case 0 :
+                e.waitUntil((async () => {
+                    for (const { target } of e.files) {
+                        const workingCopy = this.get(target);
+                        if (workingCopy && !workingCopy.isDisposed()) {
+                            await workingCopy.revert();
+                        }
+                    }
+                })());
+                break;
+            case 2 :
+            case 3 :
+                e.waitUntil((async () => {
+                    const workingCopiesToRestore = this.mapCorrelationIdToWorkingCopiesToRestore.get(e.correlationId);
+                    if (workingCopiesToRestore) {
+                        this.mapCorrelationIdToWorkingCopiesToRestore.delete(e.correlationId);
+                        await Promises.settled(( workingCopiesToRestore.map(async (workingCopyToRestore) => {
+                            await this.resolve(workingCopyToRestore.target, {
+                                reload: { async: false },
+                                contents: workingCopyToRestore.snapshot
+                            });
+                        })));
+                    }
+                })());
+                break;
+        }
+    }
+    async reload(workingCopy) {
+        await this.joinPendingResolves(workingCopy.resource);
+        if (workingCopy.isDirty() || workingCopy.isDisposed() || !( this.has(workingCopy.resource))) {
+            return;
+        }
+        await this.doResolve(workingCopy, { reload: { async: false } });
+    }
+    async resolve(resource, options) {
+        const pendingResolve = this.joinPendingResolves(resource);
+        if (pendingResolve) {
+            await pendingResolve;
+        }
+        return this.doResolve(resource, options);
+    }
+    async doResolve(resourceOrWorkingCopy, options) {
+        let workingCopy;
+        let resource;
+        if (URI.isUri(resourceOrWorkingCopy)) {
+            resource = resourceOrWorkingCopy;
+            workingCopy = this.get(resource);
+        }
+        else {
+            resource = resourceOrWorkingCopy.resource;
+            workingCopy = resourceOrWorkingCopy;
+        }
+        let workingCopyResolve;
+        let didCreateWorkingCopy = false;
+        const resolveOptions = {
+            contents: options?.contents,
+            forceReadFromFile: options?.reload?.force
+        };
+        if (workingCopy) {
+            if (options?.contents) {
+                workingCopyResolve = workingCopy.resolve(resolveOptions);
+            }
+            else if (options?.reload) {
+                if (options.reload.async) {
+                    workingCopyResolve = Promise.resolve();
+                    (async () => {
+                        try {
+                            await workingCopy.resolve(resolveOptions);
+                        }
+                        catch (error) {
+                            onUnexpectedError(error);
+                        }
+                    })();
+                }
+                else {
+                    workingCopyResolve = workingCopy.resolve(resolveOptions);
+                }
+            }
+            else {
+                workingCopyResolve = Promise.resolve();
+            }
+        }
+        else {
+            didCreateWorkingCopy = true;
+            workingCopy = ( new StoredFileWorkingCopy(
+                this.workingCopyTypeId,
+                resource,
+                this.labelService.getUriBasenameLabel(resource),
+                this.modelFactory,
+                async (options) => { await this.resolve(resource, { ...options, reload: { async: false } }); },
+                this.fileService,
+                this.logService,
+                this.workingCopyFileService,
+                this.filesConfigurationService,
+                this.workingCopyBackupService,
+                this.workingCopyService,
+                this.notificationService,
+                this.workingCopyEditorService,
+                this.editorService,
+                this.elevatedFileService
+            ));
+            workingCopyResolve = workingCopy.resolve(resolveOptions);
+            this.registerWorkingCopy(workingCopy);
+        }
+        this.mapResourceToPendingWorkingCopyResolve.set(resource, workingCopyResolve);
+        this.add(resource, workingCopy);
+        if (didCreateWorkingCopy) {
+            if (workingCopy.isDirty()) {
+                this._onDidChangeDirty.fire(workingCopy);
+            }
+        }
+        try {
+            await workingCopyResolve;
+        }
+        catch (error) {
+            if (didCreateWorkingCopy) {
+                workingCopy.dispose();
+            }
+            throw error;
+        }
+        finally {
+            this.mapResourceToPendingWorkingCopyResolve.delete(resource);
+        }
+        if (didCreateWorkingCopy && workingCopy.isDirty()) {
+            this._onDidChangeDirty.fire(workingCopy);
+        }
+        return workingCopy;
+    }
+    joinPendingResolves(resource) {
+        const pendingWorkingCopyResolve = this.mapResourceToPendingWorkingCopyResolve.get(resource);
+        if (!pendingWorkingCopyResolve) {
+            return;
+        }
+        return this.doJoinPendingResolves(resource);
+    }
+    async doJoinPendingResolves(resource) {
+        let currentWorkingCopyResolve;
+        while (( this.mapResourceToPendingWorkingCopyResolve.has(resource))) {
+            const nextPendingWorkingCopyResolve = this.mapResourceToPendingWorkingCopyResolve.get(resource);
+            if (nextPendingWorkingCopyResolve === currentWorkingCopyResolve) {
+                return;
+            }
+            currentWorkingCopyResolve = nextPendingWorkingCopyResolve;
+            try {
+                await nextPendingWorkingCopyResolve;
+            }
+            catch (error) {
+            }
+        }
+    }
+    registerWorkingCopy(workingCopy) {
+        const workingCopyListeners = ( new DisposableStore());
+        workingCopyListeners.add(workingCopy.onDidResolve(() => this._onDidResolve.fire(workingCopy)));
+        workingCopyListeners.add(workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy)));
+        workingCopyListeners.add(workingCopy.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(workingCopy)));
+        workingCopyListeners.add(workingCopy.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(workingCopy)));
+        workingCopyListeners.add(workingCopy.onDidSaveError(() => this._onDidSaveError.fire(workingCopy)));
+        workingCopyListeners.add(workingCopy.onDidSave(e => this._onDidSave.fire({ workingCopy, ...e })));
+        workingCopyListeners.add(workingCopy.onDidRevert(() => this._onDidRevert.fire(workingCopy)));
+        this.mapResourceToWorkingCopyListeners.set(workingCopy.resource, workingCopyListeners);
+    }
+    remove(resource) {
+        const removed = super.remove(resource);
+        const workingCopyListener = this.mapResourceToWorkingCopyListeners.get(resource);
+        if (workingCopyListener) {
+            dispose(workingCopyListener);
+            this.mapResourceToWorkingCopyListeners.delete(resource);
+        }
+        if (removed) {
+            this._onDidRemove.fire(resource);
+        }
+        return removed;
+    }
+    canDispose(workingCopy) {
+        if (workingCopy.isDisposed() ||
+            (!( this.mapResourceToPendingWorkingCopyResolve.has(workingCopy.resource)) && !workingCopy.isDirty())) {
+            return true;
+        }
+        return this.doCanDispose(workingCopy);
+    }
+    async doCanDispose(workingCopy) {
+        const pendingResolve = this.joinPendingResolves(workingCopy.resource);
+        if (pendingResolve) {
+            await pendingResolve;
+            return this.canDispose(workingCopy);
+        }
+        if (workingCopy.isDirty()) {
+            await Event.toPromise(workingCopy.onDidChangeDirty);
+            return this.canDispose(workingCopy);
+        }
+        return true;
+    }
+    dispose() {
+        super.dispose();
+        this.mapResourceToPendingWorkingCopyResolve.clear();
+        dispose(( this.mapResourceToWorkingCopyListeners.values()));
+        this.mapResourceToWorkingCopyListeners.clear();
+    }
+};
+StoredFileWorkingCopyManager = ( __decorate([
+    ( __param(2, IFileService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IWorkingCopyFileService)),
+    ( __param(7, IWorkingCopyBackupService)),
+    ( __param(8, IUriIdentityService)),
+    ( __param(9, IFilesConfigurationService)),
+    ( __param(10, IWorkingCopyService)),
+    ( __param(11, INotificationService)),
+    ( __param(12, IWorkingCopyEditorService)),
+    ( __param(13, IEditorService)),
+    ( __param(14, IElevatedFileService))
+], StoredFileWorkingCopyManager));
+
+export { StoredFileWorkingCopyManager };

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

@@ -0,0 +1,144 @@
+import { __decorate, __param } from '../../../../../../../external/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 { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { emptyStream } from 'monaco-editor/esm/vs/base/common/stream.js';
+
+let UntitledFileWorkingCopy = class UntitledFileWorkingCopy extends Disposable {
+    get model() { return this._model; }
+    constructor(typeId, resource, name, hasAssociatedFilePath, isScratchpad, initialContents, modelFactory, saveDelegate, workingCopyService, workingCopyBackupService, logService) {
+        super();
+        this.typeId = typeId;
+        this.resource = resource;
+        this.name = name;
+        this.hasAssociatedFilePath = hasAssociatedFilePath;
+        this.isScratchpad = isScratchpad;
+        this.initialContents = initialContents;
+        this.modelFactory = modelFactory;
+        this.saveDelegate = saveDelegate;
+        this.workingCopyBackupService = workingCopyBackupService;
+        this.logService = logService;
+        this.capabilities = this.isScratchpad ? 2  | 4  : 2 ;
+        this._model = undefined;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidSave = this._register(( new Emitter()));
+        this.onDidSave = this._onDidSave.event;
+        this._onDidRevert = this._register(( new Emitter()));
+        this.onDidRevert = this._onDidRevert.event;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this.modified = this.hasAssociatedFilePath || Boolean(this.initialContents && this.initialContents.markModified !== false);
+        this._register(workingCopyService.registerWorkingCopy(this));
+    }
+    isDirty() {
+        return this.modified && !this.isScratchpad;
+    }
+    isModified() {
+        return this.modified;
+    }
+    setModified(modified) {
+        if (this.modified === modified) {
+            return;
+        }
+        this.modified = modified;
+        if (!this.isScratchpad) {
+            this._onDidChangeDirty.fire();
+        }
+    }
+    async resolve() {
+        this.trace('resolve()');
+        if (this.isResolved()) {
+            this.trace('resolve() - exit (already resolved)');
+            return;
+        }
+        let untitledContents;
+        const backup = await this.workingCopyBackupService.resolve(this);
+        if (backup) {
+            this.trace('resolve() - with backup');
+            untitledContents = backup.value;
+        }
+        else if (this.initialContents?.value) {
+            this.trace('resolve() - with initial contents');
+            untitledContents = this.initialContents.value;
+        }
+        else {
+            this.trace('resolve() - empty');
+            untitledContents = emptyStream();
+        }
+        await this.doCreateModel(untitledContents);
+        this.setModified(this.hasAssociatedFilePath || !!backup || Boolean(this.initialContents && this.initialContents.markModified !== false));
+        if (!!backup || this.initialContents) {
+            this._onDidChangeContent.fire();
+        }
+    }
+    async doCreateModel(contents) {
+        this.trace('doCreateModel()');
+        this._model = this._register(await this.modelFactory.createModel(this.resource, contents, CancellationToken.None));
+        this.installModelListeners(this._model);
+    }
+    installModelListeners(model) {
+        this._register(model.onDidChangeContent(e => this.onModelContentChanged(e)));
+        this._register(model.onWillDispose(() => this.dispose()));
+    }
+    onModelContentChanged(e) {
+        if (!this.hasAssociatedFilePath && e.isInitial) {
+            this.setModified(false);
+        }
+        else {
+            this.setModified(true);
+        }
+        this._onDidChangeContent.fire();
+    }
+    isResolved() {
+        return !!this.model;
+    }
+    get backupDelay() {
+        return this.model?.configuration?.backupDelay;
+    }
+    async backup(token) {
+        let content = undefined;
+        if (this.isResolved()) {
+            content = await raceCancellation(this.model.snapshot(token), token);
+        }
+        else if (this.initialContents) {
+            content = this.initialContents.value;
+        }
+        return { content };
+    }
+    async save(options) {
+        this.trace('save()');
+        const result = await this.saveDelegate(this, options);
+        if (result) {
+            this._onDidSave.fire({ reason: options?.reason, source: options?.source });
+        }
+        return result;
+    }
+    async revert() {
+        this.trace('revert()');
+        this.setModified(false);
+        this._onDidRevert.fire();
+        this.dispose();
+    }
+    dispose() {
+        this.trace('dispose()');
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+    trace(msg) {
+        this.logService.trace(`[untitled file working copy] ${msg}`, ( this.resource.toString()), this.typeId);
+    }
+};
+UntitledFileWorkingCopy = ( __decorate([
+    ( __param(8, IWorkingCopyService)),
+    ( __param(9, IWorkingCopyBackupService)),
+    ( __param(10, ILogService))
+], UntitledFileWorkingCopy));
+
+export { UntitledFileWorkingCopy };

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

@@ -0,0 +1,129 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { UntitledFileWorkingCopy } from './untitledFileWorkingCopy.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { BaseFileWorkingCopyManager } from './abstractFileWorkingCopyManager.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+
+let UntitledFileWorkingCopyManager = class UntitledFileWorkingCopyManager extends BaseFileWorkingCopyManager {
+    constructor(workingCopyTypeId, modelFactory, saveDelegate, fileService, labelService, logService, workingCopyBackupService, workingCopyService) {
+        super(fileService, logService, workingCopyBackupService);
+        this.workingCopyTypeId = workingCopyTypeId;
+        this.modelFactory = modelFactory;
+        this.saveDelegate = saveDelegate;
+        this.labelService = labelService;
+        this.workingCopyService = workingCopyService;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this.mapResourceToWorkingCopyListeners = ( new ResourceMap());
+    }
+    async resolve(options) {
+        const workingCopy = this.doCreateOrGet(options);
+        await workingCopy.resolve();
+        return workingCopy;
+    }
+    doCreateOrGet(options = Object.create(null)) {
+        const massagedOptions = this.massageOptions(options);
+        if (massagedOptions.untitledResource) {
+            const existingWorkingCopy = this.get(massagedOptions.untitledResource);
+            if (existingWorkingCopy) {
+                return existingWorkingCopy;
+            }
+        }
+        return this.doCreate(massagedOptions);
+    }
+    massageOptions(options) {
+        const massagedOptions = Object.create(null);
+        if (options.associatedResource) {
+            massagedOptions.untitledResource = ( URI.from({
+                scheme: Schemas.untitled,
+                authority: options.associatedResource.authority,
+                fragment: options.associatedResource.fragment,
+                path: options.associatedResource.path,
+                query: options.associatedResource.query
+            }));
+            massagedOptions.associatedResource = options.associatedResource;
+        }
+        else {
+            if (options.untitledResource?.scheme === Schemas.untitled) {
+                massagedOptions.untitledResource = options.untitledResource;
+            }
+            massagedOptions.isScratchpad = options.isScratchpad;
+        }
+        massagedOptions.contents = options.contents;
+        return massagedOptions;
+    }
+    doCreate(options) {
+        let untitledResource = options.untitledResource;
+        if (!untitledResource) {
+            let counter = 1;
+            do {
+                untitledResource = ( URI.from({
+                    scheme: Schemas.untitled,
+                    path: options.isScratchpad ? `Scratchpad-${counter}` : `Untitled-${counter}`,
+                    query: this.workingCopyTypeId ?
+                        `typeId=${this.workingCopyTypeId}` :
+                        undefined
+                }));
+                counter++;
+            } while (( this.has(untitledResource)));
+        }
+        const workingCopy = ( new UntitledFileWorkingCopy(
+            this.workingCopyTypeId,
+            untitledResource,
+            this.labelService.getUriBasenameLabel(untitledResource),
+            !!options.associatedResource,
+            !!options.isScratchpad,
+            options.contents,
+            this.modelFactory,
+            this.saveDelegate,
+            this.workingCopyService,
+            this.workingCopyBackupService,
+            this.logService
+        ));
+        this.registerWorkingCopy(workingCopy);
+        return workingCopy;
+    }
+    registerWorkingCopy(workingCopy) {
+        const workingCopyListeners = ( new DisposableStore());
+        workingCopyListeners.add(workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy)));
+        workingCopyListeners.add(workingCopy.onWillDispose(() => this._onWillDispose.fire(workingCopy)));
+        this.mapResourceToWorkingCopyListeners.set(workingCopy.resource, workingCopyListeners);
+        this.add(workingCopy.resource, workingCopy);
+        if (workingCopy.isDirty()) {
+            this._onDidChangeDirty.fire(workingCopy);
+        }
+    }
+    remove(resource) {
+        const removed = super.remove(resource);
+        const workingCopyListener = this.mapResourceToWorkingCopyListeners.get(resource);
+        if (workingCopyListener) {
+            dispose(workingCopyListener);
+            this.mapResourceToWorkingCopyListeners.delete(resource);
+        }
+        return removed;
+    }
+    dispose() {
+        super.dispose();
+        dispose(( this.mapResourceToWorkingCopyListeners.values()));
+        this.mapResourceToWorkingCopyListeners.clear();
+    }
+};
+UntitledFileWorkingCopyManager = ( __decorate([
+    ( __param(3, IFileService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IWorkingCopyBackupService)),
+    ( __param(7, IWorkingCopyService))
+], UntitledFileWorkingCopyManager));
+
+export { UntitledFileWorkingCopyManager };

package/worker.js

@@ -0,0 +1 @@
+import './workers/notebook.worker.js';