@codingame/monaco-vscode-api 1.85.1 → 1.85.2

package/vscode/src/vs/workbench/services/terminal/common/embedderTerminalService.js

@@ -1,3 +1,77 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 const IEmbedderTerminalService = ( createDecorator('embedderTerminalService'));
-export { IEmbedderTerminalService };
+class EmbedderTerminalService {
+    constructor() {
+        this._onDidCreateTerminal = ( new Emitter());
+        this.onDidCreateTerminal = Event.buffer(this._onDidCreateTerminal.event);
+    }
+    createTerminal(options) {
+        const slc = {
+            name: options.name,
+            isFeatureTerminal: true,
+            customPtyImplementation(terminalId, cols, rows) {
+                return ( new EmbedderTerminalProcess(terminalId, options.pty));
+            },
+        };
+        this._onDidCreateTerminal.fire(slc);
+    }
+}
+class EmbedderTerminalProcess extends Disposable {
+    constructor(id, pty) {
+        super();
+        this.id = id;
+        this.shouldPersist = false;
+        this._onProcessReady = this._register(( new Emitter()));
+        this.onProcessReady = this._onProcessReady.event;
+        this._onDidChangeProperty = this._register(( new Emitter()));
+        this.onDidChangeProperty = this._onDidChangeProperty.event;
+        this._onProcessExit = this._register(( new Emitter()));
+        this.onProcessExit = this._onProcessExit.event;
+        this._pty = pty;
+        this.onProcessData = this._pty.onDidWrite;
+        if (this._pty.onDidClose) {
+            this._register(this._pty.onDidClose(e => this._onProcessExit.fire(e || undefined)));
+        }
+        if (this._pty.onDidChangeName) {
+            this._register(this._pty.onDidChangeName(e => this._onDidChangeProperty.fire({
+                type: "title" ,
+                value: e
+            })));
+        }
+    }
+    async start() {
+        this._onProcessReady.fire({ pid: -1, cwd: '', windowsPty: undefined });
+        this._pty.open();
+        return undefined;
+    }
+    shutdown() {
+        this._pty.close();
+    }
+    input() {
+    }
+    async processBinary() {
+    }
+    resize() {
+    }
+    clearBuffer() {
+    }
+    acknowledgeDataEvent() {
+    }
+    async setUnicodeVersion() {
+    }
+    async getInitialCwd() {
+        return '';
+    }
+    async getCwd() {
+        return '';
+    }
+    refreshProperty(property) {
+        throw new Error(`refreshProperty is not suppported in EmbedderTerminalProcess. property: ${property}`);
+    }
+    updateProperty(property, value) {
+        throw new Error(`updateProperty is not suppported in EmbedderTerminalProcess. property: ${property}, value: ${value}`);
+    }
+}
+export { EmbedderTerminalService, IEmbedderTerminalService };

package/vscode/src/vs/workbench/services/timer/browser/timerService.js

@@ -1,3 +1,242 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as performance$1 from 'monaco-editor/esm/vs/base/common/performance.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { IUpdateService } from '../../../../platform/update/common/update.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { Barrier, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IWorkbenchLayoutService } from '../../layout/browser/layoutService.js';
+import { IPaneCompositePartService } from '../../panecomposite/browser/panecomposite.js';
+import { TelemetryTrustedValue } from '../../../../platform/telemetry/common/telemetryUtils.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { createBlobWorker } from 'monaco-editor/esm/vs/base/browser/defaultWorkerFactory.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { TerminalExtensions } from '../../../../platform/terminal/common/terminal.js';
 const ITimerService = ( createDecorator('timerService'));
