@codingame/monaco-vscode-api 15.0.3 → 16.0.1

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverExpression.js

@@ -0,0 +1,149 @@
+
+import { Iterable } from '../../../../base/common/iterator.js';
+import { isWindows, isMacintosh, isLinux } from '../../../../base/common/platform.js';
+
+class ConfigurationResolverExpression {
+    static { this.VARIABLE_LHS = '${'; }
+    constructor(object) {
+        this.locations = ( new Map());
+        if (typeof object === 'string') {
+            this.stringRoot = true;
+            this.root = { value: object };
+        }
+        else {
+            this.stringRoot = false;
+            this.root = structuredClone(object);
+        }
+    }
+    static parse(object) {
+        if (object instanceof ConfigurationResolverExpression) {
+            return object;
+        }
+        const expr = ( new ConfigurationResolverExpression(object));
+        expr.applyPlatformSpecificKeys();
+        expr.parseObject(expr.root);
+        return expr;
+    }
+    applyPlatformSpecificKeys() {
+        const config = this.root;
+        const key = isWindows ? 'windows' : isMacintosh ? 'osx' : isLinux ? 'linux' : undefined;
+        if (key === undefined || !config || typeof config !== 'object' || !config.hasOwnProperty(key)) {
+            return;
+        }
+        ( Object.keys(config[key])).forEach(k => config[k] = config[key][k]);
+        delete config.windows;
+        delete config.osx;
+        delete config.linux;
+    }
+    parseVariable(str, start) {
+        if (str[start] !== '$' || str[start + 1] !== '{') {
+            return undefined;
+        }
+        let end = start + 2;
+        let braceCount = 1;
+        while (end < str.length) {
+            if (str[end] === '{') {
+                braceCount++;
+            }
+            else if (str[end] === '}') {
+                braceCount--;
+                if (braceCount === 0) {
+                    break;
+                }
+            }
+            end++;
+        }
+        if (braceCount !== 0) {
+            return undefined;
+        }
+        const id = str.slice(start, end + 1);
+        const inner = str.substring(start + 2, end);
+        const colonIdx = inner.indexOf(':');
+        if (colonIdx === -1) {
+            return { replacement: { id, name: inner, inner }, end };
+        }
+        return {
+            replacement: {
+                id,
+                inner,
+                name: inner.slice(0, colonIdx),
+                arg: inner.slice(colonIdx + 1)
+            },
+            end
+        };
+    }
+    parseObject(obj) {
+        if (typeof obj !== 'object' || obj === null) {
+            return;
+        }
+        if (Array.isArray(obj)) {
+            for (let i = 0; i < obj.length; i++) {
+                const value = obj[i];
+                if (typeof value === 'string') {
+                    this.parseString(obj, i, value);
+                }
+                else {
+                    this.parseObject(value);
+                }
+            }
+            return;
+        }
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'string') {
+                this.parseString(obj, key, value);
+            }
+            else {
+                this.parseObject(value);
+            }
+        }
+    }
+    parseString(object, propertyName, value) {
+        let pos = 0;
+        while (pos < value.length) {
+            const match = value.indexOf('${', pos);
+            if (match === -1) {
+                break;
+            }
+            const parsed = this.parseVariable(value, match);
+            if (parsed) {
+                const locations = this.locations.get(parsed.replacement.id) || { locations: [], replacement: parsed.replacement };
+                locations.locations.push({ object, propertyName });
+                this.locations.set(parsed.replacement.id, locations);
+                pos = parsed.end + 1;
+            }
+            else {
+                pos = match + 2;
+            }
+        }
+    }
+    unresolved() {
+        return ( Iterable.map(Iterable.filter(( this.locations.values()), l => l.resolved === undefined), l => l.replacement));
+    }
+    resolved() {
+        return ( Iterable.map(Iterable.filter(( this.locations.values()), l => !!l.resolved), l => [l.replacement, l.resolved]));
+    }
+    resolve(replacement, data) {
+        if (typeof data !== 'object') {
+            data = { value: String(data) };
+        }
+        const location = this.locations.get(replacement.id);
+        if (!location) {
+            return;
+        }
+        if (data.value !== undefined) {
+            for (const { object, propertyName } of location.locations || []) {
+                const newValue = object[propertyName].replaceAll(replacement.id, data.value);
+                object[propertyName] = newValue;
+            }
+        }
+        location.resolved = data;
+    }
+    toObject() {
+        if (this.stringRoot) {
+            return this.root.value;
+        }
+        return this.root;
+    }
+}
+
+export { ConfigurationResolverExpression };

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.d.ts

