@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.js

@@ -0,0 +1,259 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { LanguageDetectionStatsId } from '../common/languageDetectionWorkerService.js';
+import { FileAccess, Schemas, nodeModulesPath, nodeModulesAsarPath } from '../../../../base/common/network.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { URI } from '../../../../base/common/uri.js';
+import { isWeb } from '../../../../base/common/platform.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { SimpleWorkerClient } from '../../../../base/common/worker/simpleWorker.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { EditorWorkerClient, EditorWorkerHost } from '../../../../editor/browser/services/editorWorkerService.js';
+import { ILanguageConfigurationService } from '../../../../editor/common/languages/languageConfigurationRegistry.js';
+import { IDiagnosticsService } from '../../../../platform/diagnostics/common/diagnostics.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { LRUCache } from '../../../../base/common/map.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+var LanguageDetectionService_1;
+const TOP_LANG_COUNTS = 12;
+const regexpModuleLocation = `${nodeModulesPath}/vscode-regexp-languagedetection`;
+const regexpModuleLocationAsar = `${nodeModulesAsarPath}/vscode-regexp-languagedetection`;
+const moduleLocation = `${nodeModulesPath}/@vscode/vscode-languagedetection`;
+const moduleLocationAsar = `${nodeModulesAsarPath}/@vscode/vscode-languagedetection`;
+let LanguageDetectionService = class LanguageDetectionService extends Disposable {
+    static { LanguageDetectionService_1 = this; }
+    static { this.enablementSettingKey = 'workbench.editor.languageDetection'; }
+    static { this.historyBasedEnablementConfig = 'workbench.editor.historyBasedLanguageDetection'; }
+    static { this.preferHistoryConfig = 'workbench.editor.preferHistoryBasedLanguageDetection'; }
+    static { this.workspaceOpenedLanguagesStorageKey = 'workbench.editor.languageDetectionOpenedLanguages.workspace'; }
+    static { this.globalOpenedLanguagesStorageKey = 'workbench.editor.languageDetectionOpenedLanguages.global'; }
+    constructor(_environmentService, languageService, _configurationService, _diagnosticsService, _workspaceContextService, modelService, _editorService, telemetryService, storageService, _logService, languageConfigurationService) {
+        super();
+        this._environmentService = _environmentService;
+        this._configurationService = _configurationService;
+        this._diagnosticsService = _diagnosticsService;
+        this._workspaceContextService = _workspaceContextService;
+        this._editorService = _editorService;
+        this._logService = _logService;
+        this.hasResolvedWorkspaceLanguageIds = false;
+        this.workspaceLanguageIds = ( new Set());
+        this.sessionOpenedLanguageIds = ( new Set());
+        this.historicalGlobalOpenedLanguageIds = ( new LRUCache(TOP_LANG_COUNTS));
+        this.historicalWorkspaceOpenedLanguageIds = ( new LRUCache(TOP_LANG_COUNTS));
+        this.dirtyBiases = true;
+        this.langBiases = {};
+        this._languageDetectionWorkerClient = this._register(( new LanguageDetectionWorkerClient(
+            modelService,
+            languageService,
+            telemetryService,
+            this._environmentService.isBuilt && !isWeb
+                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/dist/lib/index.js`)).toString(true))
+                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/dist/lib/index.js`)).toString(true)),
+            this._environmentService.isBuilt && !isWeb
+                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/model/model.json`)).toString(true))
+                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/model.json`)).toString(true)),
+            this._environmentService.isBuilt && !isWeb
+                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/model/group1-shard1of1.bin`)).toString(true))
+                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/group1-shard1of1.bin`)).toString(true)),
+            this._environmentService.isBuilt && !isWeb
+                ? ( ( FileAccess.asBrowserUri(`${regexpModuleLocationAsar}/dist/index.js`)).toString(true))
+                : ( ( FileAccess.asBrowserUri(`${regexpModuleLocation}/dist/index.js`)).toString(true)),
+            languageConfigurationService
+        )));
+        this.initEditorOpenedListeners(storageService);
+    }
+    async resolveWorkspaceLanguageIds() {
+        if (this.hasResolvedWorkspaceLanguageIds) {
+            return;
+        }
+        this.hasResolvedWorkspaceLanguageIds = true;
+        const fileExtensions = await this._diagnosticsService.getWorkspaceFileExtensions(this._workspaceContextService.getWorkspace());
+        let count = 0;
+        for (const ext of fileExtensions.extensions) {
+            const langId = this._languageDetectionWorkerClient.getLanguageId(ext);
+            if (langId && count < TOP_LANG_COUNTS) {
+                this.workspaceLanguageIds.add(langId);
+                count++;
+                if (count > TOP_LANG_COUNTS) {
+                    break;
+                }
+            }
+        }
+        this.dirtyBiases = true;
+    }
+    isEnabledForLanguage(languageId) {
+        return !!languageId && this._configurationService.getValue(LanguageDetectionService_1.enablementSettingKey, { overrideIdentifier: languageId });
+    }
+    getLanguageBiases() {
+        if (!this.dirtyBiases) {
+            return this.langBiases;
+        }
+        const biases = {};
+        this.sessionOpenedLanguageIds.forEach(lang => biases[lang] = (biases[lang] ?? 0) + 7);
+        this.workspaceLanguageIds.forEach(lang => biases[lang] = (biases[lang] ?? 0) + 5);
+        [...( this.historicalWorkspaceOpenedLanguageIds.keys())].forEach(lang => biases[lang] = (biases[lang] ?? 0) + 3);
+        [...( this.historicalGlobalOpenedLanguageIds.keys())].forEach(lang => biases[lang] = (biases[lang] ?? 0) + 1);
+        this._logService.trace('Session Languages:', JSON.stringify([...this.sessionOpenedLanguageIds]));
+        this._logService.trace('Workspace Languages:', JSON.stringify([...this.workspaceLanguageIds]));
+        this._logService.trace('Historical Workspace Opened Languages:', JSON.stringify([...( this.historicalWorkspaceOpenedLanguageIds.keys())]));
+        this._logService.trace('Historical Globally Opened Languages:', JSON.stringify([...( this.historicalGlobalOpenedLanguageIds.keys())]));
+        this._logService.trace('Computed Language Detection Biases:', JSON.stringify(biases));
+        this.dirtyBiases = false;
+        this.langBiases = biases;
+        return biases;
+    }
+    async detectLanguage(resource, supportedLangs) {
+        const useHistory = this._configurationService.getValue(LanguageDetectionService_1.historyBasedEnablementConfig);
+        const preferHistory = this._configurationService.getValue(LanguageDetectionService_1.preferHistoryConfig);
+        if (useHistory) {
+            await this.resolveWorkspaceLanguageIds();
+        }
+        const biases = useHistory ? this.getLanguageBiases() : undefined;
+        return this._languageDetectionWorkerClient.detectLanguage(resource, biases, preferHistory, supportedLangs);
+    }
+    initEditorOpenedListeners(storageService) {
+        try {
+            const globalLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, 0 , '[]'));
+            this.historicalGlobalOpenedLanguageIds.fromJSON(globalLangHistoryData);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        try {
+            const workspaceLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, 1 , '[]'));
+            this.historicalWorkspaceOpenedLanguageIds.fromJSON(workspaceLangHistoryData);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        this._register(this._editorService.onDidActiveEditorChange(() => {
+            const activeLanguage = this._editorService.activeTextEditorLanguageId;
+            if (activeLanguage && this._editorService.activeEditor?.resource?.scheme !== Schemas.untitled) {
+                this.sessionOpenedLanguageIds.add(activeLanguage);
+                this.historicalGlobalOpenedLanguageIds.set(activeLanguage, true);
+                this.historicalWorkspaceOpenedLanguageIds.set(activeLanguage, true);
+                storageService.store(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, JSON.stringify(this.historicalGlobalOpenedLanguageIds.toJSON()), 0 , 1 );
+                storageService.store(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, JSON.stringify(this.historicalWorkspaceOpenedLanguageIds.toJSON()), 1 , 1 );
+                this.dirtyBiases = true;
+            }
+        }));
+    }
+};
+LanguageDetectionService = LanguageDetectionService_1 = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IDiagnosticsService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, IModelService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IStorageService)),
+    ( __param(9, ILogService)),
+    ( __param(10, ILanguageConfigurationService))
+], LanguageDetectionService));
+class LanguageDetectionWorkerClient extends EditorWorkerClient {
+    constructor(modelService, _languageService, _telemetryService, _indexJsUri, _modelJsonUri, _weightsUri, _regexpModelUri, languageConfigurationService) {
+        super(modelService, true, 'languageDetectionWorkerService', languageConfigurationService);
+        this._languageService = _languageService;
+        this._telemetryService = _telemetryService;
+        this._indexJsUri = _indexJsUri;
+        this._modelJsonUri = _modelJsonUri;
+        this._weightsUri = _weightsUri;
+        this._regexpModelUri = _regexpModelUri;
+    }
+    _getOrCreateLanguageDetectionWorker() {
+        if (this.workerPromise) {
+            return this.workerPromise;
+        }
+        this.workerPromise = ( new Promise((resolve, reject) => {
+            resolve(this._register(( new SimpleWorkerClient(
+                this._workerFactory,
+                'vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker',
+                ( new EditorWorkerHost(this))
+            ))));
+        }));
+        return this.workerPromise;
+    }
+    _guessLanguageIdByUri(uri) {
+        const guess = this._languageService.guessLanguageIdByFilepathOrFirstLine(uri);
+        if (guess && guess !== 'unknown') {
+            return guess;
+        }
+        return undefined;
+    }
+    async _getProxy() {
+        return (await this._getOrCreateLanguageDetectionWorker()).getProxyObject();
+    }
+    async fhr(method, args) {
+        switch (method) {
+            case 'getIndexJsUri':
+                return this.getIndexJsUri();
+            case 'getModelJsonUri':
+                return this.getModelJsonUri();
+            case 'getWeightsUri':
+                return this.getWeightsUri();
+            case 'getRegexpModelUri':
+                return this.getRegexpModelUri();
+            case 'getLanguageId':
+                return this.getLanguageId(args[0]);
+            case 'sendTelemetryEvent':
+                return this.sendTelemetryEvent(args[0], args[1], args[2]);
+            default:
+                return super.fhr(method, args);
+        }
+    }
+    async getIndexJsUri() {
+        return this._indexJsUri;
+    }
+    getLanguageId(languageIdOrExt) {
+        if (!languageIdOrExt) {
+            return undefined;
+        }
+        if (this._languageService.isRegisteredLanguageId(languageIdOrExt)) {
+            return languageIdOrExt;
+        }
+        const guessed = this._guessLanguageIdByUri(URI.file(`file.${languageIdOrExt}`));
+        if (!guessed || guessed === 'unknown') {
+            return undefined;
+        }
+        return guessed;
+    }
+    async getModelJsonUri() {
+        return this._modelJsonUri;
+    }
+    async getWeightsUri() {
+        return this._weightsUri;
+    }
+    async getRegexpModelUri() {
+        return this._regexpModelUri;
+    }
+    async sendTelemetryEvent(languages, confidences, timeSpent) {
+        this._telemetryService.publicLog2(LanguageDetectionStatsId, {
+            languages: languages.join(','),
+            confidences: confidences.join(','),
+            timeSpent
+        });
+    }
+    async detectLanguage(resource, langBiases, preferHistory, supportedLangs) {
+        const startTime = Date.now();
+        const quickGuess = this._guessLanguageIdByUri(resource);
+        if (quickGuess) {
+            return quickGuess;
+        }
+        await this._withSyncedResources([resource]);
+        const modelId = await (await this._getProxy()).detectLanguage(( resource.toString()), langBiases, preferHistory, supportedLangs);
+        const languageId = this.getLanguageId(modelId);
+        const LanguageDetectionStatsId = 'automaticlanguagedetection.perf';
+        this._telemetryService.publicLog2(LanguageDetectionStatsId, {
+            timeSpent: Date.now() - startTime,
+            detection: languageId || 'unknown',
+        });
+        return languageId;
+    }
+}
+export { LanguageDetectionService, LanguageDetectionWorkerClient };