-export { ITimerService };
+class PerfMarks {
+    constructor() {
+        this._entries = [];
+    }
+    setMarks(source, entries) {
+        this._entries.push([source, entries]);
+    }
+    getDuration(from, to) {
+        const fromEntry = this._findEntry(from);
+        if (!fromEntry) {
+            return 0;
+        }
+        const toEntry = this._findEntry(to);
+        if (!toEntry) {
+            return 0;
+        }
+        return toEntry.startTime - fromEntry.startTime;
+    }
+    _findEntry(name) {
+        for (const [, marks] of this._entries) {
+            for (let i = marks.length - 1; i >= 0; i--) {
+                if (marks[i].name === name) {
+                    return marks[i];
+                }
+            }
+        }
+    }
+    getEntries() {
+        return this._entries.slice(0);
+    }
+}
+let AbstractTimerService = class AbstractTimerService {
+    constructor(_lifecycleService, _contextService, _extensionService, _updateService, _paneCompositeService, _editorService, _accessibilityService, _telemetryService, layoutService) {
+        this._lifecycleService = _lifecycleService;
+        this._contextService = _contextService;
+        this._extensionService = _extensionService;
+        this._updateService = _updateService;
+        this._paneCompositeService = _paneCompositeService;
+        this._editorService = _editorService;
+        this._accessibilityService = _accessibilityService;
+        this._telemetryService = _telemetryService;
+        this._barrier = ( new Barrier());
+        this._marks = ( new PerfMarks());
+        this._rndValueShouldSendTelemetry = Math.random() < .05;
+        Promise.all([
+            this._extensionService.whenInstalledExtensionsRegistered(),
+            _lifecycleService.when(3 ),
+            layoutService.whenRestored,
+            Promise.all(( Array.from(( ( Registry.as(TerminalExtensions.Backend)).backends.values())).map(e => e.whenReady)))
+        ]).then(() => {
+            this.setPerformanceMarks('renderer', performance$1.getMarks());
+            return this._computeStartupMetrics();
+        }).then(metrics => {
+            this._startupMetrics = metrics;
+            this._reportStartupTimes(metrics);
+            this._barrier.open();
+        });
+        this.perfBaseline = this._barrier.wait()
+            .then(() => this._lifecycleService.when(4 ))
+            .then(() => timeout(this._startupMetrics.timers.ellapsedRequire))
+            .then(() => {
+            const jsSrc = ( (function () {
+                let tooSlow = false;
+                function fib(n) {
+                    if (tooSlow) {
+                        return 0;
+                    }
+                    if (performance.now() - t1 >= 1000) {
+                        tooSlow = true;
+                    }
+                    if (n <= 2) {
+                        return n;
+                    }
+                    return fib(n - 1) + fib(n - 2);
+                }
+                const t1 = performance.now();
+                fib(24);
+                const value = Math.round(performance.now() - t1);
+                postMessage({ value: tooSlow ? -1 : value });
+            }).toString());
+            const blob = ( new Blob([`(${jsSrc})();`], { type: 'application/javascript' }));
+            const blobUrl = URL.createObjectURL(blob);
+            const worker = createBlobWorker(blobUrl, { name: 'perfBaseline' });
+            return ( new Promise(resolve => {
+                worker.onmessage = e => resolve(e.data.value);
+            })).finally(() => {
+                worker.terminate();
+                URL.revokeObjectURL(blobUrl);
+            });
+        });
+    }
+    whenReady() {
+        return this._barrier.wait();
+    }
+    get startupMetrics() {
+        if (!this._startupMetrics) {
+            throw new Error('illegal state, MUST NOT access startupMetrics before whenReady has resolved');
+        }
+        return this._startupMetrics;
+    }
+    setPerformanceMarks(source, marks) {
+        const codeMarks = marks.filter(mark => mark.name.startsWith('code/'));
+        this._marks.setMarks(source, codeMarks);
+        this._reportPerformanceMarks(source, codeMarks);
+    }
+    getPerformanceMarks() {
+        return this._marks.getEntries();
+    }
+    getDuration(from, to) {
+        return this._marks.getDuration(from, to);
+    }
+    _reportStartupTimes(metrics) {
+        this._telemetryService.publicLog('startupTimeVaried', metrics);
+    }
+    _shouldReportPerfMarks() {
+        return this._rndValueShouldSendTelemetry;
+    }
+    _reportPerformanceMarks(source, marks) {
+        if (!this._shouldReportPerfMarks()) {
+            return;
+        }
+        for (const mark of marks) {
+            this._telemetryService.publicLog2('startup.timer.mark', {
+                source,
+                name: ( new TelemetryTrustedValue(mark.name)),
+                startTime: mark.startTime
+            });
+        }
+    }
+    async _computeStartupMetrics() {
+        const initialStartup = this._isInitialStartup();
+        let startMark;
+        if (isWeb) {
+            startMark = 'code/timeOrigin';
+        }
+        else {
+            startMark = initialStartup ? 'code/didStartMain' : 'code/willOpenNewWindow';
+        }
+        const activeViewlet = this._paneCompositeService.getActivePaneComposite(0 );
+        const activePanel = this._paneCompositeService.getActivePaneComposite(1 );
+        const info = {
+            version: 2,
+            ellapsed: this._marks.getDuration(startMark, 'code/didStartWorkbench'),
+            isLatestVersion: Boolean(await this._updateService.isLatestVersion()),
+            didUseCachedData: this._didUseCachedData(),
+            windowKind: this._lifecycleService.startupKind,
+            windowCount: await this._getWindowCount(),
+            viewletId: activeViewlet?.getId(),
+            editorIds: ( this._editorService.visibleEditors.map(input => input.typeId)),
+            panelId: activePanel ? activePanel.getId() : undefined,
+            timers: {
+                ellapsedAppReady: initialStartup ? this._marks.getDuration('code/didStartMain', 'code/mainAppReady') : undefined,
+                ellapsedNlsGeneration: initialStartup ? this._marks.getDuration('code/willGenerateNls', 'code/didGenerateNls') : undefined,
+                ellapsedLoadMainBundle: initialStartup ? this._marks.getDuration('code/willLoadMainBundle', 'code/didLoadMainBundle') : undefined,
+                ellapsedCrashReporter: initialStartup ? this._marks.getDuration('code/willStartCrashReporter', 'code/didStartCrashReporter') : undefined,
+                ellapsedMainServer: initialStartup ? this._marks.getDuration('code/willStartMainServer', 'code/didStartMainServer') : undefined,
+                ellapsedWindowCreate: initialStartup ? this._marks.getDuration('code/willCreateCodeWindow', 'code/didCreateCodeWindow') : undefined,
+                ellapsedWindowRestoreState: initialStartup ? this._marks.getDuration('code/willRestoreCodeWindowState', 'code/didRestoreCodeWindowState') : undefined,
+                ellapsedBrowserWindowCreate: initialStartup ? this._marks.getDuration('code/willCreateCodeBrowserWindow', 'code/didCreateCodeBrowserWindow') : undefined,
+                ellapsedWindowMaximize: initialStartup ? this._marks.getDuration('code/willMaximizeCodeWindow', 'code/didMaximizeCodeWindow') : undefined,
+                ellapsedWindowLoad: initialStartup ? this._marks.getDuration('code/mainAppReady', 'code/willOpenNewWindow') : undefined,
+                ellapsedWindowLoadToRequire: this._marks.getDuration('code/willOpenNewWindow', 'code/willLoadWorkbenchMain'),
+                ellapsedRequire: this._marks.getDuration('code/willLoadWorkbenchMain', 'code/didLoadWorkbenchMain'),
+                ellapsedWaitForWindowConfig: this._marks.getDuration('code/willWaitForWindowConfig', 'code/didWaitForWindowConfig'),
+                ellapsedStorageInit: this._marks.getDuration('code/willInitStorage', 'code/didInitStorage'),
+                ellapsedSharedProcesConnected: this._marks.getDuration('code/willConnectSharedProcess', 'code/didConnectSharedProcess'),
+                ellapsedWorkspaceServiceInit: this._marks.getDuration('code/willInitWorkspaceService', 'code/didInitWorkspaceService'),
+                ellapsedRequiredUserDataInit: this._marks.getDuration('code/willInitRequiredUserData', 'code/didInitRequiredUserData'),
+                ellapsedOtherUserDataInit: this._marks.getDuration('code/willInitOtherUserData', 'code/didInitOtherUserData'),
+                ellapsedExtensions: this._marks.getDuration('code/willLoadExtensions', 'code/didLoadExtensions'),
+                ellapsedEditorRestore: this._marks.getDuration('code/willRestoreEditors', 'code/didRestoreEditors'),
+                ellapsedViewletRestore: this._marks.getDuration('code/willRestoreViewlet', 'code/didRestoreViewlet'),
+                ellapsedPanelRestore: this._marks.getDuration('code/willRestorePanel', 'code/didRestorePanel'),
+                ellapsedWorkbench: this._marks.getDuration('code/willStartWorkbench', 'code/didStartWorkbench'),
+                ellapsedExtensionsReady: this._marks.getDuration(startMark, 'code/didLoadExtensions'),
+                ellapsedRenderer: this._marks.getDuration('code/didStartRenderer', 'code/didStartWorkbench')
+            },
+            platform: undefined,
+            release: undefined,
+            arch: undefined,
+            totalmem: undefined,
+            freemem: undefined,
+            meminfo: undefined,
+            cpus: undefined,
+            loadavg: undefined,
+            isVMLikelyhood: undefined,
+            initialStartup,
+            hasAccessibilitySupport: this._accessibilityService.isScreenReaderOptimized(),
+            emptyWorkbench: this._contextService.getWorkbenchState() === 1
+        };
+        await this._extendStartupInfo(info);
+        return info;
+    }
+};
+AbstractTimerService = ( __decorate([
+    ( __param(0, ILifecycleService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, IUpdateService)),
+    ( __param(4, IPaneCompositePartService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IAccessibilityService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IWorkbenchLayoutService))
+], AbstractTimerService));
+class TimerService extends AbstractTimerService {
+    _isInitialStartup() {
+        return false;
+    }
+    _didUseCachedData() {
+        return false;
+    }
+    async _getWindowCount() {
+        return 1;
+    }
+    async _extendStartupInfo(info) {
+        info.isVMLikelyhood = 0;
+        info.isARM64Emulated = false;
+        info.platform = navigator.userAgent;
+        info.release = navigator.appVersion;
+    }
+}
+export { AbstractTimerService, ITimerService, TimerService };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.js

