Detect if setting is default or user-defined

[TwitchBronBron]

Is there a way to fetch only the user settings that have been explicitly defined (i.e. exclude any "default" values).

When an extension defines settings in vscode, each setting can define a default value. Then, when settings are retrieved using vscode.workspace.getConfiguration('yourExtension.someSubcategory'), the result is fully populated with the defaults for any settings the user did not explicitly define.

The problem is, there are situations where I want to include the defaults to improve user experience, but I need to know whether the user has explicitly defined the settings or not. Consider the following example:

We add a new feature1Experimental config option. IF this option is defined, use it instead of feature1.

Consider this package.json:

{
    "contributes": {
        "configuration": [
            {
                "yourExtension.feature1": {
                    "type": "array",
                    "default": [
                        1,
                        2,
                        3
                    ],
                    "description": "The baseline feature",
                    "scope": "resource"
                }
            },
            {
                "yourExtension.feature1Experimental": {
                    "type": "array",
                    "default": [
                        4,
                        5,
                        6
                    ],
                    "description": "An experimental feature that overrides `feature1`. Should not be defined at the same time as `yourExtension.feature1`",
                    "scope": "resource"
                }
            }
        ]
    }
}

The problem is, since there are default values, the default settings will be this.

vscode.workspace.getConfiguration('yourExtension') 

{
    "yourExtension": {
         "feature1": [1, 2, 3],
        "feature1Experimental": [3, 4, 5]
     }
}

There's no way to know whether the user specifically defined feature1Experimental. And if I remove the default, then they get no auto-insert help when actually defining the value in their settings.

[bwateratmsft]

The inspect method on WorkspaceConfiguration can do what you want. It lets you see the values at each layer of configuration. For example, if there is a defaultValue but no globalValue, workspaceValue, workspaceFolderValue, etc., then the user has not explicitly set that setting.

EDIT: to correct a mistake that @eamodio pointed out

[eamodio]

You'll need to check more than just globalValue if you really want to ensure that the user hasn't set it. In GitLens, I also check workspaceFolderValue, workspaceValue, but depending on the setting you may also have to check others.

[TwitchBronBron]

This was exactly what I was looking for! I don't really care where the user has defined it, as long as they have defined it somewhere. Here's my solution:

const workspaceConfig = vscode.workspace.getConfiguration('brightscript.debug');

let userWorkspaceSettings = {} as BrightScriptLaunchConfiguration;

//only keep the config values that were explicitly defined in a config file (i.e. exclude default values)
for (const key of Object.keys(workspaceConfig)) {
    const inspection = workspaceConfig.inspect(key);
    //if the value was explicitly defined by the user in one of the various locations, then keep this value
    if (
        inspection.globalValue !== undefined ||
        inspection.workspaceValue !== undefined ||
        inspection.globalLanguageValue !== undefined ||
        inspection.defaultLanguageValue !== undefined ||
        inspection.workspaceFolderValue !== undefined ||
        inspection.workspaceLanguageValue !== undefined ||
        inspection.workspaceFolderLanguageValue !== undefined
    ) {
        userWorkspaceSettings[key] = workspaceConfig[key];
    }
}