@codingame/monaco-vscode-localization-service-override 4.1.0

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

@@ -0,0 +1,214 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { SideBySideEditor } from 'vscode/vscode/vs/workbench/browser/parts/editor/sideBySideEditor';
+import { isEditorPaneWithScrolling } from 'vscode/vscode/vs/workbench/common/editor';
+import { ReentrancyBarrier } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/browser/utils';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
+
+let SyncScroll = class SyncScroll extends Disposable {
+    static { this.ID = 'workbench.contrib.syncScrolling'; }
+    constructor(editorService, statusbarService) {
+        super();
+        this.editorService = editorService;
+        this.statusbarService = statusbarService;
+        this.paneInitialScrollTop = ( new Map());
+        this.syncScrollDispoasbles = this._register(( new DisposableStore()));
+        this.paneDisposables = ( new DisposableStore());
+        this.statusBarEntry = this._register(( new MutableDisposable()));
+        this.isActive = false;
+        this._reentrancyBarrier = ( new ReentrancyBarrier());
+        this.registerActions();
+    }
+    registerActiveListeners() {
+        this.syncScrollDispoasbles.add(this.editorService.onDidVisibleEditorsChange(() => this.trackVisiblePanes()));
+    }
+    activate() {
+        this.registerActiveListeners();
+        this.trackVisiblePanes();
+    }
+    toggle() {
+        if (this.isActive) {
+            this.deactivate();
+        }
+        else {
+            this.activate();
+        }
+        this.isActive = !this.isActive;
+        this.toggleStatusbarItem(this.isActive);
+    }
+    trackVisiblePanes() {
+        this.paneDisposables.clear();
+        this.paneInitialScrollTop.clear();
+        for (const pane of this.getAllVisiblePanes()) {
+            if (!isEditorPaneWithScrolling(pane)) {
+                continue;
+            }
+            this.paneInitialScrollTop.set(pane, pane.getScrollPosition());
+            this.paneDisposables.add(pane.onDidChangeScroll(() => this._reentrancyBarrier.runExclusively(() => {
+                this.onDidEditorPaneScroll(pane);
+            })));
+        }
+    }
+    onDidEditorPaneScroll(scrolledPane) {
+        const scrolledPaneInitialOffset = this.paneInitialScrollTop.get(scrolledPane);
+        if (scrolledPaneInitialOffset === undefined) {
+            throw new Error('Scrolled pane not tracked');
+        }
+        if (!isEditorPaneWithScrolling(scrolledPane)) {
+            throw new Error('Scrolled pane does not support scrolling');
+        }
+        const scrolledPaneCurrentPosition = scrolledPane.getScrollPosition();
+        const scrolledFromInitial = {
+            scrollTop: scrolledPaneCurrentPosition.scrollTop - scrolledPaneInitialOffset.scrollTop,
+            scrollLeft: scrolledPaneCurrentPosition.scrollLeft !== undefined && scrolledPaneInitialOffset.scrollLeft !== undefined ? scrolledPaneCurrentPosition.scrollLeft - scrolledPaneInitialOffset.scrollLeft : undefined,
+        };
+        for (const pane of this.getAllVisiblePanes()) {
+            if (pane === scrolledPane) {
+                continue;
+            }
+            if (!isEditorPaneWithScrolling(pane)) {
+                continue;
+            }
+            const initialOffset = this.paneInitialScrollTop.get(pane);
+            if (initialOffset === undefined) {
+                throw new Error('Could not find initial offset for pane');
+            }
+            const currentPanePosition = pane.getScrollPosition();
+            const newPaneScrollPosition = {
+                scrollTop: initialOffset.scrollTop + scrolledFromInitial.scrollTop,
+                scrollLeft: initialOffset.scrollLeft !== undefined && scrolledFromInitial.scrollLeft !== undefined ? initialOffset.scrollLeft + scrolledFromInitial.scrollLeft : undefined,
+            };
+            if (currentPanePosition.scrollTop === newPaneScrollPosition.scrollTop && currentPanePosition.scrollLeft === newPaneScrollPosition.scrollLeft) {
+                continue;
+            }
+            pane.setScrollPosition(newPaneScrollPosition);
+        }
+    }
+    getAllVisiblePanes() {
+        const panes = [];
+        for (const pane of this.editorService.visibleEditorPanes) {
+            if (pane instanceof SideBySideEditor) {
+                const primaryPane = pane.getPrimaryEditorPane();
+                const secondaryPane = pane.getSecondaryEditorPane();
+                if (primaryPane) {
+                    panes.push(primaryPane);
+                }
+                if (secondaryPane) {
+                    panes.push(secondaryPane);
+                }
+                continue;
+            }
+            panes.push(pane);
+        }
+        return panes;
+    }
+    deactivate() {
+        this.paneDisposables.clear();
+        this.syncScrollDispoasbles.clear();
+        this.paneInitialScrollTop.clear();
+    }
+    toggleStatusbarItem(active) {
+        if (active) {
+            if (!this.statusBarEntry.value) {
+                const text = ( localizeWithPath(
+                    'vs/workbench/contrib/scrollLocking/browser/scrollLocking',
+                    'mouseScrolllingLocked',
+                    'Scrolling Locked'
+                ));
+                const tooltip = ( localizeWithPath(
+                    'vs/workbench/contrib/scrollLocking/browser/scrollLocking',
+                    'mouseLockScrollingEnabled',
+                    'Lock Scrolling Enabled'
+                ));
+                this.statusBarEntry.value = this.statusbarService.addEntry({
+                    name: text,
+                    text,
+                    tooltip,
+                    ariaLabel: text,
+                    command: {
+                        id: 'workbench.action.toggleLockedScrolling',
+                        title: ''
+                    },
+                    kind: 'prominent',
+                    showInAllWindows: true
+                }, 'status.scrollLockingEnabled', 1 , 102);
+            }
+        }
+        else {
+            this.statusBarEntry.clear();
+        }
+    }
+    registerActions() {
+        const $this = this;
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.toggleLockedScrolling',
+                    title: {
+                        ...( localize2WithPath(
+                            'vs/workbench/contrib/scrollLocking/browser/scrollLocking',
+                            'toggleLockedScrolling',
+                            "Toggle Locked Scrolling Across Editors"
+                        )),
+                        mnemonicTitle: ( localizeWithPath(
+                            'vs/workbench/contrib/scrollLocking/browser/scrollLocking',
+                            { key: 'miToggleLockedScrolling', comment: ['&& denotes a mnemonic'] },
+                            "Locked Scrolling"
+                        )),
+                    },
+                    category: Categories.View,
+                    f1: true
+                });
+            }
+            run() {
+                $this.toggle();
+            }
+        }));
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.action.holdLockedScrolling',
+                    title: {
+                        ...( localize2WithPath(
+                            'vs/workbench/contrib/scrollLocking/browser/scrollLocking',
+                            'holdLockedScrolling',
+                            "Hold Locked Scrolling Across Editors"
+                        )),
+                        mnemonicTitle: ( localizeWithPath(
+                            'vs/workbench/contrib/scrollLocking/browser/scrollLocking',
+                            { key: 'miHoldLockedScrolling', comment: ['&& denotes a mnemonic'] },
+                            "Locked Scrolling"
+                        )),
+                    },
+                    category: Categories.View,
+                });
+            }
+            run(accessor) {
+                const keybindingService = accessor.get(IKeybindingService);
+                $this.toggle();
+                const holdMode = keybindingService.enableKeybindingHoldMode('workbench.action.holdLockedScrolling');
+                if (!holdMode) {
+                    return;
+                }
+                holdMode.finally(() => {
+                    $this.toggle();
+                });
+            }
+        }));
+    }
+    dispose() {
+        this.deactivate();
+        super.dispose();
+    }
+};
+SyncScroll = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IStatusbarService))
+], SyncScroll));
+
+export { SyncScroll };

