@codingame/monaco-vscode-extensions-service-override 1.83.8 → 1.83.9

package/vscode/src/vs/workbench/services/extensions/common/remoteExtensionHost.js

@@ -0,0 +1,220 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IExtensionHostDebugService } from 'vscode/vscode/vs/platform/debug/common/extensionHostDebug';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ILogService, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { connectRemoteAgentExtensionHost } from 'vscode/vscode/vs/platform/remote/common/remoteAgentConnection';
+import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { IRemoteSocketFactoryService } from 'vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService';
+import { ISignService } from 'vscode/vscode/vs/platform/sign/common/sign';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { isLoggingOnly } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { parseExtensionDevOptions } from './extensionDevOptions.js';
+import { isMessageOfType, UIKind, createMessageOfType } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+
+let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
+    constructor(runningLocation, _initDataProvider, remoteSocketFactoryService, _contextService, _environmentService, _telemetryService, _logService, _loggerService, _labelService, remoteAuthorityResolverService, _extensionHostDebugService, _productService, _signService) {
+        super();
+        this.runningLocation = runningLocation;
+        this._initDataProvider = _initDataProvider;
+        this.remoteSocketFactoryService = remoteSocketFactoryService;
+        this._contextService = _contextService;
+        this._environmentService = _environmentService;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this._loggerService = _loggerService;
+        this._labelService = _labelService;
+        this.remoteAuthorityResolverService = remoteAuthorityResolverService;
+        this._extensionHostDebugService = _extensionHostDebugService;
+        this._productService = _productService;
+        this._signService = _signService;
+        this.startup = 1 ;
+        this.extensions = null;
+        this._onExit = this._register(( new Emitter()));
+        this.onExit = this._onExit.event;
+        this.remoteAuthority = this._initDataProvider.remoteAuthority;
+        this._protocol = null;
+        this._hasLostConnection = false;
+        this._terminating = false;
+        const devOpts = parseExtensionDevOptions(this._environmentService);
+        this._isExtensionDevHost = devOpts.isExtensionDevHost;
+    }
+    start() {
+        const options = {
+            commit: this._productService.commit,
+            quality: this._productService.quality,
+            addressProvider: {
+                getAddress: async () => {
+                    const { authority } = await this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority);
+                    return { connectTo: authority.connectTo, connectionToken: authority.connectionToken };
+                }
+            },
+            remoteSocketFactoryService: this.remoteSocketFactoryService,
+            signService: this._signService,
+            logService: this._logService,
+            ipcLogger: null
+        };
+        return this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority).then((resolverResult) => {
+            const startParams = {
+                language: platform.language,
+                debugId: this._environmentService.debugExtensionHost.debugId,
+                break: this._environmentService.debugExtensionHost.break,
+                port: this._environmentService.debugExtensionHost.port,
+                env: { ...this._environmentService.debugExtensionHost.env, ...resolverResult.options?.extensionHostEnv },
+            };
+            const extDevLocs = this._environmentService.extensionDevelopmentLocationURI;
+            let debugOk = true;
+            if (extDevLocs && extDevLocs.length > 0) {
+                if (extDevLocs[0].scheme === Schemas.file) {
+                    debugOk = false;
+                }
+            }
+            if (!debugOk) {
+                startParams.break = false;
+            }
+            return connectRemoteAgentExtensionHost(options, startParams).then(result => {
+                this._register(result);
+                const { protocol, debugPort, reconnectionToken } = result;
+                const isExtensionDevelopmentDebug = typeof debugPort === 'number';
+                if (debugOk && this._environmentService.isExtensionDevelopment && this._environmentService.debugExtensionHost.debugId && debugPort) {
+                    this._extensionHostDebugService.attachSession(this._environmentService.debugExtensionHost.debugId, debugPort, this._initDataProvider.remoteAuthority);
+                }
+                protocol.onDidDispose(() => {
+                    this._onExtHostConnectionLost(reconnectionToken);
+                });
+                protocol.onSocketClose(() => {
+                    if (this._isExtensionDevHost) {
+                        this._onExtHostConnectionLost(reconnectionToken);
+                    }
+                });
+                return ( new Promise((resolve, reject) => {
+                    const handle = setTimeout(() => {
+                        reject('The remote extension host took longer than 60s to send its ready message.');
+                    }, 60 * 1000);
+                    const disposable = protocol.onMessage(msg => {
+                        if (isMessageOfType(msg, 1 )) {
+                            this._createExtHostInitData(isExtensionDevelopmentDebug).then(data => {
+                                protocol.send(VSBuffer.fromString(JSON.stringify(data)));
+                            });
+                            return;
+                        }
+                        if (isMessageOfType(msg, 0 )) {
+                            clearTimeout(handle);
+                            disposable.dispose();
+                            this._protocol = protocol;
+                            resolve(protocol);
+                            return;
+                        }
+                        console.error(`received unexpected message during handshake phase from the extension host: `, msg);
+                    });
+                }));
+            });
+        });
+    }
+    _onExtHostConnectionLost(reconnectionToken) {
+        if (this._hasLostConnection) {
+            return;
+        }
+        this._hasLostConnection = true;
+        if (this._isExtensionDevHost && this._environmentService.debugExtensionHost.debugId) {
+            this._extensionHostDebugService.close(this._environmentService.debugExtensionHost.debugId);
+        }
+        if (this._terminating) {
+            return;
+        }
+        this._onExit.fire([0, reconnectionToken]);
+    }
+    async _createExtHostInitData(isExtensionDevelopmentDebug) {
+        const remoteInitData = await this._initDataProvider.getInitData();
+        this.extensions = remoteInitData.extensions;
+        const workspace = this._contextService.getWorkspace();
+        return {
+            commit: this._productService.commit,
+            version: this._productService.version,
+            quality: this._productService.quality,
+            parentPid: remoteInitData.pid,
+            environment: {
+                isExtensionDevelopmentDebug,
+                appRoot: remoteInitData.appRoot,
+                appName: this._productService.nameLong,
+                appHost: this._productService.embedderIdentifier || 'desktop',
+                appUriScheme: this._productService.urlProtocol,
+                extensionTelemetryLogResource: this._environmentService.extHostTelemetryLogFile,
+                isExtensionTelemetryLoggingOnly: isLoggingOnly(this._productService, this._environmentService),
+                appLanguage: platform.language,
+                extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
+                extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
+                globalStorageHome: remoteInitData.globalStorageHome,
+                workspaceStorageHome: remoteInitData.workspaceStorageHome,
+                extensionLogLevel: this._environmentService.extensionLogLevel
+            },
+            workspace: this._contextService.getWorkbenchState() === 1  ? null : {
+                configuration: workspace.configuration,
+                id: workspace.id,
+                name: this._labelService.getWorkspaceLabel(workspace),
+                transient: workspace.transient
+            },
+            remote: {
+                isRemote: true,
+                authority: this._initDataProvider.remoteAuthority,
+                connectionData: remoteInitData.connectionData
+            },
+            consoleForward: {
+                includeStack: false,
+                logNative: Boolean(this._environmentService.debugExtensionHost.debugId)
+            },
+            extensions: this.extensions.toSnapshot(),
+            telemetryInfo: {
+                sessionId: this._telemetryService.sessionId,
+                machineId: this._telemetryService.machineId,
+                firstSessionDate: this._telemetryService.firstSessionDate,
+                msftInternal: this._telemetryService.msftInternal
+            },
+            logLevel: this._logService.getLevel(),
+            loggers: [...this._loggerService.getRegisteredLoggers()],
+            logsLocation: remoteInitData.extensionHostLogsPath,
+            autoStart: ((this.startup === 1) ),
+            uiKind: platform.isWeb ? UIKind.Web : UIKind.Desktop
+        };
+    }
+    getInspectPort() {
+        return undefined;
+    }
+    enableInspectPort() {
+        return Promise.resolve(false);
+    }
+    dispose() {
+        super.dispose();
+        this._terminating = true;
+        if (this._protocol) {
+            const socket = this._protocol.getSocket();
+            this._protocol.send(createMessageOfType(2 ));
+            this._protocol.sendDisconnect();
+            this._protocol.dispose();
+            socket.end();
+            this._protocol = null;
+        }
+    }
+};
+RemoteExtensionHost = ( __decorate([
+    ( __param(2, IRemoteSocketFactoryService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IWorkbenchEnvironmentService)),
+    ( __param(5, ITelemetryService)),
+    ( __param(6, ILogService)),
+    ( __param(7, ILoggerService)),
+    ( __param(8, ILabelService)),
+    ( __param(9, IRemoteAuthorityResolverService)),
+    ( __param(10, IExtensionHostDebugService)),
+    ( __param(11, IProductService)),
+    ( __param(12, ISignService))
+], RemoteExtensionHost));
+
+export { RemoteExtensionHost };