package/vscode/src/vs/workbench/services/lifecycle/browser/lifecycleService.js

@@ -0,0 +1,135 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { AbstractLifecycleService } from '../common/lifecycleService.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { addDisposableListener, EventType } from '../../../../base/browser/dom.js';
+import { WillSaveStateReason, IStorageService } from '../../../../platform/storage/common/storage.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { firstOrDefault } from '../../../../base/common/arrays.js';
+let BrowserLifecycleService = class BrowserLifecycleService extends AbstractLifecycleService {
+    constructor(logService, storageService) {
+        super(logService, storageService);
+        this.beforeUnloadListener = undefined;
+        this.unloadListener = undefined;
+        this.ignoreBeforeUnload = false;
+        this.didUnload = false;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.beforeUnloadListener = addDisposableListener(mainWindow, EventType.BEFORE_UNLOAD, (e) => this.onBeforeUnload(e));
+        this.unloadListener = addDisposableListener(mainWindow, EventType.PAGE_HIDE, () => this.onUnload());
+    }
+    onBeforeUnload(event) {
+        if (this.ignoreBeforeUnload) {
+            this.logService.info('[lifecycle] onBeforeUnload triggered but ignored once');
+            this.ignoreBeforeUnload = false;
+        }
+        else {
+            this.logService.info('[lifecycle] onBeforeUnload triggered and handled with veto support');
+            this.doShutdown(() => this.vetoBeforeUnload(event));
+        }
+    }
+    vetoBeforeUnload(event) {
+        event.preventDefault();
+        event.returnValue = ( localizeWithPath(
+            'vs/workbench/services/lifecycle/browser/lifecycleService',
+            'lifecycleVeto',
+            "Changes that you made may not be saved. Please check press 'Cancel' and try again."
+        ));
+    }
+    withExpectedShutdown(reason, callback) {
+        if (typeof reason === 'number') {
+            this.shutdownReason = reason;
+            return this.storageService.flush(WillSaveStateReason.SHUTDOWN);
+        }
+        else {
+            this.ignoreBeforeUnload = true;
+            try {
+                callback?.();
+            }
+            finally {
+                this.ignoreBeforeUnload = false;
+            }
+        }
+    }
+    async shutdown() {
+        this.logService.info('[lifecycle] shutdown triggered');
+        this.beforeUnloadListener?.dispose();
+        this.unloadListener?.dispose();
+        await this.storageService.flush(WillSaveStateReason.SHUTDOWN);
+        this.doShutdown();
+    }
+    doShutdown(vetoShutdown) {
+        const logService = this.logService;
+        this.storageService.flush(WillSaveStateReason.SHUTDOWN);
+        let veto = false;
+        function handleVeto(vetoResult, id) {
+            if (typeof vetoShutdown !== 'function') {
+                return;
+            }
+            if (vetoResult instanceof Promise) {
+                logService.error(`[lifecycle] Long running operations before shutdown are unsupported in the web (id: ${id})`);
+                veto = true;
+            }
+            if (vetoResult === true) {
+                logService.info(`[lifecycle]: Unload was prevented (id: ${id})`);
+                veto = true;
+            }
+        }
+        this._onBeforeShutdown.fire({
+            reason: 2 ,
+            veto(value, id) {
+                handleVeto(value, id);
+            },
+            finalVeto(valueFn, id) {
+                handleVeto(valueFn(), id);
+            }
+        });
+        if (veto && typeof vetoShutdown === 'function') {
+            return vetoShutdown();
+        }
+        return this.onUnload();
+    }
+    onUnload() {
+        if (this.didUnload) {
+            return;
+        }
+        this.didUnload = true;
+        this._register(addDisposableListener(mainWindow, EventType.PAGE_SHOW, (e) => this.onLoadAfterUnload(e)));
+        const logService = this.logService;
+        this._onWillShutdown.fire({
+            reason: 2 ,
+            joiners: () => [],
+            token: CancellationToken.None,
+            join(promise, joiner) {
+                logService.error(`[lifecycle] Long running operations during shutdown are unsupported in the web (id: ${joiner.id})`);
+            },
+            force: () => { },
+        });
+        this._onDidShutdown.fire();
+    }
+    onLoadAfterUnload(event) {
+        const wasRestoredFromCache = event.persisted;
+        if (!wasRestoredFromCache) {
+            return;
+        }
+        this.withExpectedShutdown({ disableShutdownHandling: true }, () => mainWindow.location.reload());
+    }
+    doResolveStartupKind() {
+        let startupKind = super.doResolveStartupKind();
+        if (typeof startupKind !== 'number') {
+            const timing = firstOrDefault(performance.getEntriesByType('navigation'));
+            if (timing?.type === 'reload') {
+                startupKind = 3 ;
+            }
+        }
+        return startupKind;
+    }
+};
+BrowserLifecycleService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IStorageService))
+], BrowserLifecycleService));
+export { BrowserLifecycleService };