package/vscode/src/vs/workbench/contrib/splash/browser/partsSplash.js

@@ -0,0 +1,117 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { onDidChangeFullscreen, isFullscreen } from 'vscode/vscode/vs/base/browser/browser';
+import { getTotalHeight, getTotalWidth, runWhenWindowIdle } from 'vscode/vscode/vs/base/browser/dom';
+import { Color } from 'vscode/vscode/vs/base/common/color';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import { foreground } from 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorBackground } from 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { getThemeTypeSelector, IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS } from 'vscode/vscode/vs/workbench/browser/parts/editor/editor';
+import { WORKBENCH_BACKGROUND, TITLE_BAR_ACTIVE_BACKGROUND, ACTIVITY_BAR_BACKGROUND, SIDE_BAR_BACKGROUND, STATUS_BAR_BACKGROUND, STATUS_BAR_NO_FOLDER_BACKGROUND, WINDOW_ACTIVE_BORDER, WINDOW_INACTIVE_BORDER } from 'vscode/vscode/vs/workbench/common/theme';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { mark } from 'vscode/vscode/vs/base/common/performance';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { ISplashStorageService } from './splash.js';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+
+var PartsSplash_1;
+let PartsSplash = class PartsSplash {
+    static { PartsSplash_1 = this; }
+    static { this.ID = 'workbench.contrib.partsSplash'; }
+    static { this._splashElementId = 'monaco-parts-splash'; }
+    constructor(_themeService, _layoutService, _environmentService, _configService, _partSplashService, editorGroupsService, lifecycleService) {
+        this._themeService = _themeService;
+        this._layoutService = _layoutService;
+        this._environmentService = _environmentService;
+        this._configService = _configService;
+        this._partSplashService = _partSplashService;
+        this._disposables = ( new DisposableStore());
+        Event.once(_layoutService.onDidLayoutMainContainer)(() => {
+            this._removePartsSplash();
+            mark('code/didRemovePartsSplash');
+        }, undefined, this._disposables);
+        const lastIdleSchedule = this._disposables.add(( new MutableDisposable()));
+        const savePartsSplashSoon = () => {
+            lastIdleSchedule.value = runWhenWindowIdle(mainWindow, () => this._savePartsSplash(), 2500);
+        };
+        lifecycleService.when(3 ).then(() => {
+            Event.any(Event.filter(onDidChangeFullscreen, windowId => windowId === mainWindow.vscodeWindowId), editorGroupsService.mainPart.onDidLayout, _themeService.onDidColorThemeChange)(savePartsSplashSoon, undefined, this._disposables);
+            savePartsSplashSoon();
+        });
+        _configService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("window.titleBarStyle" )) {
+                this._didChangeTitleBarStyle = true;
+                this._savePartsSplash();
+            }
+        }, this, this._disposables);
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    _savePartsSplash() {
+        const theme = this._themeService.getColorTheme();
+        this._partSplashService.saveWindowSplash({
+            zoomLevel: this._configService.getValue('window.zoomLevel'),
+            baseTheme: getThemeTypeSelector(theme.type),
+            colorInfo: {
+                foreground: theme.getColor(foreground)?.toString(),
+                background: Color.Format.CSS.formatHex(theme.getColor(editorBackground) || WORKBENCH_BACKGROUND(theme)),
+                editorBackground: theme.getColor(editorBackground)?.toString(),
+                titleBarBackground: theme.getColor(TITLE_BAR_ACTIVE_BACKGROUND)?.toString(),
+                activityBarBackground: theme.getColor(ACTIVITY_BAR_BACKGROUND)?.toString(),
+                sideBarBackground: theme.getColor(SIDE_BAR_BACKGROUND)?.toString(),
+                statusBarBackground: theme.getColor(STATUS_BAR_BACKGROUND)?.toString(),
+                statusBarNoFolderBackground: theme.getColor(STATUS_BAR_NO_FOLDER_BACKGROUND)?.toString(),
+                windowBorder: theme.getColor(WINDOW_ACTIVE_BORDER)?.toString() ?? theme.getColor(WINDOW_INACTIVE_BORDER)?.toString()
+            },
+            layoutInfo: !this._shouldSaveLayoutInfo() ? undefined : {
+                sideBarSide: this._layoutService.getSideBarPosition() === 1  ? 'right' : 'left',
+                editorPartMinWidth: DEFAULT_EDITOR_MIN_DIMENSIONS.width,
+                titleBarHeight: this._layoutService.isVisible("workbench.parts.titlebar" , mainWindow) ? getTotalHeight(assertIsDefined(this._layoutService.getContainer(mainWindow, "workbench.parts.titlebar" ))) : 0,
+                activityBarWidth: this._layoutService.isVisible("workbench.parts.activitybar" ) ? getTotalWidth(assertIsDefined(this._layoutService.getContainer(mainWindow, "workbench.parts.activitybar" ))) : 0,
+                sideBarWidth: this._layoutService.isVisible("workbench.parts.sidebar" ) ? getTotalWidth(assertIsDefined(this._layoutService.getContainer(mainWindow, "workbench.parts.sidebar" ))) : 0,
+                statusBarHeight: this._layoutService.isVisible("workbench.parts.statusbar" , mainWindow) ? getTotalHeight(assertIsDefined(this._layoutService.getContainer(mainWindow, "workbench.parts.statusbar" ))) : 0,
+                windowBorder: this._layoutService.hasMainWindowBorder(),
+                windowBorderRadius: this._layoutService.getMainWindowBorderRadius()
+            }
+        });
+    }
+    _shouldSaveLayoutInfo() {
+        return !isFullscreen(mainWindow) && !this._environmentService.isExtensionDevelopment && !this._didChangeTitleBarStyle;
+    }
+    _removePartsSplash() {
+        const element = mainWindow.document.getElementById(PartsSplash_1._splashElementId);
+        if (element) {
+            element.style.display = 'none';
+        }
+        const defaultStyles = mainWindow.document.head.getElementsByClassName('initialShellColors');
+        if (defaultStyles.length) {
+            mainWindow.document.head.removeChild(defaultStyles[0]);
+        }
+    }
+};
+PartsSplash = PartsSplash_1 = ( __decorate([
+    ( __param(0, IThemeService)),
+    ( __param(1, IWorkbenchLayoutService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ISplashStorageService)),
+    ( __param(5, IEditorGroupsService)),
+    ( __param(6, ILifecycleService))
+], PartsSplash));
+
+export { PartsSplash };