@@ -1,9 +1,9 @@
-import { IStringDictionary } from "../../../../base/common/collections.js";
 import { IProcessEnvironment } from "../../../../base/common/platform.js";
 import { URI as uri } from "../../../../base/common/uri.js";
-import { IConfigurationResolverService } from "./configurationResolver.service.js";
-import { IWorkspaceFolder } from "../../../../platform/workspace/common/workspace.js";
 import { ILabelService } from "../../../../platform/label/common/label.service.js";
+import { IWorkspaceFolderData } from "../../../../platform/workspace/common/workspace.js";
+import { IConfigurationResolverService } from "./configurationResolver.service.js";
+import { ConfigurationResolverExpression } from "./configurationResolverExpression.js";
 interface IVariableResolveContext {
     getFolderUri(folderName: string): uri | undefined;
     getWorkspaceFolderCount(): number;
@@ -19,32 +19,21 @@ interface IVariableResolveContext {
         readonly extensionLocation: uri;
     } | undefined>;
 }
-export declare class AbstractVariableResolverService implements IConfigurationResolverService {
-    static readonly VARIABLE_LHS = "${";
-    static readonly VARIABLE_REGEXP: RegExp;
+export declare abstract class AbstractVariableResolverService implements IConfigurationResolverService {
     readonly _serviceBrand: undefined;
     private _context;
     private _labelService?;
     private _envVariablesPromise?;
     private _userHomePromise?;
     protected _contributedVariables: Map<string, () => Promise<string | undefined>>;
+    readonly resolvableVariables: Set<string>;
     constructor(_context: IVariableResolveContext, _labelService?: ILabelService, _userHomePromise?: Promise<string>, _envVariablesPromise?: Promise<IProcessEnvironment>);
     private prepareEnv;
-    resolveWithEnvironment(environment: IProcessEnvironment, root: IWorkspaceFolder | undefined, value: string): Promise<string>;
-    resolveAsync(root: IWorkspaceFolder | undefined, value: string): Promise<string>;
-    resolveAsync(root: IWorkspaceFolder | undefined, value: string[]): Promise<string[]>;
-    resolveAsync(root: IWorkspaceFolder | undefined, value: IStringDictionary<string>): Promise<IStringDictionary<string>>;
-    private resolveAnyBase;
-    resolveAnyAsync(workspaceFolder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>): Promise<any>;
-    resolveAnyMap(workspaceFolder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>): Promise<{
-        newConfig: any;
-        resolvedVariables: Map<string, string>;
-    }>;
-    resolveWithInteractionReplace(folder: IWorkspaceFolder | undefined, config: any, section?: string, variables?: IStringDictionary<string>): Promise<any>;
-    resolveWithInteraction(folder: IWorkspaceFolder | undefined, config: any, section?: string, variables?: IStringDictionary<string>): Promise<Map<string, string> | undefined>;
+    resolveWithEnvironment(environment: IProcessEnvironment, folder: IWorkspaceFolderData | undefined, value: string): Promise<string>;
+    resolveAsync<T>(folder: IWorkspaceFolderData | undefined, config: T): Promise<T extends ConfigurationResolverExpression<infer R> ? R : T>;
+    resolveWithInteractionReplace(folder: IWorkspaceFolderData | undefined, config: any): Promise<any>;
+    resolveWithInteraction(folder: IWorkspaceFolderData | undefined, config: any): Promise<Map<string, string> | undefined>;
     contributeVariable(variable: string, resolution: () => Promise<string | undefined>): void;
-    private recursiveResolve;
-    private resolveString;
     private fsPath;
     private evaluateSingleVariable;
     private resolveFromMap;

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -1,19 +1,17 @@
 
+import { normalizeDriveLetter } from '../../../../base/common/labels.js';
 import { basename, sep, dirname, extname, relative } from '../../../../base/common/path.js';
+import { isWindows } from '../../../../base/common/platform.js';
 import { cwd } from '../../../../base/common/process.js';
-import { isString, isObject, isUndefinedOrNull } from '../../../../base/common/types.js';
-import { deepClone } from '../../../../base/common/objects.js';
-import { isWindows, isMacintosh, isLinux } from '../../../../base/common/platform.js';
-import { normalizeDriveLetter } from '../../../../base/common/labels.js';
+import { isUndefinedOrNull, isObject, isString } from '../../../../base/common/types.js';
 import { localize } from '../../../../nls.js';
-import { VariableError, VariableKind } from './configurationResolver.js';
-import { replaceAsync } from '../../../../base/common/strings.js';
+import { allVariableKinds, VariableError, VariableKind } from './configurationResolver.js';
+import { ConfigurationResolverExpression } from './configurationResolverExpression.js';
 
 class AbstractVariableResolverService {
-    static { this.VARIABLE_LHS = '${'; }
-    static { this.VARIABLE_REGEXP = /\$\{(.*?)\}/g; }
     constructor(_context, _labelService, _userHomePromise, _envVariablesPromise) {
         this._contributedVariables = ( new Map());
+        this.resolvableVariables = ( new Set(allVariableKinds));
         this._context = _context;
         this._labelService = _labelService;
         this._userHomePromise = _userHomePromise;
@@ -33,48 +31,38 @@ class AbstractVariableResolverService {
         }
         return envVariables;
     }
-    resolveWithEnvironment(environment, root, value) {
-        return this.recursiveResolve({ env: this.prepareEnv(environment), userHome: undefined }, root ? root.uri : undefined, value);
+    async resolveWithEnvironment(environment, folder, value) {
+        const expr = ConfigurationResolverExpression.parse(value);
+        const env = {
+            env: this.prepareEnv(environment),
+            userHome: undefined
+        };
+        for (const replacement of expr.unresolved()) {
+            const resolvedValue = await this.evaluateSingleVariable(env, replacement, folder?.uri);
+            if (resolvedValue !== undefined) {
+                expr.resolve(replacement, resolvedValue);
+            }
+        }
+        return expr.toObject();
     }
-    async resolveAsync(root, value) {
+    async resolveAsync(folder, config) {
+        const expr = ConfigurationResolverExpression.parse(config);
         const environment = {
             env: await this._envVariablesPromise,
             userHome: await this._userHomePromise
         };
-        return this.recursiveResolve(environment, root ? root.uri : undefined, value);
-    }
-    async resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables) {
-        const result = deepClone(config);
-        if (isWindows && result.windows) {
-            ( Object.keys(result.windows)).forEach(key => result[key] = result.windows[key]);
-        }
-        else if (isMacintosh && result.osx) {
-            ( Object.keys(result.osx)).forEach(key => result[key] = result.osx[key]);
-        }
-        else if (isLinux && result.linux) {
-            ( Object.keys(result.linux)).forEach(key => result[key] = result.linux[key]);
+        for (const replacement of expr.unresolved()) {
+            const resolvedValue = await this.evaluateSingleVariable(environment, replacement, folder?.uri);
+            if (resolvedValue !== undefined) {
+                expr.resolve(replacement, resolvedValue);
+            }
         }
-        delete result.windows;
-        delete result.osx;
-        delete result.linux;
-        const environmentPromises = {
-            env: await this._envVariablesPromise,
-            userHome: await this._userHomePromise
-        };
-        return this.recursiveResolve(environmentPromises, workspaceFolder ? workspaceFolder.uri : undefined, result, commandValueMapping, resolvedVariables);
-    }
-    async resolveAnyAsync(workspaceFolder, config, commandValueMapping) {
-        return this.resolveAnyBase(workspaceFolder, config, commandValueMapping);
+        return expr.toObject();
     }
-    async resolveAnyMap(workspaceFolder, config, commandValueMapping) {
-        const resolvedVariables = ( new Map());
-        const newConfig = await this.resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables);
-        return { newConfig, resolvedVariables };
-    }
-    resolveWithInteractionReplace(folder, config, section, variables) {
+    resolveWithInteractionReplace(folder, config) {
         throw ( new Error('resolveWithInteractionReplace not implemented.'));
     }
-    resolveWithInteraction(folder, config, section, variables) {
+    resolveWithInteraction(folder, config) {
         throw ( new Error('resolveWithInteraction not implemented.'));
     }
     contributeVariable(variable, resolution) {
@@ -82,60 +70,25 @@ class AbstractVariableResolverService {
             throw ( new Error('Variable ' + variable + ' is contributed twice.'));
         }
         else {
+            this.resolvableVariables.add(variable);
             this._contributedVariables.set(variable, resolution);
         }
     }
-    async recursiveResolve(environment, folderUri, value, commandValueMapping, resolvedVariables) {
-        if (isString(value)) {
-            return this.resolveString(environment, folderUri, value, commandValueMapping, resolvedVariables);
-        }
-        else if (Array.isArray(value)) {
-            return Promise.all(( value.map(
-                s => this.recursiveResolve(environment, folderUri, s, commandValueMapping, resolvedVariables)
-            )));
-        }
-        else if (isObject(value)) {
-            const result = Object.create(null);
-            const replaced = await Promise.all(( ( Object.keys(value)).map(async (key) => {
-                const replaced = await this.resolveString(environment, folderUri, key, commandValueMapping, resolvedVariables);
-                return [replaced, await this.recursiveResolve(environment, folderUri, value[key], commandValueMapping, resolvedVariables)];
-            })));
-            for (const [key, value] of replaced) {
-                result[key] = value;
-            }
-            return result;
-        }
-        return value;
-    }
-    resolveString(environment, folderUri, value, commandValueMapping, resolvedVariables) {
-        return replaceAsync(value, AbstractVariableResolverService.VARIABLE_REGEXP, async (match, variable) => {
-            if (variable.includes(AbstractVariableResolverService.VARIABLE_LHS)) {
-                return match;
-            }
-            let resolvedValue = await this.evaluateSingleVariable(environment, match, variable, folderUri, commandValueMapping);
-            resolvedVariables?.set(variable, resolvedValue);
-            if ((resolvedValue !== match) && isString(resolvedValue) && resolvedValue.match(AbstractVariableResolverService.VARIABLE_REGEXP)) {
-                resolvedValue = await this.resolveString(environment, folderUri, resolvedValue, commandValueMapping, resolvedVariables);
-            }
-            return resolvedValue;
-        });
-    }
     fsPath(displayUri) {
         return this._labelService ? this._labelService.getUriLabel(displayUri, { noPrefix: true }) : displayUri.fsPath;
     }
-    async evaluateSingleVariable(environment, match, variable, folderUri, commandValueMapping) {
-        let argument;
-        const parts = variable.split(':');
-        if (parts.length > 1) {
-            variable = parts[0];
-            argument = parts[1];
-        }
+    async evaluateSingleVariable(environment, replacement, folderUri, commandValueMapping) {
+        const { name: variable, arg: argument } = replacement;
         const getFilePath = (variableKind) => {
             const filePath = this._context.getFilePath();
             if (filePath) {
                 return normalizeDriveLetter(filePath);
             }
-            throw ( new VariableError(variableKind, ( localize(11663, "Variable {0} can not be resolved. Please open an editor.", match))));
+            throw ( new VariableError(variableKind, ( localize(
+                11994,
+                "Variable {0} can not be resolved. Please open an editor.",
+                replacement.id
+            ))));
         };
         const getFolderPathForFile = (variableKind) => {
             const filePath = getFilePath(variableKind);
@@ -146,9 +99,9 @@ class AbstractVariableResolverService {
                 }
             }
             throw ( new VariableError(variableKind, ( localize(
-                11664,
+                11995,
                 "Variable {0}: can not find workspace folder of '{1}'.",
-                match,
+                replacement.id,
                 basename(filePath)
             ))));
         };
@@ -159,9 +112,9 @@ class AbstractVariableResolverService {
                     return folder;
                 }
                 throw ( new VariableError(variableKind, ( localize(
-                    11665,
+                    11996,
                     "Variable {0} can not be resolved. No such folder '{1}'.",
-                    match,
+                    variableKind,
                     argument
                 ))));
             }
@@ -170,12 +123,16 @@ class AbstractVariableResolverService {
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
                 throw ( new VariableError(variableKind, ( localize(
-                    11666,
+                    11997,
                     "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.",
-                    match
+                    variableKind
                 ))));
             }
-            throw ( new VariableError(variableKind, ( localize(11667, "Variable {0} can not be resolved. Please open a folder.", match))));
+            throw ( new VariableError(variableKind, ( localize(
+                11998,
+                "Variable {0} can not be resolved. Please open a folder.",
+                variableKind
+            ))));
         };
         switch (variable) {
             case 'env':
@@ -189,87 +146,95 @@ class AbstractVariableResolverService {
                     return '';
                 }
                 throw ( new VariableError(VariableKind.Env, ( localize(
-                    11668,
+                    11999,
                     "Variable {0} can not be resolved because no environment variable name is given.",
-                    match
+                    replacement.id
                 ))));
             case 'config':
                 if (argument) {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (isUndefinedOrNull(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            11669,
+                            12000,
                             "Variable {0} can not be resolved because setting '{1}' not found.",
-                            match,
+                            replacement.id,
                             argument
                         ))));
                     }
                     if (isObject(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            11670,
+                            12001,
                             "Variable {0} can not be resolved because '{1}' is a structured value.",
-                            match,
+                            replacement.id,
                             argument
                         ))));
                     }
                     return config;
                 }
                 throw ( new VariableError(VariableKind.Config, ( localize(
-                    11671,
+                    12002,
                     "Variable {0} can not be resolved because no settings name is given.",
-                    match
+                    replacement.id
                 ))));
             case 'command':
