@codingame/monaco-vscode-quickaccess-service-override 1.83.8 → 1.83.10-next.0

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.js

@@ -1 +1 @@
-export { default } from 'vscode/service-override/quickaccess';
+export { default } from './quickaccess.js';

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-quickaccess-service-override",
-  "version": "1.83.8",
+  "version": "1.83.10-next.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.8",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.10-next.0",
     "monaco-editor": "0.44.0"
   }
 }

package/quickaccess.js

@@ -0,0 +1,100 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { StandaloneQuickInputService } from 'monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { QuickInputService } from './vscode/src/vs/workbench/services/quickinput/browser/quickInputService.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { StandaloneCodeEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import { CommandsQuickAccessProvider } from './vscode/src/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js';
+import './vscode/src/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoLineQuickAccess.js';
+import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess';
+import './vscode/src/vs/workbench/browser/actions/quickAccessActions.js';
+import './vscode/src/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution.js';
+
+let isKeybindingConfigurationVisible = () => {
+    return false;
+};
+let shouldUseGlobalPicker = (_activeCodeEditor, _activeCodeEditorStandalone) => {
+    return false;
+};
+const original = CommandsQuickAccessProvider.prototype['getCommandPicks'];
+CommandsQuickAccessProvider.prototype['getCommandPicks'] = async function (token) {
+    let result = await original.call(this, token);
+    if (!isKeybindingConfigurationVisible()) {
+        result = ( result.map(picks => ({
+            ...picks,
+            buttons: picks.buttons?.filter(button => button.tooltip !== 'Configure Keybinding')
+        })));
+    }
+    return result;
+};
+let DelegateQuickInputService = class DelegateQuickInputService {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.workbenchQuickInputService = instantiationService.createInstance(QuickInputService);
+    }
+    get activeService() {
+        const activeCodeEditor = StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor();
+        if (activeCodeEditor == null || shouldUseGlobalPicker(activeCodeEditor, activeCodeEditor instanceof StandaloneCodeEditor)) {
+            return this.workbenchQuickInputService;
+        }
+        this.standaloneQuickInputService ?? (this.standaloneQuickInputService = this.instantiationService.createInstance(StandaloneQuickInputService));
+        return this.standaloneQuickInputService;
+    }
+    get quickAccess() { return this.activeService.quickAccess; }
+    get backButton() { return this.activeService.backButton; }
+    get onShow() { return this.activeService.onShow; }
+    get onHide() { return this.activeService.onHide; }
+    createQuickWidget() {
+        return this.activeService.createQuickWidget();
+    }
+    pick(picks, options = {}, token = CancellationToken.None) {
+        return this.activeService .pick(picks, options, token);
+    }
+    input(options, token) {
+        return this.activeService.input(options, token);
+    }
+    createQuickPick() {
+        return this.activeService.createQuickPick();
+    }
+    createInputBox() {
+        return this.activeService.createInputBox();
+    }
+    focus() {
+        return this.activeService.focus();
+    }
+    toggle() {
+        return this.activeService.toggle();
+    }
+    navigate(next, quickNavigate) {
+        return this.activeService.navigate(next, quickNavigate);
+    }
+    accept() {
+        return this.activeService.accept();
+    }
+    back() {
+        return this.activeService.back();
+    }
+    cancel() {
+        return this.activeService.cancel();
+    }
+};
+DelegateQuickInputService = __decorate([
+    ( __param(0, IInstantiationService))
+], DelegateQuickInputService);
+function getServiceOverride({ isKeybindingConfigurationVisible: _isKeybindingConfigurationVisible, shouldUseGlobalPicker: _shouldUseGlobalPicker } = {}) {
+    if (_isKeybindingConfigurationVisible != null) {
+        isKeybindingConfigurationVisible = _isKeybindingConfigurationVisible;
+    }
+    if (_shouldUseGlobalPicker != null) {
+        shouldUseGlobalPicker = _shouldUseGlobalPicker;
+    }
+    return {
+        [( IQuickInputService.toString())]: new SyncDescriptor(DelegateQuickInputService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/vscode/src/vs/base/common/tfIdf.js

@@ -0,0 +1,138 @@
+function countMapFrom(values) {
+    const map = ( new Map());
+    for (const value of values) {
+        map.set(value, (map.get(value) ?? 0) + 1);
+    }
+    return map;
+}
+class TfIdfCalculator {
+    constructor() {
+        this.chunkCount = 0;
+        this.chunkOccurrences = ( new Map());
+        this.documents = ( new Map());
+    }
+    calculateScores(query, token) {
+        const embedding = this.computeEmbedding(query);
+        const idfCache = ( new Map());
+        const scores = [];
+        for (const [key, doc] of this.documents) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            for (const chunk of doc.chunks) {
+                const score = this.computeSimilarityScore(chunk, embedding, idfCache);
+                if (score > 0) {
+                    scores.push({ key, score });
+                }
+            }
+        }
+        return scores;
+    }
+    static termFrequencies(input) {
+        return countMapFrom(TfIdfCalculator.splitTerms(input));
+    }
+    static *splitTerms(input) {
+        const normalize = (word) => word.toLowerCase();
+        for (const [word] of input.matchAll(/\b\p{Letter}[\p{Letter}\d]{2,}\b/gu)) {
+            yield normalize(word);
+            const camelParts = word.split(/(?<=[a-z])(?=[A-Z])/g);
+            if (camelParts.length > 1) {
+                for (const part of camelParts) {
+                    if (part.length > 2 && /\p{Letter}{3,}/gu.test(part)) {
+                        yield normalize(part);
+                    }
+                }
+            }
+        }
+    }
+    updateDocuments(documents) {
+        for (const { key } of documents) {
+            this.deleteDocument(key);
+        }
+        for (const doc of documents) {
+            const chunks = [];
+            for (const text of doc.textChunks) {
+                const tf = TfIdfCalculator.termFrequencies(text);
+                for (const term of ( tf.keys())) {
+                    this.chunkOccurrences.set(term, (this.chunkOccurrences.get(term) ?? 0) + 1);
+                }
+                chunks.push({ text, tf });
+            }
+            this.chunkCount += chunks.length;
+            this.documents.set(doc.key, { chunks });
+        }
+        return this;
+    }
+    deleteDocument(key) {
+        const doc = this.documents.get(key);
+        if (!doc) {
+            return;
+        }
+        this.documents.delete(key);
+        this.chunkCount -= doc.chunks.length;
+        for (const chunk of doc.chunks) {
+            for (const term of ( chunk.tf.keys())) {
+                const currentOccurrences = this.chunkOccurrences.get(term);
+                if (typeof currentOccurrences === 'number') {
+                    const newOccurrences = currentOccurrences - 1;
+                    if (newOccurrences <= 0) {
+                        this.chunkOccurrences.delete(term);
+                    }
+                    else {
+                        this.chunkOccurrences.set(term, newOccurrences);
+                    }
+                }
+            }
+        }
+    }
+    computeSimilarityScore(chunk, queryEmbedding, idfCache) {
+        let sum = 0;
+        for (const [term, termTfidf] of Object.entries(queryEmbedding)) {
+            const chunkTf = chunk.tf.get(term);
+            if (!chunkTf) {
+                continue;
+            }
+            let chunkIdf = idfCache.get(term);
+            if (typeof chunkIdf !== 'number') {
+                chunkIdf = this.computeIdf(term);
+                idfCache.set(term, chunkIdf);
+            }
+            const chunkTfidf = chunkTf * chunkIdf;
+            sum += chunkTfidf * termTfidf;
+        }
+        return sum;
+    }
+    computeEmbedding(input) {
+        const tf = TfIdfCalculator.termFrequencies(input);
+        return this.computeTfidf(tf);
+    }
+    computeIdf(term) {
+        const chunkOccurrences = this.chunkOccurrences.get(term) ?? 0;
+        return chunkOccurrences > 0
+            ? Math.log((this.chunkCount + 1) / chunkOccurrences)
+            : 0;
+    }
+    computeTfidf(termFrequencies) {
+        const embedding = Object.create(null);
+        for (const [word, occurrences] of termFrequencies) {
+            const idf = this.computeIdf(word);
+            if (idf > 0) {
+                embedding[word] = occurrences * idf;
+            }
+        }
+        return embedding;
+    }
+}
+function normalizeTfIdfScores(scores) {
+    const result = scores.slice(0);
+    result.sort((a, b) => b.score - a.score);
+    const max = result[0]?.score ?? 0;
+    if (max > 0) {
+        for (const score of result) {
+            score.score /= max;
+        }
+    }
+    return result;
+}
+
+export { TfIdfCalculator, normalizeTfIdfScores };

package/vscode/src/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js

@@ -0,0 +1,25 @@
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { AbstractCommandsQuickAccessProvider } from '../../../../platform/quickinput/browser/commandsQuickAccess.js';
+
+class AbstractEditorCommandsQuickAccessProvider extends AbstractCommandsQuickAccessProvider {
+    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
+        super(options, instantiationService, keybindingService, commandService, telemetryService, dialogService);
+    }
+    getCodeEditorCommandPicks() {
+        const activeTextEditorControl = this.activeTextEditorControl;
+        if (!activeTextEditorControl) {
+            return [];
+        }
+        const editorCommandPicks = [];
+        for (const editorAction of activeTextEditorControl.getSupportedActions()) {
+            editorCommandPicks.push({
+                commandId: editorAction.id,
+                commandAlias: editorAction.alias,
+                label: stripIcons(editorAction.label) || editorAction.id,
+            });
+        }
+        return editorCommandPicks;
+    }
+}
+
+export { AbstractEditorCommandsQuickAccessProvider };

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

@@ -0,0 +1,333 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { or, matchesPrefix, matchesWords, matchesContiguousSubString } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
+import { normalizeTfIdfScores, TfIdfCalculator } from '../../../base/common/tfIdf.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { PickerQuickAccessProvider } from 'vscode/vscode/vs/platform/quickinput/browser/pickerQuickAccess';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+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: [commandPick.label + (commandPick.commandAlias ? ` ${commandPick.commandAlias}` : '')]
+            }))));
+            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));
+                    }
+                }
+            }
+        };
+    }
+};
+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; }
+    constructor(storageService, configurationService) {
+        super();
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.configuredCommandsHistoryLength = 0;
+        this.updateConfiguration();
+        this.load();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
+    }
+    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.saveState(this.storageService);
+        }
+    }
+    load() {
+        const raw = this.storageService.get(CommandsHistory_1.PREF_KEY_CACHE, 0 );
+        let serializedCache;
+        if (raw) {
+            try {
+                serializedCache = JSON.parse(raw);
+            }
+            catch (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.saveState(this.storageService);
+    }
+    peek(commandId) {
+        return CommandsHistory_1.cache?.peek(commandId);
+    }
+    static saveState(storageService) {
+        if (!CommandsHistory_1.cache) {
+            return;
+        }
+        const serializedCache = { usesLRU: true, entries: [] };
+        CommandsHistory_1.cache.forEach((value, key) => serializedCache.entries.push({ key, value }));
+        storageService.store(CommandsHistory_1.PREF_KEY_CACHE, JSON.stringify(serializedCache), 0 , 0 );
+        storageService.store(CommandsHistory_1.PREF_KEY_COUNTER, CommandsHistory_1.counter, 0 , 0 );
+    }
+    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.saveState(storageService);
+    }
+};
+CommandsHistory = CommandsHistory_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IConfigurationService))
+], CommandsHistory));
+
+export { AbstractCommandsQuickAccessProvider, CommandsHistory };