src/vs/platform/configuration/common/configurations.ts
348 LOC · 341 covered · 7 uncovered · 87 ranges · 2161 concepts · 25 introducers · 1092 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
configurations.ts ×19
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { IStringDictionary } from '../../../base/common/collections.js';
7
>
import { Emitter, Event } from '../../../base/common/event.js';
8
>
import { Disposable } from '../../../base/common/lifecycle.js';
9
>
import { deepClone, equals } from '../../../base/common/objects.js';
10
>
import { isEmptyObject, isString } from '../../../base/common/types.js';
11
>
import { ConfigurationModel } from './configurationModels.js';
12
>
import { Extensions, IConfigurationRegistry, IRegisteredConfigurationPropertySchema } from './configurationRegistry.js';
13
>
import { ILogService, NullLogService } from '../../log/common/log.js';
14
>
import { IPolicyService, PolicyDefinition, PolicyValue } from '../../policy/common/policy.js';
15
>
import { Registry } from '../../registry/common/platform.js';
16
>
import { getErrorMessage } from '../../../base/common/errors.js';
17
>
import * as json from '../../../base/common/json.js';
18
>
import { PolicyName } from '../../../base/common/policy.js';
19
>
20
>
export class DefaultConfiguration extends Disposable {
21
>
22
>
private readonly _onDidChangeConfiguration = this._register(new Emitter<{ defaults: ConfigurationModel; properties: string[] }>());
23
>
readonly onDidChangeConfiguration = this._onDidChangeConfiguration.event;
24
>
25
>
private _configurationModel: ConfigurationModel;
26
>
get configurationModel(): ConfigurationModel {
27
>
return this._configurationModel;
28
>
}
29
>
30
>
constructor(private readonly logService: ILogService) {
32
>
this._configurationModel = ConfigurationModel.createEmptyModel(logService);
33
>
}
35
>
async initialize(): Promise<ConfigurationModel> {
37
>
this._register(Registry.as<IConfigurationRegistry>(Extensions.Configuration).onDidUpdateConfiguration(({ properties, defaultsOverrides }) => this.onDidUpdateConfiguration(Array.from(properties), defaultsOverrides)));
38
>
return this.configurationModel;
39
>
}
41
>
reload(): ConfigurationModel {
42
this.resetConfigurationModel();
43
return this.configurationModel;
44
}
46
>
protected onDidUpdateConfiguration(properties: string[], defaultsOverrides?: boolean): void {
47
>
this.updateConfigurationModel(properties, Registry.as<IConfigurationRegistry>(Extensions.Configuration).getConfigurationProperties());
configurations.ts ×1
48
>
this._onDidChangeConfiguration.fire({ defaults: this.configurationModel, properties });
49
>
}
51
>
protected getConfigurationDefaultOverrides(): IStringDictionary<unknown> {
53
>
}
55
>
private resetConfigurationModel(): void {
56
>
this._configurationModel = ConfigurationModel.createEmptyModel(this.logService);
configurations.ts ×5
57
>
const properties = Registry.as<IConfigurationRegistry>(Extensions.Configuration).getConfigurationProperties();
58
>
this.updateConfigurationModel(Object.keys(properties), properties);
59
>
}
61
>
private updateConfigurationModel(properties: string[], configurationProperties: IStringDictionary<IRegisteredConfigurationPropertySchema>): void {
62
>
const configurationDefaultsOverrides = this.getConfigurationDefaultOverrides();
configurations.ts ×5
63
>
for (const key of properties) {
65
>
const propertySchema = configurationProperties[key];
66
>
if (defaultOverrideValue !== undefined) {
67
this._configurationModel.setValue(key, defaultOverrideValue);
69
>
this._configurationModel.setValue(key, this.getDefaultValue(key, propertySchema));
70
>
} else {
72
>
}
76
>
protected getDefaultValue(_key: string, propertySchema: IRegisteredConfigurationPropertySchema): unknown {
78
>
}
80
>
}
81
>
82
>
export interface IPolicyConfiguration {
83
>
readonly onDidChangeConfiguration: Event<ConfigurationModel>;
84
>
readonly configurationModel: ConfigurationModel;
85
>
initialize(): Promise<ConfigurationModel>;
86
>
}
87
>
88
>
export class NullPolicyConfiguration implements IPolicyConfiguration {
90
>
readonly configurationModel = ConfigurationModel.createEmptyModel(new NullLogService());
92
>
}
93
>
94
>
type ParsedType = IStringDictionary<unknown> | Array<unknown>;
95
>
96
>
export class PolicyConfiguration extends Disposable implements IPolicyConfiguration {
97
>
98
>
private readonly _onDidChangeConfiguration = this._register(new Emitter<ConfigurationModel>());
99
>
readonly onDidChangeConfiguration = this._onDidChangeConfiguration.event;
100
>
101
>
private readonly configurationRegistry: IConfigurationRegistry;
102
>
103
>
private _configurationModel: ConfigurationModel;
104
>
get configurationModel() { return this._configurationModel; }
105
>
106
>
/** Last definition submitted per policy name; avoids redundant re-registration. */
107
>
private readonly _submittedPolicyDefinitions = new Map<PolicyName, PolicyDefinition>();
108
>
109
>
/** Maps each policy-controlled setting key to its policy name, so removed keys can be re-resolved. */
110
>
private readonly _policyNameByKey = new Map<string, PolicyName>();
111
>
112
>
constructor(
114
>
@IPolicyService private readonly policyService: IPolicyService,
115
>
@ILogService private readonly logService: ILogService
116
>
) {
117
>
super();
118
>
this._configurationModel = ConfigurationModel.createEmptyModel(this.logService);
119
>
this.configurationRegistry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);
120
>
}
122
>
async initialize(): Promise<ConfigurationModel> {
124
>
125
>
this.update(await this.updatePolicyDefinitions(this.defaultConfiguration.configurationModel.keys), false);
126
>
this.update(await this.updatePolicyDefinitions(Object.keys(this.configurationRegistry.getExcludedConfigurationProperties())), false);
127
>
this._register(this.policyService.onDidChange(policyNames => this.onDidChangePolicies(policyNames)));
128
>
this._register(this.defaultConfiguration.onDidChangeConfiguration(async ({ properties }) => this.update(await this.updatePolicyDefinitions(properties), true)));
129
>
return this._configurationModel;
130
>
}
132
>
private toPolicyDefinitionType(configType: unknown, policyName: PolicyName): 'string' | 'number' | 'boolean' | undefined {
133
>
// `configType` may be a single type or a union (e.g. `['array', 'null']`).
configurations.ts ×15
134
>
// Normalize to an array and keep only the types we can represent as policies.
135
>
const configTypes = Array.isArray(configType) ? configType : [configType];
136
>
const supportedTypes = configTypes.filter(type => type === 'string' || type === 'number' || type === 'array' || type === 'object' || type === 'boolean');
137
>
if (supportedTypes.length === 0) {
138
this.logService.warn(`PolicyConfiguration#updatePolicyDefinitions - policy '${policyName}' has unsupported type '${configType}'`);
139
return undefined;
140
}
141
>
return supportedTypes.includes('number') ? 'number' : supportedTypes.includes('boolean') ? 'boolean' : 'string';
configurations.ts ×15
142
>
}
144
>
private async updatePolicyDefinitions(properties: string[]): Promise<string[]> {
145
>
this.logService.trace('PolicyConfiguration#updatePolicyDefinitions', properties);
configurations.ts ×15
146
>
const keys: string[] = [];
147
>
const policyNames = new Set<PolicyName>();
148
>
const configurationProperties = this.configurationRegistry.getConfigurationProperties();
149
>
const excludedConfigurationProperties = this.configurationRegistry.getExcludedConfigurationProperties();
150
>
151
>
for (const key of properties) {
152
>
const config = configurationProperties[key] ?? excludedConfigurationProperties[key];
153
>
if (!config) {
154
>
keys.push(key); // deregistered — update() will clear this key's applied policy value
configurations.ts ×2
155
>
const removedPolicyName = this._policyNameByKey.get(key);
156
>
if (removedPolicyName !== undefined) {
157
>
this._policyNameByKey.delete(key);
158
>
policyNames.add(removedPolicyName);
159
>
}
160
>
continue;
161
>
}
163
>
if (policyName) {
164
>
keys.push(key);
165
>
policyNames.add(policyName);
166
>
this._policyNameByKey.set(key, policyName);
167
>
}
168
>
}
169
>
170
>
const changedDefinitions: IStringDictionary<PolicyDefinition> = {};
171
>
for (const policyName of policyNames) {
172
>
const definition = this.resolvePolicyDefinition(policyName);
173
>
if (definition && !this.isSamePolicyDefinition(this._submittedPolicyDefinitions.get(policyName), definition)) {
174
>
this._submittedPolicyDefinitions.set(policyName, definition);
175
>
changedDefinitions[policyName] = definition;
176
>
}
177
>
}
178
>
179
>
if (!isEmptyObject(changedDefinitions)) {
180
>
await this.policyService.updatePolicyDefinitions(changedDefinitions);
181
>
}
182
>
183
>
return keys;
184
>
}
186
>
private isSamePolicyDefinition(a: PolicyDefinition | undefined, b: PolicyDefinition): boolean {
187
>
return !!a && a.type === b.type && a.value === b.value && a.managedSettings === b.managedSettings && a.restrictedValue === b.restrictedValue;
configurations.ts ×15
188
>
}
190
>
/** Resolve the authoritative definition: owner wins; references provide a bare type fallback. */
191
>
private resolvePolicyDefinition(policyName: PolicyName): PolicyDefinition | undefined {
192
>
const configurationProperties = this.configurationRegistry.getConfigurationProperties();
configurations.ts ×15
193
>
const excludedConfigurationProperties = this.configurationRegistry.getExcludedConfigurationProperties();
194
>
195
>
const ownerKey = this.configurationRegistry.getPolicyConfigurations().get(policyName);
196
>
if (ownerKey !== undefined) {
197
>
const config = configurationProperties[ownerKey] ?? excludedConfigurationProperties[ownerKey];
198
>
if (config?.policy) {
199
>
const type = this.toPolicyDefinitionType(config.type, policyName);
200
>
const { value, managedSettings, restrictedValue } = config.policy;
201
>
return type ? { type, value, managedSettings, restrictedValue } : undefined;
202
>
}
203
>
}
205
>
const referenceKeys = this.configurationRegistry.getPolicyReferenceConfigurations().get(policyName);
207
>
const config = configurationProperties[referenceKey] ?? excludedConfigurationProperties[referenceKey];
configurations.ts ×2
208
>
if (config?.policyReference) {
209
>
const type = this.toPolicyDefinitionType(config.type, policyName);
210
>
return type ? { type } : undefined;
211
>
}
212
>
}
214
>
return undefined;
217
>
private onDidChangePolicies(policyNames: readonly PolicyName[]): void {
218
>
this.logService.trace('PolicyConfiguration#onDidChangePolicies', policyNames);
configurations.ts ×2
219
>
const policyConfigurations = this.configurationRegistry.getPolicyConfigurations();
220
>
const policyReferenceConfigurations = this.configurationRegistry.getPolicyReferenceConfigurations();
221
>
const keys: string[] = [];
222
>
for (const policyName of policyNames) {
223
>
const owner = policyConfigurations.get(policyName);
224
>
if (owner) {
225
>
keys.push(owner);
226
>
}
227
>
const references = policyReferenceConfigurations.get(policyName);
228
>
if (references) {
230
>
}
232
>
this.update(keys, true);
233
>
}
235
>
private update(keys: string[], trigger: boolean): void {
237
>
const configurationProperties = this.configurationRegistry.getConfigurationProperties();
238
>
const excludedConfigurationProperties = this.configurationRegistry.getExcludedConfigurationProperties();
239
>
const changed: [string, unknown][] = [];
240
>
const wasEmpty = this._configurationModel.isEmpty();
241
>
242
>
for (const key of keys) {
243
>
const property = configurationProperties[key] ?? excludedConfigurationProperties[key];
244
>
const policyName = property?.policy?.name ?? property?.policyReference?.name;
245
>
if (policyName) {
246
>
let policyValue: PolicyValue | ParsedType | undefined = this.policyService.getPolicyValue(policyName);
247
>
// `property.type` may be a single type or a union (e.g. `['array', 'null']`).
248
>
// A string policy value carries a JSON payload that must be parsed unless the
249
>
// setting itself is (or can be) a plain string.
250
>
const acceptsStringType = Array.isArray(property.type) ? property.type.includes('string') : property.type === 'string';
251
>
if (isString(policyValue) && !acceptsStringType) {
253
>
policyValue = this.parse(policyValue);
254
>
} catch (e) {
255
>
this.logService.error(`Error parsing policy value ${policyName}:`, getErrorMessage(e));
configurations.ts ×1
256
>
continue;
257
>
}
259
>
if (wasEmpty ? policyValue !== undefined : !equals(this._configurationModel.getValue(key), policyValue)) {
configurations.ts ×15
261
>
}
264
>
changed.push([key, undefined]);
265
>
}
266
>
}
268
>
269
>
if (changed.length) {
271
>
const old = this._configurationModel;
272
>
this._configurationModel = ConfigurationModel.createEmptyModel(this.logService);
273
>
for (const key of old.keys) {
275
>
}
277
>
if (policyValue === undefined) {
280
>
this._configurationModel.setValue(key, policyValue);
281
>
}
282
>
}
283
>
if (trigger) {
285
>
}
289
>
private parse(content: string): ParsedType {
291
>
let currentProperty: string | null = null;
292
>
let currentParent: ParsedType = [];
293
>
const previousParents: Array<ParsedType> = [];
294
>
const parseErrors: json.ParseError[] = [];
295
>
296
>
function onValue(value: unknown) {
297
>
if (Array.isArray(currentParent)) {
298
>
currentParent.push(value);
299
>
} else if (currentProperty !== null) {
302
>
}
304
>
}
306
>
307
>
const visitor: json.JSONVisitor = {
308
>
onObjectBegin: () => {
310
>
onValue(object);
311
>
previousParents.push(currentParent);
312
>
currentParent = object;
313
>
currentProperty = null;
314
>
},
317
>
},
320
>
},
323
>
onValue(array);
324
>
previousParents.push(currentParent);
325
>
currentParent = array;
326
>
currentProperty = null;
327
>
},
330
>
},
332
>
onError: (error: json.ParseErrorCode, offset: number, length: number) => {
334
>
}
336
>
337
>
if (content) {
338
>
json.visit(content, visitor);
339
>
raw = (currentParent[0] as ParsedType | undefined) || raw;
340
>
}
342
>
if (parseErrors.length > 0) {
344
>
}
346
>
return raw;