@@ -6,6 +6,36 @@ import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IExtensionService } from '../../extensions/common/extensions.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
 const IUserDataInitializationService = ( createDecorator('IUserDataInitializationService'));
+class UserDataInitializationService {
+    constructor(initializers = []) {
+        this.initializers = initializers;
+    }
+    async whenInitializationFinished() {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(initializer => initializer.whenInitializationFinished())));
+        }
+    }
+    async requiresInitialization() {
+        return ( (await Promise.all(( this.initializers.map(initializer => initializer.requiresInitialization())))).some(result => result));
+    }
+    async initializeRequiredResources() {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(initializer => initializer.initializeRequiredResources())));
+        }
+    }
+    async initializeOtherResources(instantiationService) {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(initializer => initializer.initializeOtherResources(instantiationService))));
+        }
+    }
+    async initializeInstalledExtensions(instantiationService) {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(
+                initializer => initializer.initializeInstalledExtensions(instantiationService)
+            )));
+        }
+    }
+}
 let InitializeOtherResourcesContribution = class InitializeOtherResourcesContribution {
     constructor(userDataInitializeService, instantiationService, extensionService) {
         extensionService.whenInstalledExtensionsRegistered().then(() => this.initializeOtherResource(userDataInitializeService, instantiationService));
@@ -27,4 +57,4 @@ if (isWeb) {
     const workbenchRegistry = ( Registry.as(Extensions.Workbench));
     workbenchRegistry.registerWorkbenchContribution(InitializeOtherResourcesContribution, 3 );
 }
-export { IUserDataInitializationService };
+export { IUserDataInitializationService, UserDataInitializationService };

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfile.js

@@ -1,14 +1,38 @@
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 const IUserDataProfileService = ( createDecorator('IUserDataProfileService'));
+const IUserDataProfileManagementService = ( createDecorator('IUserDataProfileManagementService'));
+const PROFILE_URL_AUTHORITY = 'profile';
+function toUserDataProfileUri(path, productService) {
+    return ( URI.from({
+        scheme: productService.urlProtocol,
+        authority: PROFILE_URL_AUTHORITY,
+        path: path.startsWith('/') ? path : `/${path}`
+    }));
+}
 const IUserDataProfileImportExportService = ( createDecorator('IUserDataProfileImportExportService'));
 const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, ( localizeWithPath(
     'vs/workbench/services/userDataProfile/common/userDataProfile',
     'defaultProfileIcon',
     'Icon for Default Profile.'
 )));
+const PROFILES_TITLE = { value: ( localizeWithPath(
+    'vs/workbench/services/userDataProfile/common/userDataProfile',
+    'profiles',
+    "Profiles"
+)), original: 'Profiles' };
+const PROFILES_CATEGORY = { ...PROFILES_TITLE };
+const PROFILE_EXTENSION = 'code-profile';
+const PROFILE_FILTER = [{ name: ( localizeWithPath(
+    'vs/workbench/services/userDataProfile/common/userDataProfile',
+    'profile',
+    "Profile"
+)), extensions: [PROFILE_EXTENSION] }];
 const CURRENT_PROFILE_CONTEXT = ( new RawContextKey('currentProfile', ''));
-export { CURRENT_PROFILE_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileService, defaultUserDataProfileIcon };
+const IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT = ( new RawContextKey('isProfileExportInProgress', false));
+const IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT = ( new RawContextKey('isProfileImportInProgress', false));
+export { CURRENT_PROFILE_CONTEXT, IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT, IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileManagementService, IUserDataProfileService, PROFILES_CATEGORY, PROFILES_TITLE, PROFILE_EXTENSION, PROFILE_FILTER, PROFILE_URL_AUTHORITY, defaultUserDataProfileIcon, toUserDataProfileUri };

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfileIcons.js

@@ -6,4 +6,78 @@ const DEFAULT_ICON = registerIcon('settings-view-bar-icon', Codicon.settingsGear
  'settingsViewBarIcon',
  "Settings icon in the view bar."
 )));
