@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/terminal/browser/terminal.js

@@ -3,5 +3,8 @@ const ITerminalService = ( createDecorator('terminalService'));
 const ITerminalEditorService = ( createDecorator('terminalEditorService'));
 const ITerminalGroupService = ( createDecorator('terminalGroupService'));
 const ITerminalInstanceService = ( createDecorator('terminalInstanceService'));
+const isDetachedTerminalInstance = (t) => typeof t.instanceId !== 'number';
+class TerminalLinkQuickPickEvent extends MouseEvent {
+}
 const terminalEditorId = 'terminalEditor';
-export { ITerminalEditorService, ITerminalGroupService, ITerminalInstanceService, ITerminalService, terminalEditorId };
+export { ITerminalEditorService, ITerminalGroupService, ITerminalInstanceService, ITerminalService, TerminalLinkQuickPickEvent, isDetachedTerminalInstance, terminalEditorId };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProcessExtHostProxy.js

@@ -0,0 +1,130 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ITerminalService } from './terminal.js';
+let TerminalProcessExtHostProxy = class TerminalProcessExtHostProxy extends Disposable {
+    get onProcessReady() { return this._onProcessReady.event; }
+    constructor(instanceId, _cols, _rows, _terminalService) {
+        super();
+        this.instanceId = instanceId;
+        this._cols = _cols;
+        this._rows = _rows;
+        this._terminalService = _terminalService;
+        this.id = 0;
+        this.shouldPersist = false;
+        this._onProcessData = this._register(( new Emitter()));
+        this.onProcessData = this._onProcessData.event;
+        this._onProcessReady = this._register(( new Emitter()));
+        this._onStart = this._register(( new Emitter()));
+        this.onStart = this._onStart.event;
+        this._onInput = this._register(( new Emitter()));
+        this.onInput = this._onInput.event;
+        this._onBinary = this._register(( new Emitter()));
+        this.onBinary = this._onBinary.event;
+        this._onResize = this._register(( new Emitter()));
+        this.onResize = this._onResize.event;
+        this._onAcknowledgeDataEvent = this._register(( new Emitter()));
+        this.onAcknowledgeDataEvent = this._onAcknowledgeDataEvent.event;
+        this._onShutdown = this._register(( new Emitter()));
+        this.onShutdown = this._onShutdown.event;
+        this._onRequestInitialCwd = this._register(( new Emitter()));
+        this.onRequestInitialCwd = this._onRequestInitialCwd.event;
+        this._onRequestCwd = this._register(( new Emitter()));
+        this.onRequestCwd = this._onRequestCwd.event;
+        this._onDidChangeProperty = this._register(( new Emitter()));
+        this.onDidChangeProperty = this._onDidChangeProperty.event;
+        this._onProcessExit = this._register(( new Emitter()));
+        this.onProcessExit = this._onProcessExit.event;
+        this._pendingInitialCwdRequests = [];
+        this._pendingCwdRequests = [];
+    }
+    emitData(data) {
+        this._onProcessData.fire(data);
+    }
+    emitTitle(title) {
+        this._onDidChangeProperty.fire({ type: "title" , value: title });
+    }
+    emitReady(pid, cwd) {
+        this._onProcessReady.fire({ pid, cwd, windowsPty: undefined });
+    }
+    emitProcessProperty({ type, value }) {
+        switch (type) {
+            case "cwd" :
+                this.emitCwd(value);
+                break;
+            case "initialCwd" :
+                this.emitInitialCwd(value);
+                break;
+            case "title" :
+                this.emitTitle(value);
+                break;
+            case "overrideDimensions" :
+                this.emitOverrideDimensions(value);
+                break;
+            case "resolvedShellLaunchConfig" :
+                this.emitResolvedShellLaunchConfig(value);
+                break;
+        }
+    }
+    emitExit(exitCode) {
+        this._onProcessExit.fire(exitCode);
+        this.dispose();
+    }
+    emitOverrideDimensions(dimensions) {
+        this._onDidChangeProperty.fire({ type: "overrideDimensions" , value: dimensions });
+    }
+    emitResolvedShellLaunchConfig(shellLaunchConfig) {
+        this._onDidChangeProperty.fire({ type: "resolvedShellLaunchConfig" , value: shellLaunchConfig });
+    }
+    emitInitialCwd(initialCwd) {
+        while (this._pendingInitialCwdRequests.length > 0) {
+            this._pendingInitialCwdRequests.pop()(initialCwd);
+        }
+    }
+    emitCwd(cwd) {
+        while (this._pendingCwdRequests.length > 0) {
+            this._pendingCwdRequests.pop()(cwd);
+        }
+    }
+    async start() {
+        return this._terminalService.requestStartExtensionTerminal(this, this._cols, this._rows);
+    }
+    shutdown(immediate) {
+        this._onShutdown.fire(immediate);
+    }
+    input(data) {
+        this._onInput.fire(data);
+    }
+    resize(cols, rows) {
+        this._onResize.fire({ cols, rows });
+    }
+    clearBuffer() {
+    }
+    acknowledgeDataEvent() {
+    }
+    async setUnicodeVersion(version) {
+    }
+    async processBinary(data) {
+        this._onBinary.fire(data);
+    }
+    getInitialCwd() {
+        return ( new Promise(resolve => {
+            this._onRequestInitialCwd.fire();
+            this._pendingInitialCwdRequests.push(resolve);
+        }));
+    }
+    getCwd() {
+        return ( new Promise(resolve => {
+            this._onRequestCwd.fire();
+            this._pendingCwdRequests.push(resolve);
+        }));
+    }
+    async refreshProperty(type) {
+    }
+    async updateProperty(type, value) {
+    }
+};
+TerminalProcessExtHostProxy = ( __decorate([
+    ( __param(3, ITerminalService))
+], TerminalProcessExtHostProxy));
+export { TerminalProcessExtHostProxy };

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.js

