@codingame/monaco-vscode-api 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/preferences/browser/preferencesSearch.js

@@ -0,0 +1,461 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { SettingMatchType } from '../../../services/preferences/common/preferences.js';
+import { distinct } from '../../../../base/common/arrays.js';
+import { createRegExp } from '../../../../base/common/strings.js';
+import { matchesWords, matchesContiguousSubString } from '../../../../base/common/filters.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import '../../../../platform/contextkey/common/contextkey.js';
+import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IWorkbenchExtensionEnablementService } from '../../../services/extensionManagement/common/extensionManagement.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { RelatedInformationType, IAiRelatedInformationService } from '../../../services/aiRelatedInformation/common/aiRelatedInformation.js';
+import { TfIdfCalculator } from '../../../../base/common/tfIdf.js';
+import { nullRange } from '../../../services/preferences/common/preferencesModels.js';
+var LocalSearchProvider_1, AiRelatedInformationSearchProvider_1;
+let PreferencesSearchService = class PreferencesSearchService extends Disposable {
+    constructor(instantiationService, configurationService, extensionManagementService, extensionEnablementService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionEnablementService = extensionEnablementService;
+        this._installedExtensions = this.extensionManagementService.getInstalled(1 ).then(exts => {
+            return exts
+                .filter(ext => this.extensionEnablementService.isEnabled(ext))
+                .filter(ext => ext.manifest && ext.manifest.contributes && ext.manifest.contributes.configuration)
+                .filter(ext => !!ext.identifier.uuid);
+        });
+    }
+    get remoteSearchAllowed() {
+        const workbenchSettings = this.configurationService.getValue().workbench.settings;
+        return workbenchSettings.enableNaturalLanguageSearch;
+    }
+    getRemoteSearchProvider(filter, newExtensionsOnly = false) {
+        if (!this.remoteSearchAllowed) {
+            return undefined;
+        }
+        this._remoteSearchProvider ??= this.instantiationService.createInstance(RemoteSearchProvider);
+        this._remoteSearchProvider.setFilter(filter);
+        return this._remoteSearchProvider;
+    }
+    getLocalSearchProvider(filter) {
+        return this.instantiationService.createInstance(LocalSearchProvider, filter);
+    }
+};
+PreferencesSearchService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IExtensionManagementService)),
+    ( __param(3, IWorkbenchExtensionEnablementService))
+], PreferencesSearchService));
+function cleanFilter(filter) {
+    return filter
+        .replace(/[":]/g, ' ')
+        .replace(/  /g, ' ')
+        .trim();
+}
+let LocalSearchProvider = class LocalSearchProvider {
+    static { LocalSearchProvider_1 = this; }
+    static { this.EXACT_MATCH_SCORE = 10000; }
+    static { this.START_SCORE = 1000; }
+    constructor(_filter, configurationService) {
+        this._filter = _filter;
+        this.configurationService = configurationService;
+        this._filter = cleanFilter(this._filter);
+    }
+    searchModel(preferencesModel, token) {
+        if (!this._filter) {
+            return Promise.resolve(null);
+        }
+        let orderedScore = LocalSearchProvider_1.START_SCORE;
+        const settingMatcher = (setting) => {
+            const { matches, matchType } = ( new SettingMatches(
+                this._filter,
+                setting,
+                true,
+                true,
+                (filter, setting) => preferencesModel.findValueMatches(filter, setting),
+                this.configurationService
+            ));
+            const score = this._filter === setting.key ?
+                LocalSearchProvider_1.EXACT_MATCH_SCORE :
+                orderedScore--;
+            return matches.length ?
+                {
+                    matches,
+                    matchType,
+                    score
+                } :
+                null;
+        };
+        const filterMatches = preferencesModel.filterSettings(this._filter, this.getGroupFilter(this._filter), settingMatcher);
+        const exactMatch = filterMatches.find(m => m.score === LocalSearchProvider_1.EXACT_MATCH_SCORE);
+        if (exactMatch) {
+            return Promise.resolve({
+                filterMatches: [exactMatch],
+                exactMatch: true
+            });
+        }
+        else {
+            return Promise.resolve({
+                filterMatches
+            });
+        }
+    }
+    getGroupFilter(filter) {
+        const regex = createRegExp(filter, false, { global: true });
+        return (group) => {
+            return group.id !== 'defaultOverrides' && regex.test(group.title);
+        };
+    }
+};
+LocalSearchProvider = LocalSearchProvider_1 = ( __decorate([
+    ( __param(1, IConfigurationService))
+], LocalSearchProvider));
+let SettingMatches = class SettingMatches {
+    constructor(searchString, setting, requireFullQueryMatch, searchDescription, valuesMatcher, configurationService) {
+        this.searchDescription = searchDescription;
+        this.configurationService = configurationService;
+        this.matchType = SettingMatchType.None;
+        this.matches = distinct(this._findMatchesInSetting(searchString, setting), (match) => `${match.startLineNumber}_${match.startColumn}_${match.endLineNumber}_${match.endColumn}_`);
+    }
+    _findMatchesInSetting(searchString, setting) {
+        const result = this._doFindMatchesInSetting(searchString, setting);
+        return result;
+    }
+    _keyToLabel(settingId) {
+        const label = settingId
+            .replace(/[-._]/g, ' ')
+            .replace(/([a-z]+)([A-Z])/g, '$1 $2')
+            .replace(/([A-Za-z]+)(\d+)/g, '$1 $2')
+            .replace(/(\d+)([A-Za-z]+)/g, '$1 $2')
+            .toLowerCase();
+        return label;
+    }
+    _doFindMatchesInSetting(searchString, setting) {
+        const descriptionMatchingWords = ( new Map());
+        const keyMatchingWords = ( new Map());
+        const valueMatchingWords = ( new Map());
+        const words = ( new Set(searchString.split(' ')));
+        const settingKeyAsWords = this._keyToLabel(setting.key);
+        for (const word of words) {
+            const keyMatches = matchesWords(word, settingKeyAsWords, true);
+            if (keyMatches?.length) {
+                keyMatchingWords.set(word, ( keyMatches.map(match => this.toKeyRange(setting, match))));
+            }
+        }
+        if (keyMatchingWords.size === words.size) {
+            this.matchType |= SettingMatchType.KeyMatch;
+        }
+        else {
+            keyMatchingWords.clear();
+        }
+        const keyIdMatches = matchesContiguousSubString(searchString, setting.key);
+        if (keyIdMatches?.length) {
+            keyMatchingWords.set(setting.key, ( keyIdMatches.map(match => this.toKeyRange(setting, match))));
+            this.matchType |= SettingMatchType.KeyMatch;
+        }
+        if (setting.overrides?.length && (this.matchType & SettingMatchType.KeyMatch)) {
+            this.matchType = SettingMatchType.LanguageTagSettingMatch;
+            const keyRanges = keyMatchingWords.size ?
+                Array.from(( keyMatchingWords.values())).flat() : [];
+            return [...keyRanges];
+        }
+        if (this.searchDescription) {
+            for (const word of words) {
+                for (let lineIndex = 0; lineIndex < setting.description.length; lineIndex++) {
+                    const descriptionMatches = matchesContiguousSubString(word, setting.description[lineIndex]);
+                    if (descriptionMatches?.length) {
+                        descriptionMatchingWords.set(word, ( descriptionMatches.map(match => this.toDescriptionRange(setting, match, lineIndex))));
+                    }
+                }
+            }
+            if (descriptionMatchingWords.size === words.size) {
+                this.matchType |= SettingMatchType.DescriptionOrValueMatch;
+            }
+            else {
+                descriptionMatchingWords.clear();
+            }
+        }
+        if (setting.enum?.length) {
+            for (const option of setting.enum) {
+                if (typeof option !== 'string') {
+                    continue;
+                }
+                valueMatchingWords.clear();
+                for (const word of words) {
+                    const valueMatches = matchesContiguousSubString(word, option);
+                    if (valueMatches?.length) {
+                        valueMatchingWords.set(word, ( valueMatches.map(match => this.toValueRange(setting, match))));
+                    }
+                }
+                if (valueMatchingWords.size === words.size) {
+                    this.matchType |= SettingMatchType.DescriptionOrValueMatch;
+                    break;
+                }
+                else {
+                    valueMatchingWords.clear();
+                }
+            }
+        }
+        else {
+            const settingValue = this.configurationService.getValue(setting.key);
+            if (typeof settingValue === 'string') {
+                for (const word of words) {
+                    const valueMatches = matchesContiguousSubString(word, settingValue);
+                    if (valueMatches?.length) {
+                        valueMatchingWords.set(word, ( valueMatches.map(match => this.toValueRange(setting, match))));
+                    }
+                }
+                if (valueMatchingWords.size === words.size) {
+                    this.matchType |= SettingMatchType.DescriptionOrValueMatch;
+                }
+                else {
+                    valueMatchingWords.clear();
+                }
+            }
+        }
+        const descriptionRanges = descriptionMatchingWords.size ?
+            Array.from(( descriptionMatchingWords.values())).flat() : [];
+        const keyRanges = keyMatchingWords.size ?
+            Array.from(( keyMatchingWords.values())).flat() : [];
+        const valueRanges = valueMatchingWords.size ?
+            Array.from(( valueMatchingWords.values())).flat() : [];
+        return [...descriptionRanges, ...keyRanges, ...valueRanges];
+    }
+    toKeyRange(setting, match) {
+        return {
+            startLineNumber: setting.keyRange.startLineNumber,
+            startColumn: setting.keyRange.startColumn + match.start,
+            endLineNumber: setting.keyRange.startLineNumber,
+            endColumn: setting.keyRange.startColumn + match.end
+        };
+    }
+    toDescriptionRange(setting, match, lineIndex) {
+        const descriptionRange = setting.descriptionRanges[lineIndex];
+        if (!descriptionRange) {
+            return nullRange;
+        }
+        return {
+            startLineNumber: descriptionRange.startLineNumber,
+            startColumn: descriptionRange.startColumn + match.start,
+            endLineNumber: descriptionRange.endLineNumber,
+            endColumn: descriptionRange.startColumn + match.end
+        };
+    }
+    toValueRange(setting, match) {
+        return {
+            startLineNumber: setting.valueRange.startLineNumber,
+            startColumn: setting.valueRange.startColumn + match.start + 1,
+            endLineNumber: setting.valueRange.startLineNumber,
+            endColumn: setting.valueRange.startColumn + match.end + 1
+        };
+    }
+};
+SettingMatches = ( __decorate([
+    ( __param(5, IConfigurationService))
+], SettingMatches));
+class AiRelatedInformationSearchKeysProvider {
+    constructor(aiRelatedInformationService) {
+        this.aiRelatedInformationService = aiRelatedInformationService;
+        this.settingKeys = [];
+        this.settingsRecord = {};
+    }
+    updateModel(preferencesModel) {
+        if (preferencesModel === this.currentPreferencesModel) {
+            return;
+        }
+        this.currentPreferencesModel = preferencesModel;
+        this.refresh();
+    }
+    refresh() {
+        this.settingKeys = [];
+        this.settingsRecord = {};
+        if (!this.currentPreferencesModel ||
+            !this.aiRelatedInformationService.isEnabled()) {
+            return;
+        }
+        for (const group of this.currentPreferencesModel.settingsGroups) {
+            if (group.id === 'mostCommonlyUsed') {
+                continue;
+            }
+            for (const section of group.sections) {
+                for (const setting of section.settings) {
+                    this.settingKeys.push(setting.key);
+                    this.settingsRecord[setting.key] = setting;
+                }
+            }
+        }
+    }
+    getSettingKeys() {
+        return this.settingKeys;
+    }
+    getSettingsRecord() {
+        return this.settingsRecord;
+    }
+}
+let AiRelatedInformationSearchProvider = class AiRelatedInformationSearchProvider {
+    static { AiRelatedInformationSearchProvider_1 = this; }
+    static { this.AI_RELATED_INFORMATION_THRESHOLD = 0.73; }
+    static { this.AI_RELATED_INFORMATION_MAX_PICKS = 5; }
+    constructor(aiRelatedInformationService) {
+        this.aiRelatedInformationService = aiRelatedInformationService;
+        this._filter = '';
+        this._keysProvider = ( new AiRelatedInformationSearchKeysProvider(aiRelatedInformationService));
+    }
+    setFilter(filter) {
+        this._filter = cleanFilter(filter);
+    }
+    async searchModel(preferencesModel, token) {
+        if (!this._filter ||
+            !this.aiRelatedInformationService.isEnabled()) {
+            return null;
+        }
+        this._keysProvider.updateModel(preferencesModel);
+        return {
+            filterMatches: await this.getAiRelatedInformationItems(token)
+        };
+    }
+    async getAiRelatedInformationItems(token) {
+        const settingsRecord = this._keysProvider.getSettingsRecord();
+        const filterMatches = [];
+        const relatedInformation = await this.aiRelatedInformationService.getRelatedInformation(this._filter, [RelatedInformationType.SettingInformation], token ?? CancellationToken.None);
+        relatedInformation.sort((a, b) => b.weight - a.weight);
+        for (const info of relatedInformation) {
+            if (info.weight < AiRelatedInformationSearchProvider_1.AI_RELATED_INFORMATION_THRESHOLD || filterMatches.length === AiRelatedInformationSearchProvider_1.AI_RELATED_INFORMATION_MAX_PICKS) {
+                break;
+            }
+            const pick = info.setting;
+            filterMatches.push({
+                setting: settingsRecord[pick],
+                matches: [settingsRecord[pick].range],
+                matchType: SettingMatchType.RemoteMatch,
+                score: info.weight
+            });
+        }
+        return filterMatches;
+    }
+};
+AiRelatedInformationSearchProvider = AiRelatedInformationSearchProvider_1 = ( __decorate([
+    ( __param(0, IAiRelatedInformationService))
+], AiRelatedInformationSearchProvider));
+class TfIdfSearchProvider {
+    static { this.TF_IDF_PRE_NORMALIZE_THRESHOLD = 50; }
+    static { this.TF_IDF_POST_NORMALIZE_THRESHOLD = 0.7; }
+    static { this.TF_IDF_MAX_PICKS = 5; }
+    constructor() {
+        this._filter = '';
+        this._documents = [];
+        this._settingsRecord = {};
+    }
+    setFilter(filter) {
+        this._filter = cleanFilter(filter);
+    }
+    keyToLabel(settingId) {
+        const label = settingId
+            .replace(/[-._]/g, ' ')
+            .replace(/([a-z]+)([A-Z])/g, '$1 $2')
+            .replace(/([A-Za-z]+)(\d+)/g, '$1 $2')
+            .replace(/(\d+)([A-Za-z]+)/g, '$1 $2')
+            .toLowerCase();
+        return label;
+    }
+    settingItemToEmbeddingString(item) {
+        let result = `Setting Id: ${item.key}\n`;
+        result += `Label: ${this.keyToLabel(item.key)}\n`;
+        result += `Description: ${item.description}\n`;
+        return result;
+    }
+    async searchModel(preferencesModel, token) {
+        if (!this._filter) {
+            return null;
+        }
+        if (this._currentPreferencesModel !== preferencesModel) {
+            this._currentPreferencesModel = preferencesModel;
+            this._documents = [];
+            this._settingsRecord = {};
+            for (const group of preferencesModel.settingsGroups) {
+                if (group.id === 'mostCommonlyUsed') {
+                    continue;
+                }
+                for (const section of group.sections) {
+                    for (const setting of section.settings) {
+                        this._documents.push({
+                            key: setting.key,
+                            textChunks: [this.settingItemToEmbeddingString(setting)]
+                        });
+                        this._settingsRecord[setting.key] = setting;
+                    }
+                }
+            }
+        }
+        return {
+            filterMatches: await this.getTfIdfItems(token)
+        };
+    }
+    async getTfIdfItems(token) {
+        const filterMatches = [];
+        const tfIdfCalculator = ( new TfIdfCalculator());
+        tfIdfCalculator.updateDocuments(this._documents);
+        const tfIdfRankings = tfIdfCalculator.calculateScores(this._filter, token ?? CancellationToken.None);
+        tfIdfRankings.sort((a, b) => b.score - a.score);
+        const maxScore = tfIdfRankings[0].score;
+        if (maxScore < TfIdfSearchProvider.TF_IDF_PRE_NORMALIZE_THRESHOLD) {
+            return [];
+        }
+        for (const info of tfIdfRankings) {
+            if (info.score / maxScore < TfIdfSearchProvider.TF_IDF_POST_NORMALIZE_THRESHOLD || filterMatches.length === TfIdfSearchProvider.TF_IDF_MAX_PICKS) {
+                break;
+            }
+            const pick = info.key;
+            filterMatches.push({
+                setting: this._settingsRecord[pick],
+                matches: [this._settingsRecord[pick].range],
+                matchType: SettingMatchType.RemoteMatch,
+                score: info.score
+            });
+        }
+        return filterMatches;
+    }
+}
+let RemoteSearchProvider = class RemoteSearchProvider {
+    constructor(aiRelatedInformationService) {
+        this.aiRelatedInformationService = aiRelatedInformationService;
+        this.filter = '';
+    }
+    initializeSearchProviders() {
+        if (this.aiRelatedInformationService.isEnabled()) {
+            this.adaSearchProvider ??= ( new AiRelatedInformationSearchProvider(this.aiRelatedInformationService));
+        }
+        else {
+            this.tfIdfSearchProvider ??= ( new TfIdfSearchProvider());
+        }
+    }
+    setFilter(filter) {
+        this.initializeSearchProviders();
+        this.filter = filter;
+        if (this.adaSearchProvider) {
+            this.adaSearchProvider.setFilter(filter);
+        }
+        else {
+            this.tfIdfSearchProvider.setFilter(filter);
+        }
+    }
+    searchModel(preferencesModel, token) {
+        if (!this.filter) {
+            return Promise.resolve(null);
+        }
+        if (this.adaSearchProvider) {
+            return this.adaSearchProvider.searchModel(preferencesModel, token);
+        }
+        else {
+            return this.tfIdfSearchProvider.searchModel(preferencesModel, token);
+        }
+    }
+};
+RemoteSearchProvider = ( __decorate([
+    ( __param(0, IAiRelatedInformationService))
+], RemoteSearchProvider));
+export { LocalSearchProvider, PreferencesSearchService, SettingMatches };

package/vscode/src/vs/workbench/contrib/preferences/browser/preferencesWidgets.js

@@ -19,12 +19,24 @@ import { IContextMenuService, IContextViewService } from '../../../../platform/c
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
 import { ILabelService } from '../../../../platform/label/common/label.js';
-import { asCssVariable, badgeBackground, badgeForeground, contrastBorder } from '../../../../platform/theme/common/colorRegistry.js';
+import { asCssVariable } from '../../../../platform/theme/common/colorUtils.js';
+import { contrastBorder } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import { badgeBackground, badgeForeground } from '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { isWorkspaceFolder, IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
 import { settingsScopeDropDownIcon, settingsEditIcon } from './preferencesIcons.js';
 import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
 import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 let FolderSettingsActionViewItem = class FolderSettingsActionViewItem extends BaseActionViewItem {
     constructor(action, contextService, contextMenuService) {
         super(null, action);
@@ -62,6 +74,7 @@ let FolderSettingsActionViewItem = class FolderSettingsActionViewItem extends Ba
             'aria-haspopup': 'true',
             'tabindex': '0'
         }, this.labelElement, this.detailsElement, this.dropDownElement);
+        this.anchorElementHover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this.anchorElement, ''));
         this._register(addDisposableListener(this.anchorElement, EventType.MOUSE_DOWN, e => EventHelper.stop(e)));
         this._register(addDisposableListener(this.anchorElement, EventType.CLICK, e => this.onClick(e)));
         this._register(addDisposableListener(this.container, EventType.KEY_UP, e => this.onKeyUp(e)));