-export { DEFAULT_ICON };
+const ICONS = [
+    DEFAULT_ICON,
+    Codicon.vm,
+    Codicon.server,
+    Codicon.recordKeys,
+    Codicon.deviceMobile,
+    Codicon.watch,
+    Codicon.vr,
+    Codicon.piano,
+    Codicon.ruby,
+    Codicon.code,
+    Codicon.coffee,
+    Codicon.snake,
+    Codicon.window,
+    Codicon.library,
+    Codicon.extensions,
+    Codicon.terminal,
+    Codicon.beaker,
+    Codicon.package,
+    Codicon.cloud,
+    Codicon.book,
+    Codicon.globe,
+    Codicon.database,
+    Codicon.notebook,
+    Codicon.robot,
+    Codicon.game,
+    Codicon.chip,
+    Codicon.music,
+    Codicon.gift,
+    Codicon.send,
+    Codicon.briefcase,
+    Codicon.megaphone,
+    Codicon.comment,
+    Codicon.telescope,
+    Codicon.creditCard,
+    Codicon.map,
+    Codicon.deviceCameraVideo,
+    Codicon.unmute,
+    Codicon.law,
+    Codicon.graphLine,
+    Codicon.heart,
+    Codicon.home,
+    Codicon.inbox,
+    Codicon.mortarBoard,
+    Codicon.rocket,
+    Codicon.magnet,
+    Codicon.lock,
+    Codicon.milestone,
+    Codicon.tag,
+    Codicon.pulse,
+    Codicon.radioTower,
+    Codicon.smiley,
+    Codicon.symbolEvent,
+    Codicon.squirrel,
+    Codicon.symbolColor,
+    Codicon.mail,
+    Codicon.key,
+    Codicon.pieChart,
+    Codicon.organization,
+    Codicon.preview,
+    Codicon.wand,
+    Codicon.starEmpty,
+    Codicon.lightbulb,
+    Codicon.symbolRuler,
+    Codicon.dashboard,
+    Codicon.calendar,
+    Codicon.shield,
+    Codicon.flame,
+    Codicon.compass,
+    Codicon.paintcan,
+    Codicon.archive,
+    Codicon.mic,
+    Codicon.jersey,
+];
+export { DEFAULT_ICON, ICONS };

