@codingame/monaco-vscode-api 4.4.1 → 4.5.0-improve-code-splitting.1

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

@@ -1,40 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
-import { IEditorService } from '../../editor/common/editorService.js';
-const IWorkingCopyEditorService = ( createDecorator('workingCopyEditorService'));
-let WorkingCopyEditorService = class WorkingCopyEditorService extends Disposable {
-    constructor(editorService) {
-        super();
-        this.editorService = editorService;
-        this._onDidRegisterHandler = this._register(( new Emitter()));
-        this.onDidRegisterHandler = this._onDidRegisterHandler.event;
-        this.handlers = ( new Set());
-    }
-    registerHandler(handler) {
-        this.handlers.add(handler);
-        this._onDidRegisterHandler.fire(handler);
-        return toDisposable(() => this.handlers.delete(handler));
-    }
-    findEditor(workingCopy) {
-        for (const editorIdentifier of this.editorService.getEditors(0 )) {
-            if (this.isOpen(workingCopy, editorIdentifier.editor)) {
-                return editorIdentifier;
-            }
-        }
-        return undefined;
-    }
-    isOpen(workingCopy, editor) {
-        for (const handler of this.handlers) {
-            if (handler.isOpen(workingCopy, editor)) {
-                return true;
-            }
-        }
-        return false;
-    }
-};
-WorkingCopyEditorService = ( __decorate([
-    ( __param(0, IEditorService))
-], WorkingCopyEditorService));
-export { IWorkingCopyEditorService, WorkingCopyEditorService };

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

@@ -1,40 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { LinkedList } from '../../../../base/common/linkedList.js';
-let WorkingCopyFileOperationParticipant = class WorkingCopyFileOperationParticipant extends Disposable {
-    constructor(logService, configurationService) {
-        super();
-        this.logService = logService;
-        this.configurationService = configurationService;
-        this.participants = ( new LinkedList());
-    }
-    addFileOperationParticipant(participant) {
-        const remove = this.participants.push(participant);
-        return toDisposable(() => remove());
-    }
-    async participate(files, operation, undoInfo, token) {
-        const timeout = this.configurationService.getValue('files.participants.timeout');
-        if (typeof timeout !== 'number' || timeout <= 0) {
-            return;
-        }
-        for (const participant of this.participants) {
-            try {
-                await participant.participate(files, operation, undoInfo, timeout, token);
-            }
-            catch (err) {
-                this.logService.warn(err);
-            }
-        }
-    }
-    dispose() {
-        this.participants.clear();
-        super.dispose();
-    }
-};
-WorkingCopyFileOperationParticipant = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IConfigurationService))
-], WorkingCopyFileOperationParticipant));
-export { WorkingCopyFileOperationParticipant };

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

