@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/contrib/preferences/browser/settingsTreeModels.js

@@ -0,0 +1,759 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { escapeRegExpCharacters, isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { isUndefinedOrNull, withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { knownAcronyms, knownTermMappings, tocData } from './settingsLayout.js';
+import { MODIFIED_SETTING_TAG, REQUIRE_TRUSTED_WORKSPACE_SETTING_TAG, POLICY_SETTING_TAG } from '../common/preferences.js';
+import { SettingValueType } from '../../../services/preferences/common/preferences.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { APPLICATION_SCOPES, FOLDER_SCOPES, WORKSPACE_SCOPES, REMOTE_MACHINE_SCOPES, LOCAL_MACHINE_SCOPES, IWorkbenchConfigurationService } from '../../../services/configuration/common/configuration.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Extensions, EditPresentationTypes } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+class SettingsTreeElement extends Disposable {
+    constructor(_id) {
+        super();
+        this._tabbable = false;
+        this._onDidChangeTabbable = ( new Emitter());
+        this.onDidChangeTabbable = this._onDidChangeTabbable.event;
+        this.id = _id;
+    }
+    get tabbable() {
+        return this._tabbable;
+    }
+    set tabbable(value) {
+        this._tabbable = value;
+        this._onDidChangeTabbable.fire();
+    }
+}
+class SettingsTreeGroupElement extends SettingsTreeElement {
+    get children() {
+        return this._children;
+    }
+    set children(newChildren) {
+        this._children = newChildren;
+        this._childSettingKeys = ( new Set());
+        this._children.forEach(child => {
+            if (child instanceof SettingsTreeSettingElement) {
+                this._childSettingKeys.add(child.setting.key);
+            }
+        });
+    }
+    constructor(_id, count, label, level, isFirstGroup) {
+        super(_id);
+        this._childSettingKeys = ( new Set());
+        this._children = [];
+        this.count = count;
+        this.label = label;
+        this.level = level;
+        this.isFirstGroup = isFirstGroup;
+    }
+    containsSetting(key) {
+        return ( this._childSettingKeys.has(key));
+    }
+}
+class SettingsTreeNewExtensionsElement extends SettingsTreeElement {
+    constructor(_id, extensionIds) {
+        super(_id);
+        this.extensionIds = extensionIds;
+    }
+}
+class SettingsTreeSettingElement extends SettingsTreeElement {
+    constructor(setting, parent, inspectResult, isWorkspaceTrusted, languageService, productService) {
+        super(sanitizeId(parent.id + '_' + setting.key));
+        this.languageService = languageService;
+        this.productService = productService;
+        this._displayCategory = null;
+        this._displayLabel = null;
+        this.isConfigured = false;
+        this.isUntrusted = false;
+        this.hasPolicyValue = false;
+        this.overriddenScopeList = [];
+        this.overriddenDefaultsLanguageList = [];
+        this.languageOverrideValues = ( new Map());
+        this.setting = setting;
+        this.parent = parent;
+        this.update(inspectResult, isWorkspaceTrusted);
+    }
+    get displayCategory() {
+        if (!this._displayCategory) {
+            this.initLabels();
+        }
+        return this._displayCategory;
+    }
+    get displayLabel() {
+        if (!this._displayLabel) {
+            this.initLabels();
+        }
+        return this._displayLabel;
+    }
+    initLabels() {
+        if (this.setting.title) {
+            this._displayLabel = this.setting.title;
+            this._displayCategory = '';
+            return;
+        }
+        const displayKeyFormat = settingKeyToDisplayFormat(this.setting.key, this.parent.id, this.setting.isLanguageTagSetting);
+        this._displayLabel = displayKeyFormat.label;
+        this._displayCategory = displayKeyFormat.category;
+    }
+    update(inspectResult, isWorkspaceTrusted) {
+        let { isConfigured, inspected, targetSelector, inspectedLanguageOverrides, languageSelector } = inspectResult;
+        switch (targetSelector) {
+            case 'workspaceFolderValue':
+            case 'workspaceValue':
+                this.isUntrusted = !!this.setting.restricted && !isWorkspaceTrusted;
+                break;
+        }
+        let displayValue = isConfigured ? inspected[targetSelector] : inspected.defaultValue;
+        const overriddenScopeList = [];
+        const overriddenDefaultsLanguageList = [];
+        if ((languageSelector || targetSelector !== 'workspaceValue') && typeof inspected.workspaceValue !== 'undefined') {
+            overriddenScopeList.push('workspace:');
+        }
+        if ((languageSelector || targetSelector !== 'userRemoteValue') && typeof inspected.userRemoteValue !== 'undefined') {
+            overriddenScopeList.push('remote:');
+        }
+        if ((languageSelector || targetSelector !== 'userLocalValue') && typeof inspected.userLocalValue !== 'undefined') {
+            overriddenScopeList.push('user:');
+        }
+        if (inspected.overrideIdentifiers) {
+            for (const overrideIdentifier of inspected.overrideIdentifiers) {
+                const inspectedOverride = inspectedLanguageOverrides.get(overrideIdentifier);
+                if (inspectedOverride) {
+                    if (this.languageService.isRegisteredLanguageId(overrideIdentifier)) {
+                        if (languageSelector !== overrideIdentifier && typeof inspectedOverride.default?.override !== 'undefined') {
+                            overriddenDefaultsLanguageList.push(overrideIdentifier);
+                        }
+                        if ((languageSelector !== overrideIdentifier || targetSelector !== 'workspaceValue') && typeof inspectedOverride.workspace?.override !== 'undefined') {
+                            overriddenScopeList.push(`workspace:${overrideIdentifier}`);
+                        }
+                        if ((languageSelector !== overrideIdentifier || targetSelector !== 'userRemoteValue') && typeof inspectedOverride.userRemote?.override !== 'undefined') {
+                            overriddenScopeList.push(`remote:${overrideIdentifier}`);
+                        }
+                        if ((languageSelector !== overrideIdentifier || targetSelector !== 'userLocalValue') && typeof inspectedOverride.userLocal?.override !== 'undefined') {
+                            overriddenScopeList.push(`user:${overrideIdentifier}`);
+                        }
+                    }
+                    this.languageOverrideValues.set(overrideIdentifier, inspectedOverride);
+                }
+            }
+        }
+        this.overriddenScopeList = overriddenScopeList;
+        this.overriddenDefaultsLanguageList = overriddenDefaultsLanguageList;
+        this.defaultValueSource = this.setting.nonLanguageSpecificDefaultValueSource;
+        if (inspected.policyValue) {
+            this.hasPolicyValue = true;
+            isConfigured = false;
+            displayValue = inspected.policyValue;
+            this.scopeValue = inspected.policyValue;
+            this.defaultValue = inspected.defaultValue;
+        }
+        else if (languageSelector && ( this.languageOverrideValues.has(languageSelector))) {
+            const overrideValues = this.languageOverrideValues.get(languageSelector);
+            displayValue = (isConfigured ? overrideValues[targetSelector] : overrideValues.defaultValue) ?? displayValue;
+            this.scopeValue = isConfigured && overrideValues[targetSelector];
+            this.defaultValue = overrideValues.defaultValue ?? inspected.defaultValue;
+            const registryValues = ( Registry.as(Extensions.Configuration)).getConfigurationDefaultsOverrides();
+            const overrideValueSource = registryValues.get(`[${languageSelector}]`)?.valuesSources?.get(this.setting.key);
+            if (overrideValueSource) {
+                this.defaultValueSource = overrideValueSource;
+            }
+        }
+        else {
+            this.scopeValue = isConfigured && inspected[targetSelector];
+            this.defaultValue = inspected.defaultValue;
+        }
+        this.value = displayValue;
+        this.isConfigured = isConfigured;
+        if (isConfigured || this.setting.tags || this.tags || this.setting.restricted || this.hasPolicyValue) {
+            this.tags = ( new Set());
+            if (isConfigured) {
+                this.tags.add(MODIFIED_SETTING_TAG);
+            }
+            this.setting.tags?.forEach(tag => this.tags.add(tag));
+            if (this.setting.restricted) {
+                this.tags.add(REQUIRE_TRUSTED_WORKSPACE_SETTING_TAG);
+            }
+            if (this.hasPolicyValue) {
+                this.tags.add(POLICY_SETTING_TAG);
+            }
+        }
+        if (this.setting.description.length > SettingsTreeSettingElement.MAX_DESC_LINES) {
+            const truncatedDescLines = this.setting.description.slice(0, SettingsTreeSettingElement.MAX_DESC_LINES);
+            truncatedDescLines.push('[...]');
+            this.description = truncatedDescLines.join('\n');
+        }
+        else {
+            this.description = this.setting.description.join('\n');
+        }
+        if (isExtensionToggleSetting(this.setting, this.productService)) {
+            this.valueType = SettingValueType.ExtensionToggle;
+        }
+        else if (this.setting.enum && (!this.setting.type || settingTypeEnumRenderable(this.setting.type))) {
+            this.valueType = SettingValueType.Enum;
+        }
+        else if (this.setting.type === 'string') {
+            if (this.setting.editPresentation === EditPresentationTypes.Multiline) {
+                this.valueType = SettingValueType.MultilineString;
+            }
+            else {
+                this.valueType = SettingValueType.String;
+            }
+        }
+        else if (isExcludeSetting(this.setting)) {
+            this.valueType = SettingValueType.Exclude;
+        }
+        else if (isIncludeSetting(this.setting)) {
+            this.valueType = SettingValueType.Include;
+        }
+        else if (this.setting.type === 'integer') {
+            this.valueType = SettingValueType.Integer;
+        }
+        else if (this.setting.type === 'number') {
+            this.valueType = SettingValueType.Number;
+        }
+        else if (this.setting.type === 'boolean') {
+            this.valueType = SettingValueType.Boolean;
+        }
+        else if (this.setting.type === 'array' && this.setting.arrayItemType &&
+            ['string', 'enum', 'number', 'integer'].includes(this.setting.arrayItemType)) {
+            this.valueType = SettingValueType.Array;
+        }
+        else if (Array.isArray(this.setting.type) && this.setting.type.includes(SettingValueType.Null) && this.setting.type.length === 2) {
+            if (this.setting.type.includes(SettingValueType.Integer)) {
+                this.valueType = SettingValueType.NullableInteger;
+            }
+            else if (this.setting.type.includes(SettingValueType.Number)) {
+                this.valueType = SettingValueType.NullableNumber;
+            }
+            else {
+                this.valueType = SettingValueType.Complex;
+            }
+        }
+        else if (isObjectSetting(this.setting)) {
+            if (this.setting.allKeysAreBoolean) {
+                this.valueType = SettingValueType.BooleanObject;
+            }
+            else {
+                this.valueType = SettingValueType.Object;
+            }
+        }
+        else if (this.setting.isLanguageTagSetting) {
+            this.valueType = SettingValueType.LanguageTag;
+        }
+        else {
+            this.valueType = SettingValueType.Complex;
+        }
+    }
+    matchesAllTags(tagFilters) {
+        if (!tagFilters || !tagFilters.size) {
+            return true;
+        }
+        if (this.tags) {
+            let hasFilteredTag = true;
+            tagFilters.forEach(tag => {
+                hasFilteredTag = hasFilteredTag && ( this.tags.has(tag));
+            });
+            return hasFilteredTag;
+        }
+        else {
+            return false;
+        }
+    }
+    matchesScope(scope, isRemote) {
+        const configTarget = URI.isUri(scope) ? 6  : scope;
+        if (!this.setting.scope) {
+            return true;
+        }
+        if (configTarget === 1 ) {
+            return APPLICATION_SCOPES.includes(this.setting.scope);
+        }
+        if (configTarget === 6 ) {
+            return FOLDER_SCOPES.includes(this.setting.scope);
+        }
+        if (configTarget === 5 ) {
+            return WORKSPACE_SCOPES.includes(this.setting.scope);
+        }
+        if (configTarget === 4 ) {
+            return REMOTE_MACHINE_SCOPES.includes(this.setting.scope);
+        }
+        if (configTarget === 3 ) {
+            if (isRemote) {
+                return LOCAL_MACHINE_SCOPES.includes(this.setting.scope);
+            }
+        }
+        return true;
+    }
+    matchesAnyExtension(extensionFilters) {
+        if (!extensionFilters || !extensionFilters.size) {
+            return true;
+        }
+        if (!this.setting.extensionInfo) {
+            return false;
+        }
+        return ( Array.from(extensionFilters).some(
+            extensionId => extensionId.toLowerCase() === this.setting.extensionInfo.id.toLowerCase()
+        ));
+    }
+    matchesAnyFeature(featureFilters) {
+        if (!featureFilters || !featureFilters.size) {
+            return true;
+        }
+        const features = tocData.children.find(child => child.id === 'features');
+        return ( Array.from(featureFilters).some(filter => {
+            if (features && features.children) {
+                const feature = features.children.find(feature => 'features/' + filter === feature.id);
+                if (feature) {
+                    const patterns = feature.settings?.map(setting => createSettingMatchRegExp(setting));
+                    return patterns && !this.setting.extensionInfo && ( patterns.some(pattern => pattern.test(this.setting.key.toLowerCase())));
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }));
+    }
+    matchesAnyId(idFilters) {
+        if (!idFilters || !idFilters.size) {
+            return true;
+        }
+        return ( idFilters.has(this.setting.key));
+    }
+    matchesAllLanguages(languageFilter) {
+        if (!languageFilter) {
+            return true;
+        }
+        if (!this.languageService.isRegisteredLanguageId(languageFilter)) {
+            return false;
+        }
+        if (this.setting.scope === 5 ) {
+            return true;
+        }
+        return false;
+    }
+}
+SettingsTreeSettingElement.MAX_DESC_LINES = 20;
+function createSettingMatchRegExp(pattern) {
+    pattern = escapeRegExpCharacters(pattern)
+        .replace(/\\\*/g, '.*');
+    return ( new RegExp(`^${pattern}$`, 'i'));
+}
+let SettingsTreeModel = class SettingsTreeModel {
+    constructor(_viewState, _isWorkspaceTrusted, _configurationService, _languageService, _userDataProfileService, _productService) {
+        this._viewState = _viewState;
+        this._isWorkspaceTrusted = _isWorkspaceTrusted;
+        this._configurationService = _configurationService;
+        this._languageService = _languageService;
+        this._userDataProfileService = _userDataProfileService;
+        this._productService = _productService;
+        this._treeElementsBySettingName = ( new Map());
+    }
+    get root() {
+        return this._root;
+    }
+    update(newTocRoot = this._tocRoot) {
+        this._treeElementsBySettingName.clear();
+        const newRoot = this.createSettingsTreeGroupElement(newTocRoot);
+        if (newRoot.children[0] instanceof SettingsTreeGroupElement) {
+            newRoot.children[0].isFirstGroup = true;
+        }
+        if (this._root) {
+            this.disposeChildren(this._root.children);
+            this._root.children = newRoot.children;
+        }
+        else {
+            this._root = newRoot;
+        }
+    }
+    updateWorkspaceTrust(workspaceTrusted) {
+        this._isWorkspaceTrusted = workspaceTrusted;
+        this.updateRequireTrustedTargetElements();
+    }
+    disposeChildren(children) {
+        for (const child of children) {
+            this.recursiveDispose(child);
+        }
+    }
+    recursiveDispose(element) {
+        if (element instanceof SettingsTreeGroupElement) {
+            this.disposeChildren(element.children);
+        }
+        element.dispose();
+    }
+    getElementsByName(name) {
+        return withUndefinedAsNull(this._treeElementsBySettingName.get(name));
+    }
+    updateElementsByName(name) {
+        if (!( this._treeElementsBySettingName.has(name))) {
+            return;
+        }
+        this.updateSettings(this._treeElementsBySettingName.get(name));
+    }
+    updateRequireTrustedTargetElements() {
+        this.updateSettings([...( this._treeElementsBySettingName.values())].flat().filter(s => s.isUntrusted));
+    }
+    getTargetToInspect(settingScope) {
+        if (!this._userDataProfileService.currentProfile.isDefault && settingScope === 1 ) {
+            return 1 ;
+        }
+        else {
+            return this._viewState.settingsTarget;
+        }
+    }
+    updateSettings(settings) {
+        for (const element of settings) {
+            const target = this.getTargetToInspect(element.setting.scope);
+            const inspectResult = inspectSetting(element.setting.key, target, this._viewState.languageFilter, this._configurationService);
+            element.update(inspectResult, this._isWorkspaceTrusted);
+        }
+    }
+    createSettingsTreeGroupElement(tocEntry, parent) {
+        const depth = parent ? this.getDepth(parent) + 1 : 0;
+        const element = ( new SettingsTreeGroupElement(tocEntry.id, undefined, tocEntry.label, depth, false));
+        element.parent = parent;
+        const children = [];
+        if (tocEntry.settings) {
+            const settingChildren = ( tocEntry.settings.map(s => this.createSettingsTreeSettingElement(s, element)))
+                .filter(el => el.setting.deprecationMessage ? el.isConfigured : true);
+            children.push(...settingChildren);
+        }
+        if (tocEntry.children) {
+            const groupChildren = ( tocEntry.children.map(child => this.createSettingsTreeGroupElement(child, element)));
+            children.push(...groupChildren);
+        }
+        element.children = children;
+        return element;
+    }
+    getDepth(element) {
+        if (element.parent) {
+            return 1 + this.getDepth(element.parent);
+        }
+        else {
+            return 0;
+        }
+    }
+    createSettingsTreeSettingElement(setting, parent) {
+        const target = this.getTargetToInspect(setting.scope);
+        const inspectResult = inspectSetting(setting.key, target, this._viewState.languageFilter, this._configurationService);
+        const element = ( new SettingsTreeSettingElement(
+            setting,
+            parent,
+            inspectResult,
+            this._isWorkspaceTrusted,
+            this._languageService,
+            this._productService
+        ));
+        const nameElements = this._treeElementsBySettingName.get(setting.key) || [];
+        nameElements.push(element);
+        this._treeElementsBySettingName.set(setting.key, nameElements);
+        return element;
+    }
+};
+SettingsTreeModel = ( __decorate([
+    ( __param(2, IWorkbenchConfigurationService)),
+    ( __param(3, ILanguageService)),
+    ( __param(4, IUserDataProfileService)),
+    ( __param(5, IProductService))
+], SettingsTreeModel));
+function inspectSetting(key, target, languageFilter, configurationService) {
+    const inspectOverrides = URI.isUri(target) ? { resource: target } : undefined;
+    const inspected = configurationService.inspect(key, inspectOverrides);
+    const targetSelector = target === 1  ? 'applicationValue' :
+        target === 3  ? 'userLocalValue' :
+            target === 4  ? 'userRemoteValue' :
+                target === 5  ? 'workspaceValue' :
+                    'workspaceFolderValue';
+    const targetOverrideSelector = target === 1  ? 'application' :
+        target === 3  ? 'userLocal' :
+            target === 4  ? 'userRemote' :
+                target === 5  ? 'workspace' :
+                    'workspaceFolder';
+    let isConfigured = typeof inspected[targetSelector] !== 'undefined';
+    const overrideIdentifiers = inspected.overrideIdentifiers;
+    const inspectedLanguageOverrides = ( new Map());
+    if (languageFilter) {
+        isConfigured = false;
+    }
+    if (overrideIdentifiers) {
+        for (const overrideIdentifier of overrideIdentifiers) {
+            inspectedLanguageOverrides.set(overrideIdentifier, configurationService.inspect(key, { overrideIdentifier }));
+        }
+        if (languageFilter) {
+            if (( inspectedLanguageOverrides.has(languageFilter))) {
+                const overrideValue = inspectedLanguageOverrides.get(languageFilter)[targetOverrideSelector]?.override;
+                if (typeof overrideValue !== 'undefined') {
+                    isConfigured = true;
+                }
+            }
+        }
+    }
+    return { isConfigured, inspected, targetSelector, inspectedLanguageOverrides, languageSelector: languageFilter };
+}
+function sanitizeId(id) {
+    return id.replace(/[\.\/]/, '_');
+}
+function settingKeyToDisplayFormat(key, groupId = '', isLanguageTagSetting = false) {
+    const lastDotIdx = key.lastIndexOf('.');
+    let category = '';
+    if (lastDotIdx >= 0) {
+        category = key.substring(0, lastDotIdx);
+        key = key.substring(lastDotIdx + 1);
+    }
+    groupId = groupId.replace(/\//g, '.');
+    category = trimCategoryForGroup(category, groupId);
+    category = wordifyKey(category);
+    if (isLanguageTagSetting) {
+        key = key.replace(/[\[\]]/g, '');
+        key = '$(bracket) ' + key;
+    }
+    const label = wordifyKey(key);
+    return { category, label };
+}
+function wordifyKey(key) {
+    key = key
+        .replace(/\.([a-z0-9])/g, (_, p1) => ` \u203A ${p1.toUpperCase()}`)
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/^[a-z]/g, match => match.toUpperCase())
+        .replace(/\b\w+\b/g, match => {
+        return ( knownAcronyms.has(match.toLowerCase())) ?
+            match.toUpperCase() :
+            match;
+    });
+    for (const [k, v] of knownTermMappings) {
+        key = key.replace(( new RegExp(`\\b${k}\\b`, 'gi')), v);
+    }
+    return key;
+}
+function trimCategoryForGroup(category, groupId) {
+    const doTrim = (forward) => {
+        if (!/insiders$/i.test(category)) {
+            groupId = groupId.replace(/-?insiders$/i, '');
+        }
+        const parts = ( groupId.split('.')
+            .map(part => {
+            if (part.replace(/-/g, '').toLowerCase() === category.toLowerCase()) {
+                return part.replace(/-/g, '');
+            }
+            else {
+                return part;
+            }
+        }));
+        while (parts.length) {
+            const reg = ( new RegExp(`^${parts.join('\\.')}(\\.|$)`, 'i'));
+            if (reg.test(category)) {
+                return category.replace(reg, '');
+            }
+            if (forward) {
+                parts.pop();
+            }
+            else {
+                parts.shift();
+            }
+        }
+        return null;
+    };
+    let trimmed = doTrim(true);
+    if (trimmed === null) {
+        trimmed = doTrim(false);
+    }
+    if (trimmed === null) {
+        trimmed = category;
+    }
+    return trimmed;
+}
+function isExtensionToggleSetting(setting, productService) {
+    return !!productService.extensionRecommendations &&
+        !!setting.displayExtensionId;
+}
+function isExcludeSetting(setting) {
+    return setting.key === 'files.exclude' ||
+        setting.key === 'search.exclude' ||
+        setting.key === 'workbench.localHistory.exclude' ||
+        setting.key === 'explorer.autoRevealExclude' ||
+        setting.key === 'files.readonlyExclude' ||
+        setting.key === 'files.watcherExclude';
+}
+function isIncludeSetting(setting) {
+    return setting.key === 'files.readonlyInclude';
+}
+function isObjectRenderableSchema({ type }) {
+    return type === 'string' || type === 'boolean' || type === 'integer' || type === 'number';
+}
+function isObjectSetting({ type, objectProperties, objectPatternProperties, objectAdditionalProperties }) {
+    if (type !== 'object') {
+        return false;
+    }
+    if (isUndefinedOrNull(objectProperties) &&
+        isUndefinedOrNull(objectPatternProperties) &&
+        isUndefinedOrNull(objectAdditionalProperties)) {
+        return false;
+    }
+    if ((objectAdditionalProperties === true || objectAdditionalProperties === undefined)
+        && !( Object.keys(objectPatternProperties ?? {})).includes('.*')) {
+        return false;
+    }
+    const schemas = [...( Object.values(objectProperties ?? {})), ...( Object.values(objectPatternProperties ?? {}))];
+    if (objectAdditionalProperties && typeof objectAdditionalProperties === 'object') {
+        schemas.push(objectAdditionalProperties);
+    }
+    const flatSchemas = arrays.flatten(( schemas.map((schema) => {
+        if (Array.isArray(schema.anyOf)) {
+            return schema.anyOf;
+        }
+        return [schema];
+    })));
+    return flatSchemas.every(isObjectRenderableSchema);
+}
+function settingTypeEnumRenderable(_type) {
+    const enumRenderableSettingTypes = ['string', 'boolean', 'null', 'integer', 'number'];
+    const type = Array.isArray(_type) ? _type : [_type];
+    return type.every(type => enumRenderableSettingTypes.includes(type));
+}
+let SearchResultModel = class SearchResultModel extends SettingsTreeModel {
+    constructor(viewState, isWorkspaceTrusted, configurationService, environmentService, languageService, userDataProfileService, productService) {
+        super(viewState, isWorkspaceTrusted, configurationService, languageService, userDataProfileService, productService);
+        this.environmentService = environmentService;
+        this.rawSearchResults = null;
+        this.cachedUniqueSearchResults = null;
+        this.newExtensionSearchResults = null;
+        this.searchResultCount = null;
+        this.id = 'searchResultModel';
+        this.update({ id: 'searchResultModel', label: '' });
+    }
+    getUniqueResults() {
+        if (this.cachedUniqueSearchResults) {
+            return this.cachedUniqueSearchResults;
+        }
+        if (!this.rawSearchResults) {
+            return [];
+        }
+        const localMatchKeys = ( new Set());
+        const localResult = this.rawSearchResults[0 ];
+        localResult?.filterMatches.forEach(m => localMatchKeys.add(m.setting.key));
+        const remoteResult = this.rawSearchResults[1 ];
+        if (remoteResult) {
+            remoteResult.filterMatches = remoteResult.filterMatches.filter(m => !( localMatchKeys.has(m.setting.key)));
+        }
+        if (remoteResult) {
+            this.newExtensionSearchResults = this.rawSearchResults[2 ];
+        }
+        this.cachedUniqueSearchResults = [localResult, remoteResult];
+        return this.cachedUniqueSearchResults;
+    }
+    getRawResults() {
+        return this.rawSearchResults || [];
+    }
+    setResult(order, result) {
+        this.cachedUniqueSearchResults = null;
+        this.newExtensionSearchResults = null;
+        this.rawSearchResults = this.rawSearchResults || [];
+        if (!result) {
+            delete this.rawSearchResults[order];
+            return;
+        }
+        if (result.exactMatch) {
+            this.rawSearchResults = [];
+        }
+        this.rawSearchResults[order] = result;
+        this.updateChildren();
+    }
+    updateChildren() {
+        this.update({
+            id: 'searchResultModel',
+            label: 'searchResultModel',
+            settings: this.getFlatSettings()
+        });
+        const isRemote = !!this.environmentService.remoteAuthority;
+        this.root.children = this.root.children
+            .filter(child => child instanceof SettingsTreeSettingElement && child.matchesAllTags(this._viewState.tagFilters) && child.matchesScope(this._viewState.settingsTarget, isRemote) && child.matchesAnyExtension(this._viewState.extensionFilters) && child.matchesAnyId(this._viewState.idFilters) && child.matchesAnyFeature(this._viewState.featureFilters) && child.matchesAllLanguages(this._viewState.languageFilter));
+        this.searchResultCount = this.root.children.length;
+        if (this.newExtensionSearchResults?.filterMatches.length) {
+            let resultExtensionIds = ( ( this.newExtensionSearchResults.filterMatches
+                .map(result => result.setting))
+                .filter(setting => setting.extensionName && setting.extensionPublisher)
+                .map(setting => `${setting.extensionPublisher}.${setting.extensionName}`));
+            resultExtensionIds = arrays.distinct(resultExtensionIds);
+            if (resultExtensionIds.length) {
+                const newExtElement = ( new SettingsTreeNewExtensionsElement('newExtensions', resultExtensionIds));
+                newExtElement.parent = this._root;
+                this._root.children.push(newExtElement);
+            }
+        }
+    }
+    getUniqueResultsCount() {
+        return this.searchResultCount ?? 0;
+    }
+    getFlatSettings() {
+        const flatSettings = [];
+        arrays.coalesce(this.getUniqueResults())
+            .forEach(r => {
+            flatSettings.push(...( r.filterMatches.map(m => m.setting)));
+        });
+        return flatSettings;
+    }
+};
+SearchResultModel = ( __decorate([
+    ( __param(2, IWorkbenchConfigurationService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, ILanguageService)),
+    ( __param(5, IUserDataProfileService)),
+    ( __param(6, IProductService))
+], SearchResultModel));
+const tagRegex = /(^|\s)@tag:("([^"]*)"|[^"]\S*)/g;
+const extensionRegex = /(^|\s)@ext:("([^"]*)"|[^"]\S*)?/g;
+const featureRegex = /(^|\s)@feature:("([^"]*)"|[^"]\S*)?/g;
+const idRegex = /(^|\s)@id:("([^"]*)"|[^"]\S*)?/g;
+const languageRegex = /(^|\s)@lang:("([^"]*)"|[^"]\S*)?/g;
+function parseQuery(query) {
+    function getTagsForType(query, filterRegex, parsedParts) {
+        return query.replace(filterRegex, (_, __, quotedParsedElement, unquotedParsedElement) => {
+            const parsedElement = unquotedParsedElement || quotedParsedElement;
+            if (parsedElement) {
+                parsedParts.push(...( parsedElement.split(',').map(s => s.trim())).filter(s => !isFalsyOrWhitespace(s)));
+            }
+            return '';
+        });
+    }
+    const tags = [];
+    query = query.replace(tagRegex, (_, __, quotedTag, tag) => {
+        tags.push(tag || quotedTag);
+        return '';
+    });
+    query = query.replace(`@${MODIFIED_SETTING_TAG}`, () => {
+        tags.push(MODIFIED_SETTING_TAG);
+        return '';
+    });
+    query = query.replace(`@${POLICY_SETTING_TAG}`, () => {
+        tags.push(POLICY_SETTING_TAG);
+        return '';
+    });
+    const extensions = [];
+    const features = [];
+    const ids = [];
+    const langs = [];
+    query = getTagsForType(query, extensionRegex, extensions);
+    query = getTagsForType(query, featureRegex, features);
+    query = getTagsForType(query, idRegex, ids);
+    {
+        query = getTagsForType(query, languageRegex, langs);
+    }
+    query = query.trim();
+    return {
+        tags,
+        extensionFilters: extensions,
+        featureFilters: features,
+        idFilters: ids,
+        languageFilter: langs.length ? langs[0] : undefined,
+        query,
+    };
+}
+export { SearchResultModel, SettingsTreeElement, SettingsTreeGroupElement, SettingsTreeModel, SettingsTreeNewExtensionsElement, SettingsTreeSettingElement, inspectSetting, parseQuery, settingKeyToDisplayFormat };