package/vscode/src/vs/workbench/services/themes/common/iconExtensionPoint.js

@@ -0,0 +1,5 @@
+import { Extensions } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+
+const iconRegistry = ( Registry.as(Extensions.IconContribution));
+iconRegistry.getIconReferenceSchema();

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

@@ -0,0 +1,79 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+
+let ResourceWorkingCopy = class ResourceWorkingCopy extends Disposable {
+    constructor(resource, fileService) {
+        super();
+        this.resource = resource;
+        this.fileService = fileService;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this.orphaned = false;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+    }
+    isOrphaned() {
+        return this.orphaned;
+    }
+    async onDidFilesChange(e) {
+        let fileEventImpactsUs = false;
+        let newInOrphanModeGuess;
+        if (this.orphaned) {
+            const fileWorkingCopyResourceAdded = e.contains(this.resource, 1 );
+            if (fileWorkingCopyResourceAdded) {
+                newInOrphanModeGuess = false;
+                fileEventImpactsUs = true;
+            }
+        }
+        else {
+            const fileWorkingCopyResourceDeleted = e.contains(this.resource, 2 );
+            if (fileWorkingCopyResourceDeleted) {
+                newInOrphanModeGuess = true;
+                fileEventImpactsUs = true;
+            }
+        }
+        if (fileEventImpactsUs && this.orphaned !== newInOrphanModeGuess) {
+            let newInOrphanModeValidated = false;
+            if (newInOrphanModeGuess) {
+                await timeout(100, CancellationToken.None);
+                if (this.isDisposed()) {
+                    newInOrphanModeValidated = true;
+                }
+                else {
+                    const exists = await this.fileService.exists(this.resource);
+                    newInOrphanModeValidated = !exists;
+                }
+            }
+            if (this.orphaned !== newInOrphanModeValidated && !this.isDisposed()) {
+                this.setOrphaned(newInOrphanModeValidated);
+            }
+        }
+    }
+    setOrphaned(orphaned) {
+        if (this.orphaned !== orphaned) {
+            this.orphaned = orphaned;
+            this._onDidChangeOrphaned.fire();
+        }
+    }
+    isDisposed() {
+        return this._store.isDisposed;
+    }
+    dispose() {
+        this.orphaned = false;
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+    isModified() {
+        return this.isDirty();
+    }
+};
+ResourceWorkingCopy = ( __decorate([
+    ( __param(1, IFileService))
+], ResourceWorkingCopy));
+
+export { ResourceWorkingCopy };