@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/platform/files/common/io.js

@@ -1,75 +0,0 @@
-import { VSBuffer } from '../../../base/common/buffer.js';
-import { canceled } from '../../../base/common/errors.js';
-import { localizeWithPath } from '../../../nls.js';
-import { ensureFileSystemProviderError, createFileSystemProviderError, FileSystemProviderErrorCode } from './files.js';
-async function readFileIntoStream(provider, resource, target, transformer, options, token) {
-    let error = undefined;
-    try {
-        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
-    }
-    catch (err) {
-        error = err;
-    }
-    finally {
-        if (error && options.errorTransformer) {
-            error = options.errorTransformer(error);
-        }
-        if (typeof error !== 'undefined') {
-            target.error(error);
-        }
-        target.end();
-    }
-}
-async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
-    throwIfCancelled(token);
-    const handle = await provider.open(resource, { create: false });
-    try {
-        throwIfCancelled(token);
-        let totalBytesRead = 0;
-        let bytesRead = 0;
-        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
-        let buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
-        let posInBuffer = 0;
-        do {
-            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
-            posInFile += bytesRead;
-            posInBuffer += bytesRead;
-            totalBytesRead += bytesRead;
-            if (typeof allowedRemainingBytes === 'number') {
-                allowedRemainingBytes -= bytesRead;
-            }
-            if (posInBuffer === buffer.byteLength) {
-                await target.write(transformer(buffer));
-                buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-                posInBuffer = 0;
-            }
-        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
-        if (posInBuffer > 0) {
-            let lastChunkLength = posInBuffer;
-            if (typeof allowedRemainingBytes === 'number') {
-                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
-            }
-            target.write(transformer(buffer.slice(0, lastChunkLength)));
-        }
-    }
-    catch (error) {
-        throw ensureFileSystemProviderError(error);
-    }
-    finally {
-        await provider.close(handle);
-    }
-}
-function throwIfCancelled(token) {
-    if (token.isCancellationRequested) {
-        throw canceled();
-    }
-    return true;
-}
-function throwIfTooLarge(totalBytesRead, options) {
-    if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(localizeWithPath('vs/platform/files/common/io', 'fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
-    }
-    return true;
-}
-export { readFileIntoStream };

package/vscode/src/vs/platform/issue/common/issueReporterUtil.js

@@ -1,15 +0,0 @@
-import { rtrim } from '../../../base/common/strings.js';
-function normalizeGitHubUrl(url) {
-    if (url.endsWith('.git')) {
-        url = url.substr(0, url.length - 4);
-    }
-    url = rtrim(url, '/');
-    if (url.endsWith('/new')) {
-        url = rtrim(url, '/new');
-    }
-    if (url.endsWith('/issues')) {
-        url = rtrim(url, '/issues');
-    }
-    return url;
-}
-export { normalizeGitHubUrl };

package/vscode/src/vs/platform/keyboardLayout/common/keyboardConfig.js

@@ -1,48 +0,0 @@
-import { localizeWithPath } from '../../../nls.js';
-import { OS } from '../../../base/common/platform.js';
-import { Extensions } from '../../configuration/common/configurationRegistry.js';
-import { Registry } from '../../registry/common/platform.js';
-function readKeyboardConfig(configurationService) {
-    const keyboard = configurationService.getValue('keyboard');
-    const dispatch = ((keyboard?.dispatch === 'keyCode' ? 1  : 0) );
-    const mapAltGrToCtrlAlt = Boolean(keyboard?.mapAltGrToCtrlAlt);
-    return { dispatch, mapAltGrToCtrlAlt };
-}
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
-const keyboardConfiguration = {
-    'id': 'keyboard',
-    'order': 15,
-    'type': 'object',
-    'title': ( localizeWithPath(
-        'vs/platform/keyboardLayout/common/keyboardConfig',
-        'keyboardConfigurationTitle',
-        "Keyboard"
-    )),
-    'properties': {
-        'keyboard.dispatch': {
-            scope: 1 ,
-            type: 'string',
-            enum: ['code', 'keyCode'],
-            default: 'code',
-            markdownDescription: ( localizeWithPath(
-                'vs/platform/keyboardLayout/common/keyboardConfig',
-                'dispatch',
-                "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
-            )),
-            included: OS === 2  || OS === 3
-        },
-        'keyboard.mapAltGrToCtrlAlt': {
-            scope: 1 ,
-            type: 'boolean',
-            default: false,
-            markdownDescription: ( localizeWithPath(
-                'vs/platform/keyboardLayout/common/keyboardConfig',
-                'mapAltGrToCtrlAlt',
-                "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."
-            )),
-            included: OS === 1
-        }
-    }
-};
-configurationRegistry.registerConfiguration(keyboardConfiguration);
-export { readKeyboardConfig };

package/vscode/src/vs/platform/keyboardLayout/common/keyboardMapper.js

@@ -1,23 +0,0 @@
-class CachedKeyboardMapper {
-    constructor(actual) {
-        this._actual = actual;
-        this._cache = ( new Map());
-    }
-    dumpDebugInfo() {
-        return this._actual.dumpDebugInfo();
-    }
-    resolveKeyboardEvent(keyboardEvent) {
-        return this._actual.resolveKeyboardEvent(keyboardEvent);
-    }
-    resolveKeybinding(keybinding) {
-        const hashCode = keybinding.getHashCode();
-        const resolved = this._cache.get(hashCode);
-        if (!resolved) {
-            const r = this._actual.resolveKeybinding(keybinding);
-            this._cache.set(hashCode, r);
-            return r;
-        }
-        return resolved;
-    }
-}
-export { CachedKeyboardMapper };

package/vscode/src/vs/platform/lifecycle/common/lifecycle.js

@@ -1,25 +0,0 @@
-import { isThenable, Promises } from '../../../base/common/async.js';
-function handleVetos(vetos, onError) {
-    if (vetos.length === 0) {
-        return Promise.resolve(false);
-    }
-    const promises = [];
-    let lazyValue = false;
-    for (const valueOrPromise of vetos) {
-        if (valueOrPromise === true) {
-            return Promise.resolve(true);
-        }
-        if (isThenable(valueOrPromise)) {
-            promises.push(valueOrPromise.then(value => {
-                if (value) {
-                    lazyValue = true;
-                }
-            }, err => {
-                onError(err);
-                lazyValue = true;
-            }));
-        }
-    }
-    return Promises.settled(promises).then(() => lazyValue);
-}
-export { handleVetos };

package/vscode/src/vs/platform/log/common/fileLog.js

@@ -1,105 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { ThrottledDelayer } from '../../../base/common/async.js';
-import { VSBuffer } from '../../../base/common/buffer.js';
-import { joinPath, dirname, basename } from '../../../base/common/resources.js';
-import { whenProviderRegistered, IFileService, ByteSize } from '../../files/common/files.js';
-import { BufferLogger } from './bufferLog.js';
-import { AbstractLoggerService, AbstractMessageLogger, LogLevel } from './log.js';
-const MAX_FILE_SIZE = 5 * ByteSize.MB;
-let FileLogger = class FileLogger extends AbstractMessageLogger {
-    constructor(resource, level, donotUseFormatters, fileService) {
-        super();
-        this.resource = resource;
-        this.donotUseFormatters = donotUseFormatters;
-        this.fileService = fileService;
-        this.backupIndex = 1;
-        this.buffer = '';
-        this.setLevel(level);
-        this.flushDelayer = ( new ThrottledDelayer(100 ));
-        this.initializePromise = this.initialize();
-    }
-    async flush() {
-        if (!this.buffer) {
-            return;
-        }
-        await this.initializePromise;
-        let content = await this.loadContent();
-        if (content.length > MAX_FILE_SIZE) {
-            await this.fileService.writeFile(this.getBackupResource(), VSBuffer.fromString(content));
-            content = '';
-        }
-        if (this.buffer) {
-            content += this.buffer;
-            this.buffer = '';
-            await this.fileService.writeFile(this.resource, VSBuffer.fromString(content));
-        }
-    }
-    async initialize() {
-        try {
-            await this.fileService.createFile(this.resource);
-        }
-        catch (error) {
-            if (error.fileOperationResult !== 3 ) {
-                throw error;
-            }
-        }
-    }
-    log(level, message) {
-        if (this.donotUseFormatters) {
-            this.buffer += message;
-        }
-        else {
-            this.buffer += `${this.getCurrentTimestamp()} [${this.stringifyLogLevel(level)}] ${message}\n`;
-        }
-        this.flushDelayer.trigger(() => this.flush());
-    }
-    getCurrentTimestamp() {
-        const toTwoDigits = (v) => v < 10 ? `0${v}` : v;
-        const toThreeDigits = (v) => v < 10 ? `00${v}` : v < 100 ? `0${v}` : v;
-        const currentTime = ( new Date());
-        return `${currentTime.getFullYear()}-${toTwoDigits(currentTime.getMonth() + 1)}-${toTwoDigits(currentTime.getDate())} ${toTwoDigits(currentTime.getHours())}:${toTwoDigits(currentTime.getMinutes())}:${toTwoDigits(currentTime.getSeconds())}.${toThreeDigits(currentTime.getMilliseconds())}`;
-    }
-    getBackupResource() {
-        this.backupIndex = this.backupIndex > 5 ? 1 : this.backupIndex;
-        return joinPath(dirname(this.resource), `${basename(this.resource)}_${this.backupIndex++}`);
-    }
-    async loadContent() {
-        try {
-            const content = await this.fileService.readFile(this.resource);
-            return ( content.value.toString());
-        }
-        catch (e) {
-            return '';
-        }
-    }
-    stringifyLogLevel(level) {
-        switch (level) {
-            case LogLevel.Debug: return 'debug';
-            case LogLevel.Error: return 'error';
-            case LogLevel.Info: return 'info';
-            case LogLevel.Trace: return 'trace';
-            case LogLevel.Warning: return 'warning';
-        }
-        return '';
-    }
-};
-FileLogger = ( __decorate([
-    ( __param(3, IFileService))
-], FileLogger));
-class FileLoggerService extends AbstractLoggerService {
-    constructor(logLevel, logsHome, fileService) {
-        super(logLevel, logsHome);
-        this.fileService = fileService;
-    }
-    doCreateLogger(resource, logLevel, options) {
-        const logger = ( new BufferLogger(logLevel));
-        whenProviderRegistered(resource, this.fileService).then(() => logger.logger = ( new FileLogger(
-            resource,
-            logger.getLevel(),
-            !!options?.donotUseFormatters,
-            this.fileService
-        )));
-        return logger;
-    }
-}
-export { FileLoggerService };

package/vscode/src/vs/platform/log/common/logIpc.js

@@ -1,26 +0,0 @@
-import { URI } from '../../../base/common/uri.js';
-import '../../../base/common/event.js';
-import './log.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-class RemoteLoggerChannelClient extends Disposable {
-    constructor(loggerService, channel) {
-        super();
-        channel.call('setLogLevel', [loggerService.getLogLevel()]);
-        this._register(loggerService.onDidChangeLogLevel(arg => channel.call('setLogLevel', [arg])));
-        channel.call('getRegisteredLoggers').then(loggers => {
-            for (const loggerResource of loggers) {
-                loggerService.registerLogger({ ...loggerResource, resource: URI.revive(loggerResource.resource) });
-            }
-        });
-        this._register(channel.listen('onDidChangeVisibility')(([resource, visibility]) => loggerService.setVisibility(URI.revive(resource), visibility)));
-        this._register(channel.listen('onDidChangeLoggers')(({ added, removed }) => {
-            for (const loggerResource of added) {
-                loggerService.registerLogger({ ...loggerResource, resource: URI.revive(loggerResource.resource) });
-            }
-            for (const loggerResource of removed) {
-                loggerService.deregisterLogger(loggerResource.resource);
-            }
-        }));
-    }
-}
-export { RemoteLoggerChannelClient };

