@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/api/browser/mainThreadExtensionService.js

@@ -0,0 +1,213 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { areSameExtensions } from '../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { IExtensionsWorkbenchService } from '../../contrib/extensions/common/extensions.js';
+import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
+import { IWorkbenchExtensionEnablementService } from '../../services/extensionManagement/common/extensionManagement.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IHostService } from '../../services/host/browser/host.js';
+import { ITimerService } from '../../services/timer/browser/timerService.js';
+let MainThreadExtensionService = class MainThreadExtensionService {
+    constructor(extHostContext, _extensionService, _notificationService, _extensionsWorkbenchService, _hostService, _extensionEnablementService, _timerService, _commandService, _environmentService) {
+        this._extensionService = _extensionService;
+        this._notificationService = _notificationService;
+        this._extensionsWorkbenchService = _extensionsWorkbenchService;
+        this._hostService = _hostService;
+        this._extensionEnablementService = _extensionEnablementService;
+        this._timerService = _timerService;
+        this._commandService = _commandService;
+        this._environmentService = _environmentService;
+        this._extensionHostKind = extHostContext.extensionHostKind;
+        const internalExtHostContext = extHostContext;
+        this._internalExtensionService = internalExtHostContext.internalExtensionService;
+    }
+    dispose() {
+    }
+    $getExtension(extensionId) {
+        return this._extensionService.getExtension(extensionId);
+    }
+    $activateExtension(extensionId, reason) {
+        return this._internalExtensionService._activateById(extensionId, reason);
+    }
+    async $onWillActivateExtension(extensionId) {
+        this._internalExtensionService._onWillActivateExtension(extensionId);
+    }
+    $onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason) {
+        this._internalExtensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
+    }
+    $onExtensionRuntimeError(extensionId, data) {
+        const error = ( new Error());
+        error.name = data.name;
+        error.message = data.message;
+        error.stack = data.stack;
+        this._internalExtensionService._onExtensionRuntimeError(extensionId, error);
+        console.error(`[${extensionId}]${error.message}`);
+        console.error(error.stack);
+    }
+    async $onExtensionActivationError(extensionId, data, missingExtensionDependency) {
+        const error = ( new Error());
+        error.name = data.name;
+        error.message = data.message;
+        error.stack = data.stack;
+        this._internalExtensionService._onDidActivateExtensionError(extensionId, error);
+        if (missingExtensionDependency) {
+            const extension = await this._extensionService.getExtension(extensionId.value);
+            if (extension) {
+                const local = await this._extensionsWorkbenchService.queryLocal();
+                const installedDependency = local.find(i => areSameExtensions(i.identifier, { id: missingExtensionDependency.dependency }));
+                if (installedDependency?.local) {
+                    await this._handleMissingInstalledDependency(extension, installedDependency.local);
+                    return;
+                }
+                else {
+                    await this._handleMissingNotInstalledDependency(extension, missingExtensionDependency.dependency);
+                    return;
+                }
+            }
+        }
+        const isDev = !this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment;
+        if (isDev) {
+            this._notificationService.error(error);
+            return;
+        }
+        console.error(error.message);
+    }
+    async _handleMissingInstalledDependency(extension, missingInstalledDependency) {
+        const extName = extension.displayName || extension.name;
+        if (this._extensionEnablementService.isEnabled(missingInstalledDependency)) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    'reload window',
+                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
+                    extName,
+                    missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
+                )),
+                actions: {
+                    primary: [( new Action('reload', ( localize('reload', "Reload Window")), '', true, () => this._hostService.reload()))]
+                }
+            });
+        }
+        else {
+            const enablementState = this._extensionEnablementService.getEnablementState(missingInstalledDependency);
+            if (enablementState === 4 ) {
+                this._notificationService.notify({
+                    severity: Severity.Error,
+                    message: ( localize(
+                        'notSupportedInWorkspace',
+                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
+                        extName,
+                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
+                    )),
+                });
+            }
+            else if (enablementState === 0 ) {
+                this._notificationService.notify({
+                    severity: Severity.Error,
+                    message: ( localize(
+                        'restrictedMode',
+                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
+                        extName,
+                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
+                    )),
+                    actions: {
+                        primary: [( new Action('manageWorkspaceTrust', ( localize('manageWorkspaceTrust', "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage')))]
+                    }
+                });
+            }
+            else if (this._extensionEnablementService.canChangeEnablement(missingInstalledDependency)) {
+                this._notificationService.notify({
+                    severity: Severity.Error,
+                    message: ( localize(
+                        'disabledDep',
+                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
+                        extName,
+                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
+                    )),
+                    actions: {
+                        primary: [( new Action('enable', ( localize('enable dep', "Enable and Reload")), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 6  ? 8  : 9 )
+                                .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
+                    }
+                });
+            }
+            else {
+                this._notificationService.notify({
+                    severity: Severity.Error,
+                    message: ( localize(
+                        'disabledDepNoAction',
+                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
+                        extName,
+                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
+                    )),
+                });
+            }
+        }
+    }
+    async _handleMissingNotInstalledDependency(extension, missingDependency) {
+        const extName = extension.displayName || extension.name;
+        let dependencyExtension = null;
+        try {
+            dependencyExtension = (await this._extensionsWorkbenchService.getExtensions([{ id: missingDependency }], CancellationToken.None))[0];
+        }
+        catch (err) {
+        }
+        if (dependencyExtension) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    'uninstalledDep',
+                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not installed. Would you like to install the extension and reload the window?",
+                    extName,
+                    dependencyExtension.displayName
+                )),
+                actions: {
+                    primary: [( new Action('install', ( localize('install missing dep', "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
+                            .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
+                }
+            });
+        }
+        else {
+            this._notificationService.error(( localize(
+                'unknownDep',
+                "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
+                extName,
+                missingDependency
+            )));
+        }
+    }
+    async $setPerformanceMarks(marks) {
+        if (this._extensionHostKind === 1 ) {
+            this._timerService.setPerformanceMarks('localExtHost', marks);
+        }
+        else if (this._extensionHostKind === 2 ) {
+            this._timerService.setPerformanceMarks('workerExtHost', marks);
+        }
+        else {
+            this._timerService.setPerformanceMarks('remoteExtHost', marks);
+        }
+    }
+    async $asBrowserUri(uri) {
+        return FileAccess.uriToBrowserUri(URI.revive(uri));
+    }
+};
+MainThreadExtensionService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadExtensionService),
+    ( __param(1, IExtensionService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IExtensionsWorkbenchService)),
+    ( __param(4, IHostService)),
+    ( __param(5, IWorkbenchExtensionEnablementService)),
+    ( __param(6, ITimerService)),
+    ( __param(7, ICommandService)),
+    ( __param(8, IWorkbenchEnvironmentService))
+], MainThreadExtensionService);
+export { MainThreadExtensionService };

package/dist/vscode/vs/workbench/api/browser/mainThreadFileSystem.js

@@ -0,0 +1,270 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableMap, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { FilePermission, FileSystemProviderErrorCode, FileOperationError, toFileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkbenchFileService } from '../../services/files/common/files.js';
+import { normalizeWatcherPattern } from '../../../platform/files/common/watcher.js';
+import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
+var MainThreadFileSystem_1;
+let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
+    constructor(extHostContext, _fileService, _contextService, _logService, _configurationService) {
+        this._fileService = _fileService;
+        this._contextService = _contextService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
+        this._fileProvider = ( (new DisposableMap()));
+        this._disposables = ( (new DisposableStore()));
+        this._watches = ( (new DisposableMap()));
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostFileSystem)));
+        const infoProxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostFileSystemInfo)));
+        for (const entry of _fileService.listCapabilities()) {
+            infoProxy.$acceptProviderInfos(( (URI.from({ scheme: entry.scheme, path: '/dummy' }))), entry.capabilities);
+        }
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(e => infoProxy.$acceptProviderInfos(( (URI.from({ scheme: e.scheme, path: '/dummy' }))), e.provider?.capabilities ?? null)));
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderCapabilities(e => infoProxy.$acceptProviderInfos(( (URI.from({ scheme: e.scheme, path: '/dummy' }))), e.provider.capabilities)));
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._fileProvider.dispose();
+        this._watches.dispose();
+    }
+    async $registerFileSystemProvider(handle, scheme, capabilities) {
+        this._fileProvider.set(handle, ( (new RemoteFileSystemProvider(this._fileService, scheme, capabilities, handle, this._proxy))));
+    }
+    $unregisterProvider(handle) {
+        this._fileProvider.deleteAndDispose(handle);
+    }
+    $onFileSystemChange(handle, changes) {
+        const fileProvider = this._fileProvider.get(handle);
+        if (!fileProvider) {
+            throw new Error('Unknown file provider');
+        }
+        fileProvider.$onFileSystemChange(changes);
+    }
+    $stat(uri) {
+        return this._fileService.stat(URI.revive(uri)).then(stat => {
+            return {
+                ctime: stat.ctime,
+                mtime: stat.mtime,
+                size: stat.size,
+                permissions: stat.readonly ? FilePermission.Readonly : undefined,
+                type: MainThreadFileSystem_1._asFileType(stat)
+            };
+        }).catch(MainThreadFileSystem_1._handleError);
+    }
+    $readdir(uri) {
+        return this._fileService.resolve(URI.revive(uri), { resolveMetadata: false }).then(stat => {
+            if (!stat.isDirectory) {
+                const err = ( (new Error(stat.name)));
+                err.name = FileSystemProviderErrorCode.FileNotADirectory;
+                throw err;
+            }
+            return !stat.children ? [] : ( (stat.children.map(child => [child.name, MainThreadFileSystem_1._asFileType(child)])));
+        }).catch(MainThreadFileSystem_1._handleError);
+    }
+    static _asFileType(stat) {
+        let res = 0;
+        if (stat.isFile) {
+            res += FileType.File;
+        }
+        else if (stat.isDirectory) {
+            res += FileType.Directory;
+        }
+        if (stat.isSymbolicLink) {
+            res += FileType.SymbolicLink;
+        }
+        return res;
+    }
+    $readFile(uri) {
+        return this._fileService.readFile(URI.revive(uri)).then(file => file.value).catch(MainThreadFileSystem_1._handleError);
+    }
+    $writeFile(uri, content) {
+        return this._fileService.writeFile(URI.revive(uri), content)
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $rename(source, target, opts) {
+        return this._fileService.move(URI.revive(source), URI.revive(target), opts.overwrite)
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $copy(source, target, opts) {
+        return this._fileService.copy(URI.revive(source), URI.revive(target), opts.overwrite)
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $mkdir(uri) {
+        return this._fileService.createFolder(URI.revive(uri))
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $delete(uri, opts) {
+        return this._fileService.del(URI.revive(uri), opts).catch(MainThreadFileSystem_1._handleError);
+    }
+    static _handleError(err) {
+        if (err instanceof FileOperationError) {
+            switch (err.fileOperationResult) {
+                case 1 :
+                    err.name = FileSystemProviderErrorCode.FileNotFound;
+                    break;
+                case 0 :
+                    err.name = FileSystemProviderErrorCode.FileIsADirectory;
+                    break;
+                case 6 :
+                    err.name = FileSystemProviderErrorCode.NoPermissions;
+                    break;
+                case 4 :
+                    err.name = FileSystemProviderErrorCode.FileExists;
+                    break;
+            }
+        }
+        else if (err instanceof Error) {
+            const code = toFileSystemProviderErrorCode(err);
+            if (code !== FileSystemProviderErrorCode.Unknown) {
+                err.name = code;
+            }
+        }
+        throw err;
+    }
+    $ensureActivation(scheme) {
+        return this._fileService.activateProvider(scheme);
+    }
+    async $watch(extensionId, session, resource, unvalidatedOpts) {
+        const uri = URI.revive(resource);
+        const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
+        const opts = { ...unvalidatedOpts };
+        if (opts.recursive) {
+            try {
+                const stat = await this._fileService.stat(uri);
+                if (!stat.isDirectory) {
+                    opts.recursive = false;
+                }
+            }
+            catch (error) {
+                this._logService.error(`MainThreadFileSystem#$watch(): failed to stat a resource for file watching (extension: ${extensionId}, path: ${( ( uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session}): ${error}`);
+            }
+        }
+        if (workspaceFolder && opts.recursive) {
+            this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace (extension: ${extensionId}, path: ${( ( uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
+            return;
+        }
+        this._logService.trace(`MainThreadFileSystem#$watch(): request to start watching (extension: ${extensionId}, path: ${( ( uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
+        if (opts.recursive) {
+            const config = this._configurationService.getValue();
+            if (config.files?.watcherExclude) {
+                for (const key in config.files.watcherExclude) {
+                    if (config.files.watcherExclude[key] === true) {
+                        opts.excludes.push(key);
+                    }
+                }
+            }
+        }
+        else if (workspaceFolder) {
+            const config = this._configurationService.getValue();
+            if (config.files?.watcherExclude) {
+                for (const key in config.files.watcherExclude) {
+                    if (config.files.watcherExclude[key] === true) {
+                        if (!opts.includes) {
+                            opts.includes = [];
+                        }
+                        const includePattern = `${rtrim(key, '/')}/${GLOBSTAR}`;
+                        opts.includes.push(normalizeWatcherPattern(workspaceFolder.uri.fsPath, includePattern));
+                    }
+                }
+            }
+            if (!opts.includes || opts.includes.length === 0) {
+                this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( ( uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session})`);
+                return;
+            }
+        }
+        const subscription = this._fileService.watch(uri, opts);
+        this._watches.set(session, subscription);
+    }
+    $unwatch(session) {
+        if (this._watches.has(session)) {
+            this._logService.trace(`MainThreadFileSystem#$unwatch(): request to stop watching (session: ${session})`);
+            this._watches.deleteAndDispose(session);
+        }
+    }
+};
+MainThreadFileSystem = MainThreadFileSystem_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadFileSystem),
+    ( (__param(1, IWorkbenchFileService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, ILogService))),
+    ( (__param(4, IConfigurationService)))
+], MainThreadFileSystem);
+class RemoteFileSystemProvider {
+    constructor(fileService, scheme, capabilities, _handle, _proxy) {
+        this._handle = _handle;
+        this._proxy = _proxy;
+        this._onDidChange = ( (new Emitter()));
+        this.onDidChangeFile = this._onDidChange.event;
+        this.onDidChangeCapabilities = Event.None;
+        this.capabilities = capabilities;
+        this._registration = fileService.registerProvider(scheme, this);
+    }
+    dispose() {
+        this._registration.dispose();
+        this._onDidChange.dispose();
+    }
+    watch(resource, opts) {
+        const session = Math.random();
+        this._proxy.$watch(this._handle, session, resource, opts);
+        return toDisposable(() => {
+            this._proxy.$unwatch(this._handle, session);
+        });
+    }
+    $onFileSystemChange(changes) {
+        this._onDidChange.fire(( (changes.map(RemoteFileSystemProvider._createFileChange))));
+    }
+    static _createFileChange(dto) {
+        return { resource: URI.revive(dto.resource), type: dto.type };
+    }
+    stat(resource) {
+        return this._proxy.$stat(this._handle, resource).then(undefined, err => {
+            throw err;
+        });
+    }
+    readFile(resource) {
+        return this._proxy.$readFile(this._handle, resource).then(buffer => buffer.buffer);
+    }
+    writeFile(resource, content, opts) {
+        return this._proxy.$writeFile(this._handle, resource, VSBuffer.wrap(content), opts);
+    }
+    delete(resource, opts) {
+        return this._proxy.$delete(this._handle, resource, opts);
+    }
+    mkdir(resource) {
+        return this._proxy.$mkdir(this._handle, resource);
+    }
+    readdir(resource) {
+        return this._proxy.$readdir(this._handle, resource);
+    }
+    rename(resource, target, opts) {
+        return this._proxy.$rename(this._handle, resource, target, opts);
+    }
+    copy(resource, target, opts) {
+        return this._proxy.$copy(this._handle, resource, target, opts);
+    }
+    open(resource, opts) {
+        return this._proxy.$open(this._handle, resource, opts);
+    }
+    close(fd) {
+        return this._proxy.$close(this._handle, fd);
+    }
+    read(fd, pos, data, offset, length) {
+        return this._proxy.$read(this._handle, fd, pos, length).then(readData => {
+            data.set(readData.buffer, offset);
+            return readData.byteLength;
+        });
+    }
+    write(fd, pos, data, offset, length) {
+        return this._proxy.$write(this._handle, fd, pos, VSBuffer.wrap(data).slice(offset, offset + length));
+    }
+}
+export { MainThreadFileSystem };