@@ -1,181 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { AsyncEmitter } from '../../../../base/common/event.js';
-import { Promises } from '../../../../base/common/async.js';
-import { insert } from '../../../../base/common/arrays.js';
-import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
-import { IWorkingCopyService } from './workingCopyService.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { WorkingCopyFileOperationParticipant } from './workingCopyFileOperationParticipant.js';
-import { StoredFileWorkingCopySaveParticipant } from './storedFileWorkingCopySaveParticipant.js';
-const IWorkingCopyFileService = ( createDecorator('workingCopyFileService'));
-let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
-    constructor(fileService, workingCopyService, instantiationService, uriIdentityService) {
-        super();
-        this.fileService = fileService;
-        this.workingCopyService = workingCopyService;
-        this.instantiationService = instantiationService;
-        this.uriIdentityService = uriIdentityService;
-        this._onWillRunWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
-        this.onWillRunWorkingCopyFileOperation = this._onWillRunWorkingCopyFileOperation.event;
-        this._onDidFailWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
-        this.onDidFailWorkingCopyFileOperation = this._onDidFailWorkingCopyFileOperation.event;
-        this._onDidRunWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
-        this.onDidRunWorkingCopyFileOperation = this._onDidRunWorkingCopyFileOperation.event;
-        this.correlationIds = 0;
-        this.fileOperationParticipants = this._register(this.instantiationService.createInstance(WorkingCopyFileOperationParticipant));
-        this.saveParticipants = this._register(this.instantiationService.createInstance(StoredFileWorkingCopySaveParticipant));
-        this.workingCopyProviders = [];
-        this._register(this.registerWorkingCopyProvider(resource => {
-            return this.workingCopyService.workingCopies.filter(workingCopy => {
-                if (this.fileService.hasProvider(resource)) {
-                    return this.uriIdentityService.extUri.isEqualOrParent(workingCopy.resource, resource);
-                }
-                return this.uriIdentityService.extUri.isEqual(workingCopy.resource, resource);
-            });
-        }));
-    }
-    create(operations, token, undoInfo) {
-        return this.doCreateFileOrFolder(operations, true, token, undoInfo);
-    }
-    createFolder(operations, token, undoInfo) {
-        return this.doCreateFileOrFolder(operations, false, token, undoInfo);
-    }
-    async doCreateFileOrFolder(operations, isFile, token, undoInfo) {
-        if (operations.length === 0) {
-            return [];
-        }
-        if (isFile) {
-            const validateCreates = await Promises.settled(( operations.map(
-                operation => this.fileService.canCreateFile(operation.resource, { overwrite: operation.overwrite })
-            )));
-            const error = validateCreates.find(validateCreate => validateCreate instanceof Error);
-            if (error instanceof Error) {
-                throw error;
-            }
-        }
-        const files = ( operations.map(operation => ({ target: operation.resource })));
-        await this.runFileOperationParticipants(files, 0 , undoInfo, token);
-        const event = { correlationId: this.correlationIds++, operation: 0 , files };
-        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-        let stats;
-        try {
-            if (isFile) {
-                stats = await Promises.settled(( operations.map(
-                    operation => this.fileService.createFile(operation.resource, operation.contents, { overwrite: operation.overwrite })
-                )));
-            }
-            else {
-                stats = await Promises.settled(( operations.map(operation => this.fileService.createFolder(operation.resource))));
-            }
-        }
-        catch (error) {
-            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-            throw error;
-        }
-        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-        return stats;
-    }
-    async move(operations, token, undoInfo) {
-        return this.doMoveOrCopy(operations, true, token, undoInfo);
-    }
-    async copy(operations, token, undoInfo) {
-        return this.doMoveOrCopy(operations, false, token, undoInfo);
-    }
-    async doMoveOrCopy(operations, move, token, undoInfo) {
-        const stats = [];
-        for (const { file: { source, target }, overwrite } of operations) {
-            const validateMoveOrCopy = await (move ? this.fileService.canMove(source, target, overwrite) : this.fileService.canCopy(source, target, overwrite));
-            if (validateMoveOrCopy instanceof Error) {
-                throw validateMoveOrCopy;
-            }
-        }
-        const files = ( operations.map(o => o.file));
-        await this.runFileOperationParticipants(files, move ? 2  : 3 , undoInfo, token);
-        const event = { correlationId: this.correlationIds++, operation: move ? 2  : 3 , files };
-        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-        try {
-            for (const { file: { source, target }, overwrite } of operations) {
-                if (!this.uriIdentityService.extUri.isEqual(source, target)) {
-                    const dirtyWorkingCopies = (move ? [...this.getDirty(source), ...this.getDirty(target)] : this.getDirty(target));
-                    await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true }))));
-                }
-                if (move) {
-                    stats.push(await this.fileService.move(source, target, overwrite));
-                }
-                else {
-                    stats.push(await this.fileService.copy(source, target, overwrite));
-                }
-            }
-        }
-        catch (error) {
-            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-            throw error;
-        }
-        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-        return stats;
-    }
-    async delete(operations, token, undoInfo) {
-        for (const operation of operations) {
-            const validateDelete = await this.fileService.canDelete(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
-            if (validateDelete instanceof Error) {
-                throw validateDelete;
-            }
-        }
-        const files = ( operations.map(operation => ({ target: operation.resource })));
-        await this.runFileOperationParticipants(files, 1 , undoInfo, token);
-        const event = { correlationId: this.correlationIds++, operation: 1 , files };
-        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-        for (const operation of operations) {
-            const dirtyWorkingCopies = this.getDirty(operation.resource);
-            await Promises.settled(( dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true }))));
-        }
-        try {
-            for (const operation of operations) {
-                await this.fileService.del(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
-            }
-        }
-        catch (error) {
-            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-            throw error;
-        }
-        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
-    }
-    addFileOperationParticipant(participant) {
-        return this.fileOperationParticipants.addFileOperationParticipant(participant);
-    }
-    runFileOperationParticipants(files, operation, undoInfo, token) {
-        return this.fileOperationParticipants.participate(files, operation, undoInfo, token);
-    }
-    get hasSaveParticipants() { return this.saveParticipants.length > 0; }
-    addSaveParticipant(participant) {
-        return this.saveParticipants.addSaveParticipant(participant);
-    }
-    runSaveParticipants(workingCopy, context, token) {
-        return this.saveParticipants.participate(workingCopy, context, token);
-    }
-    registerWorkingCopyProvider(provider) {
-        const remove = insert(this.workingCopyProviders, provider);
-        return toDisposable(remove);
-    }
-    getDirty(resource) {
-        const dirtyWorkingCopies = ( new Set());
-        for (const provider of this.workingCopyProviders) {
-            for (const workingCopy of provider(resource)) {
-                if (workingCopy.isDirty()) {
-                    dirtyWorkingCopies.add(workingCopy);
-                }
-            }
-        }
-        return Array.from(dirtyWorkingCopies);
-    }
-};
-WorkingCopyFileService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IWorkingCopyService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IUriIdentityService))
-], WorkingCopyFileService));
-export { IWorkingCopyFileService, WorkingCopyFileService };

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