package/vscode/src/vs/platform/quickinput/browser/commandsQuickAccess.js

@@ -1,355 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { toErrorMessage } from '../../../base/common/errorMessage.js';
-import { isCancellationError } from '../../../base/common/errors.js';
-import { or, matchesContiguousSubString, matchesWords, matchesPrefix } from '../../../base/common/filters.js';
-import { createSingleCallFunction } from '../../../base/common/functional.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { LRUCache } from '../../../base/common/map.js';
-import { normalizeTfIdfScores, TfIdfCalculator } from '../../../base/common/tfIdf.js';
-import { localizeWithPath } from '../../../nls.js';
-import { ICommandService } from '../../commands/common/commands.js';
-import { IConfigurationService } from '../../configuration/common/configuration.js';
-import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from '../../instantiation/common/instantiation.js';
-import { IKeybindingService } from '../../keybinding/common/keybinding.js';
-import { ILogService } from '../../log/common/log.js';
-import { PickerQuickAccessProvider } from './pickerQuickAccess.js';
-import { WillSaveStateReason, IStorageService } from '../../storage/common/storage.js';
-import { ITelemetryService } from '../../telemetry/common/telemetry.js';
-import { IDialogService } from '../../dialogs/common/dialogs.js';
-var AbstractCommandsQuickAccessProvider_1, CommandsHistory_1;
-let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvider extends PickerQuickAccessProvider {
-    static { AbstractCommandsQuickAccessProvider_1 = this; }
-    static { this.PREFIX = '>'; }
-    static { this.TFIDF_THRESHOLD = 0.5; }
-    static { this.TFIDF_MAX_RESULTS = 5; }
-    static { this.WORD_FILTER = or(matchesPrefix, matchesWords, matchesContiguousSubString); }
-    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
-        super(AbstractCommandsQuickAccessProvider_1.PREFIX, options);
-        this.instantiationService = instantiationService;
-        this.keybindingService = keybindingService;
-        this.commandService = commandService;
-        this.telemetryService = telemetryService;
-        this.dialogService = dialogService;
-        this.commandsHistory = this._register(this.instantiationService.createInstance(CommandsHistory));
-        this.options = options;
-    }
-    async _getPicks(filter, _disposables, token, runOptions) {
-        const allCommandPicks = await this.getCommandPicks(token);
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const runTfidf = createSingleCallFunction(() => {
-            const tfidf = ( new TfIdfCalculator());
-            tfidf.updateDocuments(( allCommandPicks.map(commandPick => ({
-                key: commandPick.commandId,
-                textChunks: [this.getTfIdfChunk(commandPick)]
-            }))));
-            const result = tfidf.calculateScores(filter, token);
-            return normalizeTfIdfScores(result)
-                .filter(score => score.score > AbstractCommandsQuickAccessProvider_1.TFIDF_THRESHOLD)
-                .slice(0, AbstractCommandsQuickAccessProvider_1.TFIDF_MAX_RESULTS);
-        });
-        const filteredCommandPicks = [];
-        for (const commandPick of allCommandPicks) {
-            const labelHighlights = AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.label) ?? undefined;
-            const aliasHighlights = commandPick.commandAlias ? AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.commandAlias) ?? undefined : undefined;
-            if (labelHighlights || aliasHighlights) {
-                commandPick.highlights = {
-                    label: labelHighlights,
-                    detail: this.options.showAlias ? aliasHighlights : undefined
-                };
-                filteredCommandPicks.push(commandPick);
-            }
-            else if (filter === commandPick.commandId) {
-                filteredCommandPicks.push(commandPick);
-            }
-            else if (filter.length >= 3) {
-                const tfidf = runTfidf();
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                const tfidfScore = tfidf.find(score => score.key === commandPick.commandId);
-                if (tfidfScore) {
-                    commandPick.tfIdfScore = tfidfScore.score;
-                    filteredCommandPicks.push(commandPick);
-                }
-            }
-        }
-        const mapLabelToCommand = ( new Map());
-        for (const commandPick of filteredCommandPicks) {
-            const existingCommandForLabel = mapLabelToCommand.get(commandPick.label);
-            if (existingCommandForLabel) {
-                commandPick.description = commandPick.commandId;
-                existingCommandForLabel.description = existingCommandForLabel.commandId;
-            }
-            else {
-                mapLabelToCommand.set(commandPick.label, commandPick);
-            }
-        }
-        filteredCommandPicks.sort((commandPickA, commandPickB) => {
-            if (commandPickA.tfIdfScore && commandPickB.tfIdfScore) {
-                if (commandPickA.tfIdfScore === commandPickB.tfIdfScore) {
-                    return commandPickA.label.localeCompare(commandPickB.label);
-                }
-                return commandPickB.tfIdfScore - commandPickA.tfIdfScore;
-            }
-            else if (commandPickA.tfIdfScore) {
-                return 1;
-            }
-            else if (commandPickB.tfIdfScore) {
-                return -1;
-            }
-            const commandACounter = this.commandsHistory.peek(commandPickA.commandId);
-            const commandBCounter = this.commandsHistory.peek(commandPickB.commandId);
-            if (commandACounter && commandBCounter) {
-                return commandACounter > commandBCounter ? -1 : 1;
-            }
-            if (commandACounter) {
-                return -1;
-            }
-            if (commandBCounter) {
-                return 1;
-            }
-            if (this.options.suggestedCommandIds) {
-                const commandASuggestion = ( this.options.suggestedCommandIds.has(commandPickA.commandId));
-                const commandBSuggestion = ( this.options.suggestedCommandIds.has(commandPickB.commandId));
-                if (commandASuggestion && commandBSuggestion) {
-                    return 0;
-                }
-                if (commandASuggestion) {
-                    return -1;
-                }
-                if (commandBSuggestion) {
-                    return 1;
-                }
-            }
-            return commandPickA.label.localeCompare(commandPickB.label);
-        });
-        const commandPicks = [];
-        let addOtherSeparator = false;
-        let addSuggestedSeparator = true;
-        let addCommonlyUsedSeparator = !!this.options.suggestedCommandIds;
-        for (let i = 0; i < filteredCommandPicks.length; i++) {
-            const commandPick = filteredCommandPicks[i];
-            if (i === 0 && this.commandsHistory.peek(commandPick.commandId)) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'recentlyUsed',
-                    "recently used"
-                )) });
-                addOtherSeparator = true;
-            }
-            if (addSuggestedSeparator && commandPick.tfIdfScore !== undefined) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'suggested',
-                    "similar commands"
-                )) });
-                addSuggestedSeparator = false;
-            }
-            if (addCommonlyUsedSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && this.options.suggestedCommandIds?.has(commandPick.commandId)) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'commonlyUsed',
-                    "commonly used"
-                )) });
-                addOtherSeparator = true;
-                addCommonlyUsedSeparator = false;
-            }
-            if (addOtherSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && !this.options.suggestedCommandIds?.has(commandPick.commandId)) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'morecCommands',
-                    "other commands"
-                )) });
-                addOtherSeparator = false;
-            }
-            commandPicks.push(this.toCommandPick(commandPick, runOptions));
-        }
-        if (!this.hasAdditionalCommandPicks(filter, token)) {
-            return commandPicks;
-        }
-        return {
-            picks: commandPicks,
-            additionalPicks: (async () => {
-                const additionalCommandPicks = await this.getAdditionalCommandPicks(allCommandPicks, filteredCommandPicks, filter, token);
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                const commandPicks = ( additionalCommandPicks.map(commandPick => this.toCommandPick(commandPick, runOptions)));
-                if (addSuggestedSeparator && commandPicks[0]?.type !== 'separator') {
-                    commandPicks.unshift({ type: 'separator', label: ( localizeWithPath(
-                        'vs/platform/quickinput/browser/commandsQuickAccess',
-                        'suggested',
-                        "similar commands"
-                    )) });
-                }
-                return commandPicks;
-            })()
-        };
-    }
-    toCommandPick(commandPick, runOptions) {
-        if (commandPick.type === 'separator') {
-            return commandPick;
-        }
-        const keybinding = this.keybindingService.lookupKeybinding(commandPick.commandId);
-        const ariaLabel = keybinding ?
-            ( localizeWithPath(
-                'vs/platform/quickinput/browser/commandsQuickAccess',
-                'commandPickAriaLabelWithKeybinding',
-                "{0}, {1}",
-                commandPick.label,
-                keybinding.getAriaLabel()
-            )) :
-            commandPick.label;
-        return {
-            ...commandPick,
-            ariaLabel,
-            detail: this.options.showAlias && commandPick.commandAlias !== commandPick.label ? commandPick.commandAlias : undefined,
-            keybinding,
-            accept: async () => {
-                this.commandsHistory.push(commandPick.commandId);
-                this.telemetryService.publicLog2('workbenchActionExecuted', {
-                    id: commandPick.commandId,
-                    from: runOptions?.from ?? 'quick open'
-                });
-                try {
-                    commandPick.args?.length
-                        ? await this.commandService.executeCommand(commandPick.commandId, ...commandPick.args)
-                        : await this.commandService.executeCommand(commandPick.commandId);
-                }
-                catch (error) {
-                    if (!isCancellationError(error)) {
-                        this.dialogService.error(( localizeWithPath(
-                            'vs/platform/quickinput/browser/commandsQuickAccess',
-                            'canNotRun',
-                            "Command '{0}' resulted in an error",
-                            commandPick.label
-                        )), toErrorMessage(error));
-                    }
-                }
-            }
-        };
-    }
-    getTfIdfChunk({ label, commandAlias, commandDescription }) {
-        let chunk = label;
-        if (commandAlias && commandAlias !== label) {
-            chunk += ` - ${commandAlias}`;
-        }
-        if (commandDescription && commandDescription.value !== label) {
-            chunk += ` - ${commandDescription.value === commandDescription.original ? commandDescription.value : `${commandDescription.value} (${commandDescription.original})`}`;
-        }
-        return chunk;
-    }
-};
-AbstractCommandsQuickAccessProvider = AbstractCommandsQuickAccessProvider_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IKeybindingService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IDialogService))
-], AbstractCommandsQuickAccessProvider));
-let CommandsHistory = class CommandsHistory extends Disposable {
-    static { CommandsHistory_1 = this; }
-    static { this.DEFAULT_COMMANDS_HISTORY_LENGTH = 50; }
-    static { this.PREF_KEY_CACHE = 'commandPalette.mru.cache'; }
-    static { this.PREF_KEY_COUNTER = 'commandPalette.mru.counter'; }
-    static { this.counter = 1; }
-    static { this.hasChanges = false; }
-    constructor(storageService, configurationService, logService) {
-        super();
-        this.storageService = storageService;
-        this.configurationService = configurationService;
-        this.logService = logService;
-        this.configuredCommandsHistoryLength = 0;
-        this.updateConfiguration();
-        this.load();
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
-        this._register(this.storageService.onWillSaveState(e => {
-            if (e.reason === WillSaveStateReason.SHUTDOWN) {
-                this.saveState();
-            }
-        }));
-    }
-    updateConfiguration(e) {
-        if (e && !e.affectsConfiguration('workbench.commandPalette.history')) {
-            return;
-        }
-        this.configuredCommandsHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(this.configurationService);
-        if (CommandsHistory_1.cache && CommandsHistory_1.cache.limit !== this.configuredCommandsHistoryLength) {
-            CommandsHistory_1.cache.limit = this.configuredCommandsHistoryLength;
-            CommandsHistory_1.hasChanges = true;
-        }
-    }
-    load() {
-        const raw = this.storageService.get(CommandsHistory_1.PREF_KEY_CACHE, 0 );
-        let serializedCache;
-        if (raw) {
-            try {
-                serializedCache = JSON.parse(raw);
-            }
-            catch (error) {
-                this.logService.error(`[CommandsHistory] invalid data: ${error}`);
-            }
-        }
-        const cache = CommandsHistory_1.cache = ( new LRUCache(this.configuredCommandsHistoryLength, 1));
-        if (serializedCache) {
-            let entries;
-            if (serializedCache.usesLRU) {
-                entries = serializedCache.entries;
-            }
-            else {
-                entries = serializedCache.entries.sort((a, b) => a.value - b.value);
-            }
-            entries.forEach(entry => cache.set(entry.key, entry.value));
-        }
-        CommandsHistory_1.counter = this.storageService.getNumber(CommandsHistory_1.PREF_KEY_COUNTER, 0 , CommandsHistory_1.counter);
-    }
-    push(commandId) {
-        if (!CommandsHistory_1.cache) {
-            return;
-        }
-        CommandsHistory_1.cache.set(commandId, CommandsHistory_1.counter++);
-        CommandsHistory_1.hasChanges = true;
-    }
-    peek(commandId) {
-        return CommandsHistory_1.cache?.peek(commandId);
-    }
-    saveState() {
-        if (!CommandsHistory_1.cache) {
-            return;
-        }
-        if (!CommandsHistory_1.hasChanges) {
-            return;
-        }
-        const serializedCache = { usesLRU: true, entries: [] };
-        CommandsHistory_1.cache.forEach((value, key) => serializedCache.entries.push({ key, value }));
-        this.storageService.store(CommandsHistory_1.PREF_KEY_CACHE, JSON.stringify(serializedCache), 0 , 0 );
-        this.storageService.store(CommandsHistory_1.PREF_KEY_COUNTER, CommandsHistory_1.counter, 0 , 0 );
-        CommandsHistory_1.hasChanges = false;
-    }
-    static getConfiguredCommandHistoryLength(configurationService) {
-        const config = configurationService.getValue();
-        const configuredCommandHistoryLength = config.workbench?.commandPalette?.history;
-        if (typeof configuredCommandHistoryLength === 'number') {
-            return configuredCommandHistoryLength;
-        }
-        return CommandsHistory_1.DEFAULT_COMMANDS_HISTORY_LENGTH;
-    }
-    static clearHistory(configurationService, storageService) {
-        const commandHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(configurationService);
-        CommandsHistory_1.cache = ( new LRUCache(commandHistoryLength));
-        CommandsHistory_1.counter = 1;
-        CommandsHistory_1.hasChanges = true;
-    }
-};
-CommandsHistory = CommandsHistory_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, ILogService))
-], CommandsHistory));
-export { AbstractCommandsQuickAccessProvider, CommandsHistory };