-                return this.resolveFromMap(VariableKind.Command, match, argument, commandValueMapping, 'command');
+                return this.resolveFromMap(VariableKind.Command, replacement.id, argument, commandValueMapping, 'command');
             case 'input':
-                return this.resolveFromMap(VariableKind.Input, match, argument, commandValueMapping, 'input');
+                return this.resolveFromMap(VariableKind.Input, replacement.id, argument, commandValueMapping, 'input');
             case 'extensionInstallFolder':
                 if (argument) {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
                         throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                            11672,
+                            12003,
                             "Variable {0} can not be resolved because the extension {1} is not installed.",
-                            match,
+                            replacement.id,
                             argument
                         ))));
                     }
                     return this.fsPath(ext.extensionLocation);
                 }
                 throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                    11673,
+                    12004,
                     "Variable {0} can not be resolved because no extension name is given.",
-                    match
+                    replacement.id
                 ))));
             default: {
                 switch (variable) {
                     case 'workspaceRoot':
-                    case 'workspaceFolder':
-                        return normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.WorkspaceFolder)));
-                    case 'cwd':
-                        return ((folderUri || argument) ? normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.Cwd))) : cwd());
+                    case 'workspaceFolder': {
+                        const uri = getFolderUri(VariableKind.WorkspaceFolder);
+                        return uri ? normalizeDriveLetter(this.fsPath(uri)) : undefined;
+                    }
+                    case 'cwd': {
+                        if (!folderUri && !argument) {
+                            return cwd();
+                        }
+                        const uri = getFolderUri(VariableKind.Cwd);
+                        return uri ? normalizeDriveLetter(this.fsPath(uri)) : undefined;
+                    }
                     case 'workspaceRootFolderName':