@@ -14,6 +14,7 @@ const SUGGESTIONS_FONT_WEIGHT = ['normal', 'bold', '100', '200', '300', '400', '
 const ITerminalProfileResolverService = ( createDecorator('terminalProfileResolverService'));
 const ITerminalProfileService = ( createDecorator('terminalProfileService'));
 const DEFAULT_LOCAL_ECHO_EXCLUDE = ['vim', 'vi', 'nano', 'tmux'];
+const isTerminalProcessManager = (t) => typeof t.write === 'function';
 const DEFAULT_COMMANDS_TO_SKIP_SHELL = [
     "workbench.action.terminal.clearSelection" ,
     "workbench.action.terminal.clear" ,
@@ -245,4 +246,4 @@ const terminalContributionsDescriptor = {
         },
     },
 };
-export { DEFAULT_BOLD_FONT_WEIGHT, DEFAULT_COMMANDS_TO_SKIP_SHELL, DEFAULT_FONT_WEIGHT, DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT, DEFAULT_LOCAL_ECHO_EXCLUDE, ITerminalProfileResolverService, ITerminalProfileService, MAXIMUM_FONT_WEIGHT, MINIMUM_FONT_WEIGHT, MINIMUM_LETTER_SPACING, SUGGESTIONS_FONT_WEIGHT, TERMINAL_CONFIG_SECTION, TERMINAL_CREATION_COMMANDS, TERMINAL_VIEW_ID, terminalContributionsDescriptor };
+export { DEFAULT_BOLD_FONT_WEIGHT, DEFAULT_COMMANDS_TO_SKIP_SHELL, DEFAULT_FONT_WEIGHT, DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT, DEFAULT_LOCAL_ECHO_EXCLUDE, ITerminalProfileResolverService, ITerminalProfileService, MAXIMUM_FONT_WEIGHT, MINIMUM_FONT_WEIGHT, MINIMUM_LETTER_SPACING, SUGGESTIONS_FONT_WEIGHT, TERMINAL_CONFIG_SECTION, TERMINAL_CREATION_COMMANDS, TERMINAL_VIEW_ID, isTerminalProcessManager, terminalContributionsDescriptor };

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/featuredExtensionService.js