@@ -1,126 +0,0 @@
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { URI } from '../../../../base/common/uri.js';
-import { Disposable, DisposableMap, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { ResourceMap } from '../../../../base/common/map.js';
-const IWorkingCopyService = ( createDecorator('workingCopyService'));
-class WorkingCopyService extends Disposable {
-    constructor() {
-        super(...arguments);
-        this._onDidRegister = this._register(( new Emitter()));
-        this.onDidRegister = this._onDidRegister.event;
-        this._onDidUnregister = this._register(( new Emitter()));
-        this.onDidUnregister = this._onDidUnregister.event;
-        this._onDidChangeDirty = this._register(( new Emitter()));
-        this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeContent = this._register(( new Emitter()));
-        this.onDidChangeContent = this._onDidChangeContent.event;
-        this._onDidSave = this._register(( new Emitter()));
-        this.onDidSave = this._onDidSave.event;
-        this._workingCopies = ( new Set());
-        this.mapResourceToWorkingCopies = ( new ResourceMap());
-        this.mapWorkingCopyToListeners = this._register(( new DisposableMap()));
-    }
-    get workingCopies() { return Array.from(( this._workingCopies.values())); }
-    registerWorkingCopy(workingCopy) {
-        let workingCopiesForResource = this.mapResourceToWorkingCopies.get(workingCopy.resource);
-        if (workingCopiesForResource?.has(workingCopy.typeId)) {
-            throw new Error(`Cannot register more than one working copy with the same resource ${workingCopy.resource.toString()} and type ${workingCopy.typeId}.`);
-        }
-        this._workingCopies.add(workingCopy);
-        if (!workingCopiesForResource) {
-            workingCopiesForResource = ( new Map());
-            this.mapResourceToWorkingCopies.set(workingCopy.resource, workingCopiesForResource);
-        }
-        workingCopiesForResource.set(workingCopy.typeId, workingCopy);
-        const disposables = ( new DisposableStore());
-        disposables.add(workingCopy.onDidChangeContent(() => this._onDidChangeContent.fire(workingCopy)));
-        disposables.add(workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy)));
-        disposables.add(workingCopy.onDidSave(e => this._onDidSave.fire({ workingCopy, ...e })));
-        this.mapWorkingCopyToListeners.set(workingCopy, disposables);
-        this._onDidRegister.fire(workingCopy);
-        if (workingCopy.isDirty()) {
-            this._onDidChangeDirty.fire(workingCopy);
-        }
-        return toDisposable(() => {
-            this.unregisterWorkingCopy(workingCopy);
-            this._onDidUnregister.fire(workingCopy);
-        });
-    }
-    unregisterWorkingCopy(workingCopy) {
-        this._workingCopies.delete(workingCopy);
-        const workingCopiesForResource = this.mapResourceToWorkingCopies.get(workingCopy.resource);
-        if (workingCopiesForResource?.delete(workingCopy.typeId) && workingCopiesForResource.size === 0) {
-            this.mapResourceToWorkingCopies.delete(workingCopy.resource);
-        }
-        if (workingCopy.isDirty()) {
-            this._onDidChangeDirty.fire(workingCopy);
-        }
-        this.mapWorkingCopyToListeners.deleteAndDispose(workingCopy);
-    }
-    has(resourceOrIdentifier) {
-        if (URI.isUri(resourceOrIdentifier)) {
-            return ( this.mapResourceToWorkingCopies.has(resourceOrIdentifier));
-        }
-        return this.mapResourceToWorkingCopies.get(resourceOrIdentifier.resource)?.has(resourceOrIdentifier.typeId) ?? false;
-    }
-    get(identifier) {
-        return this.mapResourceToWorkingCopies.get(identifier.resource)?.get(identifier.typeId);
-    }
-    getAll(resource) {
-        const workingCopies = this.mapResourceToWorkingCopies.get(resource);
-        if (!workingCopies) {
-            return undefined;
-        }
-        return Array.from(( workingCopies.values()));
-    }
-    get hasDirty() {
-        for (const workingCopy of this._workingCopies) {
-            if (workingCopy.isDirty()) {
-                return true;
-            }
-        }
-        return false;
-    }
-    get dirtyCount() {
-        let totalDirtyCount = 0;
-        for (const workingCopy of this._workingCopies) {
-            if (workingCopy.isDirty()) {
-                totalDirtyCount++;
-            }
-        }
-        return totalDirtyCount;
-    }
-    get dirtyWorkingCopies() {
-        return this.workingCopies.filter(workingCopy => workingCopy.isDirty());
-    }
-    get modifiedCount() {
-        let totalModifiedCount = 0;
-        for (const workingCopy of this._workingCopies) {
-            if (workingCopy.isModified()) {
-                totalModifiedCount++;
-            }
-        }
-        return totalModifiedCount;
-    }
-    get modifiedWorkingCopies() {
-        return this.workingCopies.filter(workingCopy => workingCopy.isModified());
-    }
-    isDirty(resource, typeId) {
-        const workingCopies = this.mapResourceToWorkingCopies.get(resource);
-        if (workingCopies) {
-            if (typeof typeId === 'string') {
-                return workingCopies.get(typeId)?.isDirty() ?? false;
-            }
-            else {
-                for (const [, workingCopy] of workingCopies) {
-                    if (workingCopy.isDirty()) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-}
-export { IWorkingCopyService, WorkingCopyService };

package/vscode/src/vs/workbench/services/workspaces/common/workspaceIdentityService.js

@@ -1,102 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { VSBuffer } from '../../../../base/common/buffer.js';
-import { isEqualOrParent, relativePath, joinPath } from '../../../../base/common/resources.js';
-import { URI } from '../../../../base/common/uri.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { EditSessionIdentityMatch, IEditSessionIdentityService } from '../../../../platform/workspace/common/editSessions.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-const IWorkspaceIdentityService = ( createDecorator('IWorkspaceIdentityService'));
-let WorkspaceIdentityService = class WorkspaceIdentityService {
-    constructor(workspaceContextService, editSessionIdentityService) {
-        this.workspaceContextService = workspaceContextService;
-        this.editSessionIdentityService = editSessionIdentityService;
-    }
-    async getWorkspaceStateFolders(cancellationToken) {
-        const workspaceStateFolders = [];
-        for (const workspaceFolder of this.workspaceContextService.getWorkspace().folders) {
-            const workspaceFolderIdentity = await this.editSessionIdentityService.getEditSessionIdentifier(workspaceFolder, cancellationToken);
-            if (!workspaceFolderIdentity) {
-                continue;
-            }
-            workspaceStateFolders.push({ resourceUri: ( workspaceFolder.uri.toString()), workspaceFolderIdentity });
-        }
-        return workspaceStateFolders;
-    }
-    async matches(incomingWorkspaceFolders, cancellationToken) {
-        const incomingToCurrentWorkspaceFolderUris = {};
-        const incomingIdentitiesToIncomingWorkspaceFolders = {};
-        for (const workspaceFolder of incomingWorkspaceFolders) {
-            incomingIdentitiesToIncomingWorkspaceFolders[workspaceFolder.workspaceFolderIdentity] = workspaceFolder.resourceUri;
-        }
-        const currentWorkspaceFoldersToIdentities = ( new Map());
-        for (const workspaceFolder of this.workspaceContextService.getWorkspace().folders) {
-            const workspaceFolderIdentity = await this.editSessionIdentityService.getEditSessionIdentifier(workspaceFolder, cancellationToken);
-            if (!workspaceFolderIdentity) {
-                continue;
-            }
-            currentWorkspaceFoldersToIdentities.set(workspaceFolder, workspaceFolderIdentity);
-        }
-        for (const [currentWorkspaceFolder, currentWorkspaceFolderIdentity] of currentWorkspaceFoldersToIdentities.entries()) {
-            const incomingWorkspaceFolder = incomingIdentitiesToIncomingWorkspaceFolders[currentWorkspaceFolderIdentity];
-            if (incomingWorkspaceFolder) {
-                incomingToCurrentWorkspaceFolderUris[incomingWorkspaceFolder] = ( currentWorkspaceFolder.uri.toString());
-                continue;
-            }
-            let hasCompleteMatch = false;
-            for (const [incomingIdentity, incomingFolder] of Object.entries(incomingIdentitiesToIncomingWorkspaceFolders)) {
-                if ((await this.editSessionIdentityService.provideEditSessionIdentityMatch(currentWorkspaceFolder, currentWorkspaceFolderIdentity, incomingIdentity, cancellationToken)) === EditSessionIdentityMatch.Complete) {
-                    incomingToCurrentWorkspaceFolderUris[incomingFolder] = ( currentWorkspaceFolder.uri.toString());
-                    hasCompleteMatch = true;
-                    break;
-                }
-            }
-            if (hasCompleteMatch) {
-                continue;
-            }
-            return false;
-        }
-        const convertUri = (uriToConvert) => {
-            for (const incomingFolderUriKey of ( Object.keys(incomingToCurrentWorkspaceFolderUris))) {
-                const incomingFolderUri = ( URI.parse(incomingFolderUriKey));
-                if (isEqualOrParent(incomingFolderUri, uriToConvert)) {
-                    const currentWorkspaceFolderUri = incomingToCurrentWorkspaceFolderUris[incomingFolderUriKey];
-                    const relativeFilePath = relativePath(incomingFolderUri, uriToConvert);
-                    if (relativeFilePath) {
-                        return joinPath(( URI.parse(currentWorkspaceFolderUri)), relativeFilePath);
-                    }
-                }
-            }
-            return uriToConvert;
-        };
-        const uriReplacer = (obj, depth = 0) => {
-            if (!obj || depth > 200) {
-                return obj;
-            }
-            if (obj instanceof VSBuffer || obj instanceof Uint8Array) {
-                return obj;
-            }
-            if (URI.isUri(obj)) {
-                return convertUri(obj);
-            }
-            if (Array.isArray(obj)) {
-                for (let i = 0; i < obj.length; ++i) {
-                    obj[i] = uriReplacer(obj[i], depth + 1);
-                }
-            }
-            else {
-                for (const key in obj) {
-                    if (Object.hasOwnProperty.call(obj, key)) {
-                        obj[key] = uriReplacer(obj[key], depth + 1);
-                    }
-                }
-            }
-            return obj;
-        };
-        return uriReplacer;
-    }
-};
-WorkspaceIdentityService = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IEditSessionIdentityService))
-], WorkspaceIdentityService));
-export { IWorkspaceIdentityService, WorkspaceIdentityService };