-                    case 'workspaceFolderBasename':
-                        return normalizeDriveLetter(basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
-                    case 'userHome': {
+                    case 'workspaceFolderBasename': {
+                        const uri = getFolderUri(VariableKind.WorkspaceFolderBasename);
+                        return uri ? normalizeDriveLetter(basename(this.fsPath(uri))) : undefined;
+                    }
+                    case 'userHome':
                         if (environment.userHome) {
                             return environment.userHome;
                         }
                         throw ( new VariableError(VariableKind.UserHome, ( localize(
-                            11674,
+                            12005,
                             "Variable {0} can not be resolved. UserHome path is not defined",
-                            match
+                            replacement.id
                         ))));
-                    }
                     case 'lineNumber': {
                         const lineNumber = this._context.getLineNumber();
                         if (lineNumber) {
                             return lineNumber;
                         }
                         throw ( new VariableError(VariableKind.LineNumber, ( localize(
-                            11675,
+                            12006,
                             "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.",
-                            match
+                            replacement.id
                         ))));
                     }
                     case 'columnNumber': {
@@ -278,9 +243,9 @@ class AbstractVariableResolverService {
                             return columnNumber;
                         }
                         throw ( new Error(( localize(
-                            11676,
+                            12007,
                             "Variable {0} can not be resolved. Make sure to have a column selected in the active editor.",
-                            match
+                            replacement.id
                         ))));
                     }
                     case 'selectedText': {
@@ -289,9 +254,9 @@ class AbstractVariableResolverService {
                             return selectedText;
                         }
                         throw ( new VariableError(VariableKind.SelectedText, ( localize(
-                            11677,
+                            12008,
                             "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.",
-                            match
+                            replacement.id
                         ))));
                     }
                     case 'file':
@@ -330,26 +295,26 @@ class AbstractVariableResolverService {
                         if (ep) {
                             return ep;
                         }
-                        return match;
+                        return replacement.id;
                     }
                     case 'execInstallFolder': {
                         const ar = this._context.getAppRoot();
                         if (ar) {
                             return ar;
                         }
-                        return match;
+                        return replacement.id;
                     }
                     case 'pathSeparator':
                     case '/':
                         return sep;
-                    default:
+                    default: {
                         try {
-                            const key = argument ? `${variable}:${argument}` : variable;
-                            return this.resolveFromMap(VariableKind.Unknown, match, key, commandValueMapping, undefined);
+                            return this.resolveFromMap(VariableKind.Unknown, replacement.id, argument, commandValueMapping, undefined);
                         }
-                        catch (error) {
-                            return match;
+                        catch {
+                            return replacement.id;
                         }
+                    }
                 }
             }
         }