@@ -0,0 +1,159 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IExtensionManagementService, IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+var FeaturedExtensionsService_1;
+const IFeaturedExtensionsService = ( createDecorator('featuredExtensionsService'));
+let FeaturedExtensionsService = class FeaturedExtensionsService extends Disposable {
+    static { FeaturedExtensionsService_1 = this; }
+    static { this.STORAGE_KEY = 'workbench.welcomePage.extensionMetadata'; }
+    constructor(extensionManagementService, extensionService, storageService, productService, galleryService) {
+        super();
+        this.extensionManagementService = extensionManagementService;
+        this.extensionService = extensionService;
+        this.storageService = storageService;
+        this.productService = productService;
+        this.galleryService = galleryService;
+        this.ignoredExtensions = ( new Set());
+        this._isInitialized = false;
+        this.title = ( localizeWithPath(
+            'vs/workbench/contrib/welcomeGettingStarted/browser/featuredExtensionService',
+            'gettingStarted.featuredTitle',
+            'Recommended'
+        ));
+    }
+    async getExtensions() {
+        await this._init();
+        const featuredExtensions = [];
+        for (const extension of this.productService.featuredExtensions?.filter(e => !( this.ignoredExtensions.has(e.id))) ?? []) {
+            const resolvedExtension = await this.resolveExtension(extension);
+            if (resolvedExtension) {
+                featuredExtensions.push(resolvedExtension);
+            }
+        }
+        return featuredExtensions;
+    }
+    async _init() {
+        if (this._isInitialized) {
+            return;
+        }
+        const featuredExtensions = this.productService.featuredExtensions;
+        if (!featuredExtensions) {
+            this._isInitialized = true;
+            return;
+        }
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const installed = await this.extensionManagementService.getInstalled();
+        for (const extension of featuredExtensions) {
+            if (( installed.some(e => ExtensionIdentifier.equals(e.identifier.id, extension.id)))) {
+                this.ignoredExtensions.add(extension.id);
+            }
+            else {
+                let galleryExtension;
+                try {
+                    galleryExtension = (await this.galleryService.getExtensions([{ id: extension.id }], CancellationToken.None))[0];
+                }
+                catch (err) {
+                    continue;
+                }
+                if (!(await this.extensionManagementService.canInstall(galleryExtension))) {
+                    this.ignoredExtensions.add(extension.id);
+                }
+            }
+        }
+        this._isInitialized = true;
+    }
+    async resolveExtension(productMetadata) {
+        const title = productMetadata.title ?? (await this.getMetadata(productMetadata.id, 0 ));
+        const description = productMetadata.description ?? (await this.getMetadata(productMetadata.id, 1 ));
+        const imagePath = productMetadata.imagePath ?? (await this.getMetadata(productMetadata.id, 2 ));
+        if (title && description && imagePath) {
+            return {
+                id: productMetadata.id,
+                title: title,
+                description: description,
+                imagePath: imagePath,
+            };
+        }
+        return undefined;
+    }
+    async getMetadata(extensionId, key) {
+        const storageMetadata = this.getStorageData(extensionId);
+        if (storageMetadata) {
+            switch (key) {
+                case 0 : {
+                    return storageMetadata.title;
+                }
+                case 1 : {
+                    return storageMetadata.description;
+                }
+                case 2 : {
+                    return storageMetadata.imagePath;
+                }
+                default:
+                    return undefined;
+            }
+        }
+        return await this.getGalleryMetadata(extensionId, key);
+    }
+    getStorageData(extensionId) {
+        const metadata = this.storageService.get(FeaturedExtensionsService_1.STORAGE_KEY + '.' + extensionId, -1 );
+        if (metadata) {
+            const value = JSON.parse(metadata);
+            const lastUpdateDate = ( new Date()).getTime() - value.date;
+            if (lastUpdateDate < 1000 * 60 * 60 * 24 * 7) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    async getGalleryMetadata(extensionId, key) {
+        const storageKey = FeaturedExtensionsService_1.STORAGE_KEY + '.' + extensionId;
+        this.storageService.remove(storageKey, -1 );
+        let metadata;
+        let galleryExtension;
+        try {
+            galleryExtension = (await this.galleryService.getExtensions([{ id: extensionId }], CancellationToken.None))[0];
+        }
+        catch (err) {
+        }
+        if (!galleryExtension) {
+            return metadata;
+        }
+        switch (key) {
+            case 0 : {
+                metadata = galleryExtension.displayName;
+                break;
+            }
+            case 1 : {
+                metadata = galleryExtension.description;
+                break;
+            }
+            case 2 : {
+                metadata = galleryExtension.assets.icon?.uri;
+                break;
+            }
+        }
+        this.storageService.store(storageKey, JSON.stringify({
+            title: galleryExtension.displayName,
+            description: galleryExtension.description,
+            imagePath: galleryExtension.assets.icon?.uri,
+            date: ( new Date()).getTime()
+        }), -1 , 1 );
+        return metadata;
+    }
+};
+FeaturedExtensionsService = FeaturedExtensionsService_1 = ( __decorate([
+    ( __param(0, IExtensionManagementService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IProductService)),
+    ( __param(4, IExtensionGalleryService))
+], FeaturedExtensionsService));
+export { FeaturedExtensionsService, IFeaturedExtensionsService };