package/vscode/src/vs/workbench/contrib/splash/browser/splash.contribution.js

@@ -0,0 +1,5 @@
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { PartsSplash } from './partsSplash.js';
+
+registerWorkbenchContribution2(PartsSplash.ID, PartsSplash, 1 );

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

@@ -0,0 +1,5 @@
+import { createDecorator } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+const ISplashStorageService = ( createDecorator('ISplashStorageService'));
+
+export { ISplashStorageService };

package/vscode/src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.js

@@ -0,0 +1,227 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IWorkbenchThemeService } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { language } from 'vscode/vscode/vs/base/common/platform';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import ErrorTelemetry from '../../../../platform/telemetry/browser/errorTelemetry.js';
+import { TelemetryTrustedValue } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { ConfigurationTargetToString, IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { extname, isEqual, isEqualOrParent, basename } from 'vscode/vscode/vs/base/common/resources';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { getMimeTypes } from 'vscode/vscode/vs/editor/common/services/languagesAssociations';
+import { hash } from 'vscode/vscode/vs/base/common/hash';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { isNumber, isBoolean, isString } from 'vscode/vscode/vs/base/common/types';
+import { AutoUpdateConfigurationKey } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { KEYWORD_ACTIVIATION_SETTING_ID } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+
+var TelemetryContribution_1;
+let TelemetryContribution = class TelemetryContribution extends Disposable {
+    static { TelemetryContribution_1 = this; }
+    static { this.ALLOWLIST_JSON = ['package.json', 'package-lock.json', 'tsconfig.json', 'jsconfig.json', 'bower.json', '.eslintrc.json', 'tslint.json', 'composer.json']; }
+    static { this.ALLOWLIST_WORKSPACE_JSON = ['settings.json', 'extensions.json', 'tasks.json', 'launch.json']; }
+    constructor(telemetryService, contextService, lifecycleService, editorService, keybindingsService, themeService, environmentService, userDataProfileService, paneCompositeService, textFileService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.contextService = contextService;
+        this.userDataProfileService = userDataProfileService;
+        const { filesToOpenOrCreate, filesToDiff, filesToMerge } = environmentService;
+        const activeViewlet = paneCompositeService.getActivePaneComposite(0 );
+        telemetryService.publicLog2('workspaceLoad', {
+            windowSize: { innerHeight: mainWindow.innerHeight, innerWidth: mainWindow.innerWidth, outerHeight: mainWindow.outerHeight, outerWidth: mainWindow.outerWidth },
+            emptyWorkbench: contextService.getWorkbenchState() === 1 ,
+            'workbench.filesToOpenOrCreate': filesToOpenOrCreate && filesToOpenOrCreate.length || 0,
+            'workbench.filesToDiff': filesToDiff && filesToDiff.length || 0,
+            'workbench.filesToMerge': filesToMerge && filesToMerge.length || 0,
+            customKeybindingsCount: keybindingsService.customKeybindingsCount(),
+            theme: themeService.getColorTheme().id,
+            language,
+            pinnedViewlets: paneCompositeService.getPinnedPaneCompositeIds(0 ),
+            restoredViewlet: activeViewlet ? activeViewlet.getId() : undefined,
+            restoredEditors: editorService.visibleEditors.length,
+            startupKind: lifecycleService.startupKind
+        });
+        this._register(( new ErrorTelemetry(telemetryService)));
+        this._register(textFileService.files.onDidResolve(e => this.onTextFileModelResolved(e)));
+        this._register(textFileService.files.onDidSave(e => this.onTextFileModelSaved(e)));
+        this._register(lifecycleService.onDidShutdown(() => this.dispose()));
+    }
+    onTextFileModelResolved(e) {
+        const settingsType = this.getTypeIfSettings(e.model.resource);
+        if (settingsType) {
+            this.telemetryService.publicLog2('settingsRead', { settingsType });
+        }
+        else {
+            this.telemetryService.publicLog2('fileGet', this.getTelemetryData(e.model.resource, e.reason));
+        }
+    }
+    onTextFileModelSaved(e) {
+        const settingsType = this.getTypeIfSettings(e.model.resource);
+        if (settingsType) {
+            this.telemetryService.publicLog2('settingsWritten', { settingsType });
+        }
+        else {
+            this.telemetryService.publicLog2('filePUT', this.getTelemetryData(e.model.resource, e.reason));
+        }
+    }
+    getTypeIfSettings(resource) {
+        if (extname(resource) !== '.json') {
+            return '';
+        }
+        if (isEqual(resource, this.userDataProfileService.currentProfile.settingsResource)) {
+            return 'global-settings';
+        }
+        if (isEqual(resource, this.userDataProfileService.currentProfile.keybindingsResource)) {
+            return 'keybindings';
+        }
+        if (isEqualOrParent(resource, this.userDataProfileService.currentProfile.snippetsHome)) {
+            return 'snippets';
+        }
+        const folders = this.contextService.getWorkspace().folders;
+        for (const folder of folders) {
+            if (isEqualOrParent(resource, folder.toResource('.vscode'))) {
+                const filename = basename(resource);
+                if (TelemetryContribution_1.ALLOWLIST_WORKSPACE_JSON.indexOf(filename) > -1) {
+                    return `.vscode/${filename}`;
+                }
+            }
+        }
+        return '';
+    }
+    getTelemetryData(resource, reason) {
+        let ext = extname(resource);
+        const queryStringLocation = ext.indexOf('?');
+        ext = queryStringLocation !== -1 ? ext.substr(0, queryStringLocation) : ext;
+        const fileName = basename(resource);
+        const path = resource.scheme === Schemas.file ? resource.fsPath : resource.path;
+        const telemetryData = {
+            mimeType: ( new TelemetryTrustedValue(getMimeTypes(resource).join(', '))),
+            ext,
+            path: hash(path),
+            reason,
+            allowlistedjson: undefined
+        };
+        if (ext === '.json' && TelemetryContribution_1.ALLOWLIST_JSON.indexOf(fileName) > -1) {
+            telemetryData['allowlistedjson'] = fileName;
+        }
+        return telemetryData;
+    }
+};
+TelemetryContribution = TelemetryContribution_1 = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IWorkbenchThemeService)),
+    ( __param(6, IWorkbenchEnvironmentService)),
+    ( __param(7, IUserDataProfileService)),
+    ( __param(8, IPaneCompositePartService)),
+    ( __param(9, ITextFileService))
+], TelemetryContribution));
+let ConfigurationTelemetryContribution = class ConfigurationTelemetryContribution extends Disposable {
+    constructor(configurationService, telemetryService) {
+        super();
+        this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
+        this.configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+        const debouncedConfigService = Event.debounce(configurationService.onDidChangeConfiguration, (last, cur) => {
+            const newAffectedKeys = last ? ( new Set([...last.affectedKeys, ...cur.affectedKeys])) : cur.affectedKeys;
+            return { ...cur, affectedKeys: newAffectedKeys };
+        }, 1000, true);
+        this._register(debouncedConfigService(event => {
+            if (event.source !== 7 ) {
+                telemetryService.publicLog2('updateConfiguration', {
+                    configurationSource: ConfigurationTargetToString(event.source),
+                    configurationKeys: Array.from(event.affectedKeys)
+                });
+            }
+        }));
+        const { user, workspace } = ( configurationService.keys());
+        for (const setting of user) {
+            this.reportTelemetry(setting, 3 );
+        }
+        for (const setting of workspace) {
+            this.reportTelemetry(setting, 5 );
+        }
+    }
+    getValueToReport(key, target) {
+        const inpsectData = this.configurationService.inspect(key);
+        const value = target === 3  ? inpsectData.user?.value : inpsectData.workspace?.value;
+        if (isNumber(value) || isBoolean(value)) {
+            return ( value.toString());
+        }
+        const schema = this.configurationRegistry.getConfigurationProperties()[key];
+        if (isString(value)) {
+            if (schema?.enum?.includes(value)) {
+                return value;
+            }
+            return undefined;
+        }
+        if (Array.isArray(value)) {
+            if (value.every(v => isNumber(v) || isBoolean(v) || (isString(v) && schema?.enum?.includes(v)))) {
+                return JSON.stringify(value);
+            }
+        }
+        return undefined;
+    }
+    reportTelemetry(key, target) {
+        const source = ConfigurationTargetToString(target);
+        switch (key) {
+            case "workbench.activityBar.location" :
+                this.telemetryService.publicLog2('workbench.activityBar.location', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case AutoUpdateConfigurationKey:
+                this.telemetryService.publicLog2('extensions.autoUpdate', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'files.autoSave':
+                this.telemetryService.publicLog2('files.autoSave', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'editor.stickyScroll.enabled':
+                this.telemetryService.publicLog2('editor.stickyScroll.enabled', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case KEYWORD_ACTIVIATION_SETTING_ID:
+                this.telemetryService.publicLog2('accessibility.voice.keywordActivation', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.zoomLevel':
+                this.telemetryService.publicLog2('window.zoomLevel', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.zoomPerWindow':
+                this.telemetryService.publicLog2('window.zoomPerWindow', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.titleBarStyle':
+                this.telemetryService.publicLog2('window.titleBarStyle', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.customTitleBarVisibility':
+                this.telemetryService.publicLog2('window.customTitleBarVisibility', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'window.nativeTabs':
+                this.telemetryService.publicLog2('window.nativeTabs', { settingValue: this.getValueToReport(key, target), source });
+                return;
+            case 'extensions.verifySignature':
+                this.telemetryService.publicLog2('extensions.verifySignature', { settingValue: this.getValueToReport(key, target), source });
+                return;
+        }
+    }
+};
+ConfigurationTelemetryContribution = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ITelemetryService))
+], ConfigurationTelemetryContribution));
+const workbenchContributionRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionRegistry.registerWorkbenchContribution(TelemetryContribution, 3 );
+workbenchContributionRegistry.registerWorkbenchContribution(ConfigurationTelemetryContribution, 4 );
+
+export { TelemetryContribution };

package/vscode/src/vs/workbench/contrib/userDataProfile/browser/userDataProfile.contribution.js

@@ -0,0 +1,9 @@
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { UserDataProfilesWorkbenchContribution } from './userDataProfile.js';
+import './userDataProfileActions.js';
+import { UserDataProfilePreviewContribution } from './userDataProfilePreview.js';
+
+const workbenchRegistry = ( Registry.as(Extensions.Workbench));
+registerWorkbenchContribution2(UserDataProfilesWorkbenchContribution.ID, UserDataProfilesWorkbenchContribution, 2 );
+workbenchRegistry.registerWorkbenchContribution(UserDataProfilePreviewContribution, 3 );