@@ -110,7 +123,7 @@ let FolderSettingsActionViewItem = class FolderSettingsActionViewItem extends Ba
         const workspace = this.contextService.getWorkspace();
         if (this._folder) {
             this.labelElement.textContent = this._folder.name;
-            this.anchorElement.title = this._folder.name;
+            this.anchorElementHover.update(this._folder.name);
             const detailsText = this.labelWithCount(this._action.label, total);
             this.detailsElement.textContent = detailsText;
             this.dropDownElement.classList.toggle('hide', workspace.folders.length === 1 || !this._action.checked);
@@ -119,7 +132,7 @@ let FolderSettingsActionViewItem = class FolderSettingsActionViewItem extends Ba
             const labelText = this.labelWithCount(this._action.label, total);
             this.labelElement.textContent = labelText;
             this.detailsElement.textContent = '';
-            this.anchorElement.title = this._action.label;
+            this.anchorElementHover.update(this._action.label);
             this.dropDownElement.classList.remove('hide');
         }
         this.anchorElement.classList.toggle('checked', this._action.checked);
@@ -213,7 +226,7 @@ let SettingsTargetsWidget = class SettingsTargetsWidget extends Widget {
                 'settingsSwitcherBarAriaLabel',
                 "Settings Switcher"
             )),
-            actionViewItemProvider: (action) => action.id === 'folderSettings' ? this.folderSettings : undefined
+            actionViewItemProvider: (action, options) => action.id === 'folderSettings' ? this.folderSettings : undefined
         })));
         this.userLocalSettings = ( new Action(
             'userSettings',