package/vscode/src/vs/workbench/services/userDataSync/common/userDataSync.js

@@ -1,13 +1,83 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { localizeWithPath, localize2WithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
 const IUserDataSyncWorkbenchService = ( createDecorator('IUserDataSyncWorkbenchService'));
-registerIcon('settings-sync-view-icon', Codicon.sync, ( localizeWithPath(
+function getSyncAreaLabel(source) {
+    switch (source) {
+        case "settings" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'settings',
+            "Settings"
+        ));
+        case "keybindings" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'keybindings',
+            "Keyboard Shortcuts"
+        ));
+        case "snippets" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'snippets',
+            "User Snippets"
+        ));
+        case "tasks" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'tasks',
+            "User Tasks"
+        ));
+        case "extensions" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'extensions',
+            "Extensions"
+        ));
+        case "globalState" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'ui state label',
+            "UI State"
+        ));
+        case "profiles" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'profiles',
+            "Profiles"
+        ));
+        case "workspaceState" : return ( localizeWithPath(
+            'vs/workbench/services/userDataSync/common/userDataSync',
+            'workspace state label',
+            "Workspace State"
+        ));
+    }
+}
+const SYNC_TITLE = ( localize2WithPath(
+    'vs/workbench/services/userDataSync/common/userDataSync',
+    'sync category',
+    "Settings Sync"
+));
+const SYNC_VIEW_ICON = registerIcon('settings-sync-view-icon', Codicon.sync, ( localizeWithPath(
     'vs/workbench/services/userDataSync/common/userDataSync',
     'syncViewIcon',
     'View icon of the Settings Sync view.'
 )));
