@codingame/monaco-vscode-notebook-service-override 3.2.3 → 4.1.0

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

@@ -1,408 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { StoredFileWorkingCopy } from 'vscode/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { ResourceQueue, Promises } from 'vscode/vscode/vs/base/common/async';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { joinPath } from 'vscode/vscode/vs/base/common/resources';
-import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
-import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
-import { BaseFileWorkingCopyManager } from './abstractFileWorkingCopyManager.js';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-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 'vscode/vscode/vs/base/common/platform';
-import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-
-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 queueSize = this.workingCopyResolveQueue.queueSize(workingCopy.resource);
-        if (queueSize <= 1) {
-            this.workingCopyResolveQueue.queueFor(workingCopy.resource, 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,
-            limits: options?.limits
-        };
-        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

@@ -1,144 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
-import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
-import { emptyStream } from 'vscode/vscode/vs/base/common/stream';
-
-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

@@ -1,129 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { UntitledFileWorkingCopy } from './untitledFileWorkingCopy.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { BaseFileWorkingCopyManager } from './abstractFileWorkingCopyManager.js';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-
-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 };