package/vscode/src/vs/workbench/services/localization/common/locale.d.ts

@@ -0,0 +1,11 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILanguagePackItem } from '../../../../platform/languagePacks/common/languagePacks.js';
+
+declare const ILocaleService: ServiceIdentifier<ILocaleService>;
+interface ILocaleService {
+    readonly _serviceBrand: undefined;
+    setLocale(languagePackItem: ILanguagePackItem, skipDialog?: boolean): Promise<void>;
+    clearLocalePreference(): Promise<void>;
+}
+
+export { ILocaleService };

package/vscode/src/vs/workbench/services/notification/common/notificationService.js

@@ -0,0 +1,251 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { isNotificationSource, NotificationsFilter, Severity, NoOpNotification, NeverShowAgainScope } from '../../../../platform/notification/common/notification.js';
+import { NotificationsModel, ChoiceAction } from '../../../common/notifications.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Action } from '../../../../base/common/actions.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+var NotificationService_1;
+let NotificationService = class NotificationService extends Disposable {
+    static { NotificationService_1 = this; }
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this.model = this._register(( new NotificationsModel()));
+        this._onDidAddNotification = this._register(( new Emitter()));
+        this.onDidAddNotification = this._onDidAddNotification.event;
+        this._onDidRemoveNotification = this._register(( new Emitter()));
+        this.onDidRemoveNotification = this._onDidRemoveNotification.event;
+        this._onDidChangeFilter = this._register(( new Emitter()));
+        this.onDidChangeFilter = this._onDidChangeFilter.event;
+        this.globalFilterEnabled = this.storageService.getBoolean(NotificationService_1.GLOBAL_FILTER_SETTINGS_KEY, -1 , false);
+        this.mapSourceToFilter = (() => {
+            const map = ( new Map());
+            for (const sourceFilter of this.storageService.getObject(NotificationService_1.PER_SOURCE_FILTER_SETTINGS_KEY, -1 , [])) {
+                map.set(sourceFilter.id, sourceFilter);
+            }
+            return map;
+        })();
+        this.updateFilters();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.model.onDidChangeNotification(e => {
+            switch (e.kind) {
+                case 0 :
+                case 3 : {
+                    const source = typeof e.item.sourceId === 'string' && typeof e.item.source === 'string' ? { id: e.item.sourceId, label: e.item.source } : e.item.source;
+                    const notification = {
+                        message: e.item.message.original,
+                        severity: e.item.severity,
+                        source,
+                        priority: e.item.priority
+                    };
+                    if (e.kind === 0 ) {
+                        if (isNotificationSource(source)) {
+                            if (!( this.mapSourceToFilter.has(source.id))) {
+                                this.setFilter({ ...source, filter: NotificationsFilter.OFF });
+                            }
+                            else {
+                                this.updateSourceFilter(source);
+                            }
+                        }
+                        this._onDidAddNotification.fire(notification);
+                    }
+                    if (e.kind === 3 ) {
+                        this._onDidRemoveNotification.fire(notification);
+                    }
+                    break;
+                }
+            }
+        }));
+    }
+    static { this.GLOBAL_FILTER_SETTINGS_KEY = 'notifications.doNotDisturbMode'; }
+    static { this.PER_SOURCE_FILTER_SETTINGS_KEY = 'notifications.perSourceDoNotDisturbMode'; }
+    setFilter(filter) {
+        if (typeof filter === 'number') {
+            if (this.globalFilterEnabled === (filter === NotificationsFilter.ERROR)) {
+                return;
+            }
+            this.globalFilterEnabled = filter === NotificationsFilter.ERROR;
+            this.storageService.store(NotificationService_1.GLOBAL_FILTER_SETTINGS_KEY, this.globalFilterEnabled, -1 , 1 );
+            this.updateFilters();
+            this._onDidChangeFilter.fire();
+        }
+        else {
+            const existing = this.mapSourceToFilter.get(filter.id);
+            if (existing?.filter === filter.filter && existing.label === filter.label) {
+                return;
+            }
+            this.mapSourceToFilter.set(filter.id, { id: filter.id, label: filter.label, filter: filter.filter });
+            this.saveSourceFilters();
+            this.updateFilters();
+        }
+    }
+    getFilter(source) {
+        if (source) {
+            return this.mapSourceToFilter.get(source.id)?.filter ?? NotificationsFilter.OFF;
+        }
+        return this.globalFilterEnabled ? NotificationsFilter.ERROR : NotificationsFilter.OFF;
+    }
+    updateSourceFilter(source) {
+        const existing = this.mapSourceToFilter.get(source.id);
+        if (!existing) {
+            return;
+        }
+        if (existing.label !== source.label) {
+            this.mapSourceToFilter.set(source.id, { id: source.id, label: source.label, filter: existing.filter });
+            this.saveSourceFilters();
+        }
+    }
+    saveSourceFilters() {
+        this.storageService.store(NotificationService_1.PER_SOURCE_FILTER_SETTINGS_KEY, JSON.stringify([...( this.mapSourceToFilter.values())]), -1 , 1 );
+    }
+    getFilters() {
+        return [...( this.mapSourceToFilter.values())];
+    }
+    updateFilters() {
+        this.model.setFilter({
+            global: this.globalFilterEnabled ? NotificationsFilter.ERROR : NotificationsFilter.OFF,
+            sources: ( new Map(( [...( this.mapSourceToFilter.values())].map(source => [source.id, source.filter]))))
+        });
+    }
+    removeFilter(sourceId) {
+        if (this.mapSourceToFilter.delete(sourceId)) {
+            this.saveSourceFilters();
+            this.updateFilters();
+        }
+    }
+    info(message) {
+        if (Array.isArray(message)) {
+            for (const messageEntry of message) {
+                this.info(messageEntry);
+            }
+            return;
+        }
+        this.model.addNotification({ severity: Severity.Info, message });
+    }
+    warn(message) {
+        if (Array.isArray(message)) {
+            for (const messageEntry of message) {
+                this.warn(messageEntry);
+            }
+            return;
+        }
+        this.model.addNotification({ severity: Severity.Warning, message });
+    }
+    error(message) {
+        if (Array.isArray(message)) {
+            for (const messageEntry of message) {
+                this.error(messageEntry);
+            }
+            return;
+        }
+        this.model.addNotification({ severity: Severity.Error, message });
+    }
+    notify(notification) {
+        const toDispose = ( new DisposableStore());
+        if (notification.neverShowAgain) {
+            const scope = this.toStorageScope(notification.neverShowAgain);
+            const id = notification.neverShowAgain.id;
+            if (this.storageService.getBoolean(id, scope)) {
+                return ( new NoOpNotification());
+            }
+            const neverShowAgainAction = toDispose.add(( new Action('workbench.notification.neverShowAgain', ( localizeWithPath(
+                'vs/workbench/services/notification/common/notificationService',
+                'neverShowAgain',
+                "Don't Show Again"
+            )), undefined, true, async () => {
+                handle.close();
+                this.storageService.store(id, true, scope, 0 );
+            })));
+            const actions = {
+                primary: notification.actions?.primary || [],
+                secondary: notification.actions?.secondary || []
+            };
+            if (!notification.neverShowAgain.isSecondary) {
+                actions.primary = [neverShowAgainAction, ...actions.primary];
+            }
+            else {
+                actions.secondary = [...actions.secondary, neverShowAgainAction];
+            }
+            notification.actions = actions;
+        }
+        const handle = this.model.addNotification(notification);
+        Event.once(handle.onDidClose)(() => toDispose.dispose());
+        return handle;
+    }
+    toStorageScope(options) {
+        switch (options.scope) {
+            case NeverShowAgainScope.APPLICATION:
+                return -1 ;
+            case NeverShowAgainScope.PROFILE:
+                return 0 ;
+            case NeverShowAgainScope.WORKSPACE:
+                return 1 ;
+            default:
+                return -1 ;
+        }
+    }
+    prompt(severity, message, choices, options) {
+        const toDispose = ( new DisposableStore());
+        if (options?.neverShowAgain) {
+            const scope = this.toStorageScope(options.neverShowAgain);
+            const id = options.neverShowAgain.id;
+            if (this.storageService.getBoolean(id, scope)) {
+                return ( new NoOpNotification());
+            }
+            const neverShowAgainChoice = {
+                label: ( localizeWithPath(
+                    'vs/workbench/services/notification/common/notificationService',
+                    'neverShowAgain',
+                    "Don't Show Again"
+                )),
+                run: () => this.storageService.store(id, true, scope, 0 ),
+                isSecondary: options.neverShowAgain.isSecondary
+            };
+            if (!options.neverShowAgain.isSecondary) {
+                choices = [neverShowAgainChoice, ...choices];
+            }
+            else {
+                choices = [...choices, neverShowAgainChoice];
+            }
+        }
+        let choiceClicked = false;
+        const primaryActions = [];
+        const secondaryActions = [];
+        choices.forEach((choice, index) => {
+            const action = ( new ChoiceAction(`workbench.dialog.choice.${index}`, choice));
+            if (!choice.isSecondary) {
+                primaryActions.push(action);
+            }
+            else {
+                secondaryActions.push(action);
+            }
+            toDispose.add(action.onDidRun(() => {
+                choiceClicked = true;
+                if (!choice.keepOpen) {
+                    handle.close();
+                }
+            }));
+            toDispose.add(action);
+        });
+        const actions = { primary: primaryActions, secondary: secondaryActions };
+        const handle = this.notify({ severity, message, actions, sticky: options?.sticky, priority: options?.priority });
+        Event.once(handle.onDidClose)(() => {
+            toDispose.dispose();
+            if (options && typeof options.onCancel === 'function' && !choiceClicked) {
+                options.onCancel();
+            }
+        });
+        return handle;
+    }
+    status(message, options) {
+        return this.model.showStatusMessage(message, options);
+    }
+};
+NotificationService = NotificationService_1 = ( __decorate([
+    ( __param(0, IStorageService))
+], NotificationService));
+export { NotificationService };