+const CONTEXT_SYNC_STATE = ( new RawContextKey('syncStatus', "uninitialized" ));
 const CONTEXT_SYNC_ENABLEMENT = ( new RawContextKey('syncEnabled', false));
-export { CONTEXT_SYNC_ENABLEMENT, IUserDataSyncWorkbenchService };
+const CONTEXT_ACCOUNT_STATE = ( new RawContextKey('userDataSyncAccountStatus', "unavailable" ));
+const CONTEXT_ENABLE_ACTIVITY_VIEWS = ( new RawContextKey(`enableSyncActivityViews`, false));
+const CONTEXT_ENABLE_SYNC_CONFLICTS_VIEW = ( new RawContextKey(`enableSyncConflictsView`, false));
+const CONTEXT_HAS_CONFLICTS = ( new RawContextKey('hasConflicts', false));
+const CONFIGURE_SYNC_COMMAND_ID = 'workbench.userDataSync.actions.configure';
+const SHOW_SYNC_LOG_COMMAND_ID = 'workbench.userDataSync.actions.showLog';
+const SYNC_VIEW_CONTAINER_ID = 'workbench.view.sync';
+const SYNC_CONFLICTS_VIEW_ID = 'workbench.views.sync.conflicts';
+const DOWNLOAD_ACTIVITY_ACTION_DESCRIPTOR = {
+    id: 'workbench.userDataSync.actions.downloadSyncActivity',
+    title: { original: 'Download Settings Sync Activity', value: ( localizeWithPath(
+        'vs/workbench/services/userDataSync/common/userDataSync',
+        'download sync activity title',
+        "Download Settings Sync Activity"
+    )) },
+    category: Categories.Developer,
+    f1: true,
+    precondition: ( ContextKeyExpr.and(( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), ( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" ))))
+};
+export { CONFIGURE_SYNC_COMMAND_ID, CONTEXT_ACCOUNT_STATE, CONTEXT_ENABLE_ACTIVITY_VIEWS, CONTEXT_ENABLE_SYNC_CONFLICTS_VIEW, CONTEXT_HAS_CONFLICTS, CONTEXT_SYNC_ENABLEMENT, CONTEXT_SYNC_STATE, DOWNLOAD_ACTIVITY_ACTION_DESCRIPTOR, IUserDataSyncWorkbenchService, SHOW_SYNC_LOG_COMMAND_ID, SYNC_CONFLICTS_VIEW_ID, SYNC_TITLE, SYNC_VIEW_CONTAINER_ID, SYNC_VIEW_ICON, getSyncAreaLabel };

package/vscode/src/vs/base/parts/request/browser/request.js

@@ -1,60 +0,0 @@
-import { bufferToStream, VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { OfflineError } from '../common/request.js';
-function request(options, token) {
-    if (options.proxyAuthorization) {
-        options.headers = {
-            ...(options.headers || {}),
-            'Proxy-Authorization': options.proxyAuthorization
-        };
-    }
-    const xhr = ( new XMLHttpRequest());
-    return ( new Promise((resolve, reject) => {
-        xhr.open(options.type || 'GET', options.url || '', true, options.user, options.password);
-        setRequestHeaders(xhr, options);
-        xhr.responseType = 'arraybuffer';
-        xhr.onerror = e => reject(navigator.onLine ? ( new Error(xhr.statusText && ('XHR failed: ' + xhr.statusText) || 'XHR failed')) : ( new OfflineError()));
-        xhr.onload = (e) => {
-            resolve({
-                res: {
-                    statusCode: xhr.status,
-                    headers: getResponseHeaders(xhr)
-                },
-                stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(xhr.response))))
-            });
-        };
-        xhr.ontimeout = e => reject(( new Error(`XHR timeout: ${options.timeout}ms`)));
-        if (options.timeout) {
-            xhr.timeout = options.timeout;
-        }
-        xhr.send(options.data);
-        token.onCancellationRequested(() => {
-            xhr.abort();
-            reject(canceled());
-        });
-    }));
-}
-function setRequestHeaders(xhr, options) {
-    if (options.headers) {
-        outer: for (const k in options.headers) {
-            switch (k) {
-                case 'User-Agent':
-                case 'Accept-Encoding':
-                case 'Content-Length':
-                    continue outer;
-            }
-            xhr.setRequestHeader(k, options.headers[k]);
-        }
-    }
-}
-function getResponseHeaders(xhr) {
-    const headers = Object.create(null);
-    for (const line of xhr.getAllResponseHeaders().split(/\r\n|\n|\r/g)) {
-        if (line) {
-            const idx = line.indexOf(':');
-            headers[line.substr(0, idx).trim().toLowerCase()] = line.substr(idx + 1).trim();
-        }
-    }
-    return headers;
-}
-export { request };

package/vscode/src/vs/platform/request/browser/requestService.js

@@ -1,28 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { request } from '../../../base/parts/request/browser/request.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { AbstractRequestService } from '../common/request.js';
-let RequestService = class RequestService extends AbstractRequestService {
-    constructor(configurationService, loggerService) {
-        super(loggerService);
-        this.configurationService = configurationService;
-    }
-    async request(options, token) {
-        if (!options.proxyAuthorization) {
-            options.proxyAuthorization = this.configurationService.getValue('http.proxyAuthorization');
-        }
-        return this.logAndRequest('browser', options, () => request(options, token));
-    }
-    async resolveProxy(url) {
-        return undefined;
-    }
-    async loadCertificates() {
-        return [];
-    }
-};
-RequestService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ILoggerService))
-], RequestService));
-export { RequestService };