@@ -361,7 +326,7 @@ class AbstractVariableResolverService {
                 return v;
             }
             throw ( new VariableError(variableKind, ( localize(
-                11678,
+                12009,
                 "Variable {0} can not be resolved because the command has no value.",
                 match
             ))));

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.js

@@ -16,7 +16,7 @@ const editorAssociationsConfigurationNode = {
         'workbench.editorAssociations': {
             type: 'object',
             markdownDescription: ( localize(
-                11731,
+                12062,
                 "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
             )),
             additionalProperties: {

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.d.ts

@@ -46,14 +46,15 @@ export declare enum EnablementState {
     DisabledByExtensionKind = 1,
     DisabledByEnvironment = 2,
     EnabledByEnvironment = 3,
-    DisabledByVirtualWorkspace = 4,
-    DisabledByInvalidExtension = 5,
-    DisabledByAllowlist = 6,
-    DisabledByExtensionDependency = 7,
-    DisabledGlobally = 8,
-    DisabledWorkspace = 9,
-    EnabledGlobally = 10,
-    EnabledWorkspace = 11
+    DisabledByMalicious = 4,
+    DisabledByVirtualWorkspace = 5,
+    DisabledByInvalidExtension = 6,
+    DisabledByAllowlist = 7,
+    DisabledByExtensionDependency = 8,
+    DisabledGlobally = 9,
+    DisabledWorkspace = 10,
+    EnabledGlobally = 11,
+    EnabledWorkspace = 12
 }
 export interface IScannedExtension extends IExtension {
     readonly metadata?: Metadata;

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.js

@@ -14,14 +14,15 @@ var EnablementState;
     EnablementState[EnablementState["DisabledByExtensionKind"] = 1] = "DisabledByExtensionKind";
     EnablementState[EnablementState["DisabledByEnvironment"] = 2] = "DisabledByEnvironment";
     EnablementState[EnablementState["EnabledByEnvironment"] = 3] = "EnabledByEnvironment";
-    EnablementState[EnablementState["DisabledByVirtualWorkspace"] = 4] = "DisabledByVirtualWorkspace";
-    EnablementState[EnablementState["DisabledByInvalidExtension"] = 5] = "DisabledByInvalidExtension";
-    EnablementState[EnablementState["DisabledByAllowlist"] = 6] = "DisabledByAllowlist";
-    EnablementState[EnablementState["DisabledByExtensionDependency"] = 7] = "DisabledByExtensionDependency";
-    EnablementState[EnablementState["DisabledGlobally"] = 8] = "DisabledGlobally";
-    EnablementState[EnablementState["DisabledWorkspace"] = 9] = "DisabledWorkspace";
-    EnablementState[EnablementState["EnabledGlobally"] = 10] = "EnabledGlobally";
-    EnablementState[EnablementState["EnabledWorkspace"] = 11] = "EnabledWorkspace";
+    EnablementState[EnablementState["DisabledByMalicious"] = 4] = "DisabledByMalicious";
+    EnablementState[EnablementState["DisabledByVirtualWorkspace"] = 5] = "DisabledByVirtualWorkspace";
+    EnablementState[EnablementState["DisabledByInvalidExtension"] = 6] = "DisabledByInvalidExtension";
+    EnablementState[EnablementState["DisabledByAllowlist"] = 7] = "DisabledByAllowlist";
+    EnablementState[EnablementState["DisabledByExtensionDependency"] = 8] = "DisabledByExtensionDependency";
+    EnablementState[EnablementState["DisabledGlobally"] = 9] = "DisabledGlobally";
+    EnablementState[EnablementState["DisabledWorkspace"] = 10] = "DisabledWorkspace";
+    EnablementState[EnablementState["EnabledGlobally"] = 11] = "EnabledGlobally";
+    EnablementState[EnablementState["EnabledWorkspace"] = 12] = "EnabledWorkspace";
 })(EnablementState || (EnablementState = {}));
 
 export { EnablementState, ExtensionInstallLocation, getDefaultIconPath };