src/vs/platform/configuration/common/configurationModels.ts
1298 LOC · 1198 covered · 100 uncovered · 398 ranges · 2492 concepts · 147 introducers · 1276 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
>
/*---------------------------------------------------------------------------------------------
configurationModels.ts ×92
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 * as arrays from '../../../base/common/arrays.js';
7
>
import { IStringDictionary } from '../../../base/common/collections.js';
8
>
import { Emitter, Event } from '../../../base/common/event.js';
9
>
import * as json from '../../../base/common/json.js';
10
>
import { Disposable } from '../../../base/common/lifecycle.js';
11
>
import { getOrSet, ResourceMap } from '../../../base/common/map.js';
12
>
import * as objects from '../../../base/common/objects.js';
13
>
import { IExtUri } from '../../../base/common/resources.js';
14
>
import * as types from '../../../base/common/types.js';
15
>
import { URI, UriComponents } from '../../../base/common/uri.js';
16
>
import { addToValueTree, ConfigurationTarget, getConfigurationValue, IConfigurationChange, IConfigurationChangeEvent, IConfigurationCompareResult, IConfigurationData, IConfigurationModel, IConfigurationOverrides, IConfigurationUpdateOverrides, IConfigurationValue, IInspectValue, IOverrides, removeFromValueTree, toValuesTree } from './configuration.js';
17
>
import { ConfigurationScope, Extensions, IConfigurationPropertySchema, IConfigurationRegistry, overrideIdentifiersFromKey, OVERRIDE_PROPERTY_REGEX, IRegisteredConfigurationPropertySchema } from './configurationRegistry.js';
18
>
import { FileOperation, IFileService } from '../../files/common/files.js';
19
>
import { ILogService } from '../../log/common/log.js';
20
>
import { Registry } from '../../registry/common/platform.js';
21
>
import { Workspace } from '../../workspace/common/workspace.js';
22
>
24
>
return Object.isFrozen(data) ? data : objects.deepFreeze(data);
25
>
}
27
>
type InspectValue<V> = IInspectValue<V> & { merged?: V };
28
>
29
>
export class ConfigurationModel implements IConfigurationModel {
30
>
31
>
static createEmptyModel(logService: ILogService): ConfigurationModel {
32
>
return new ConfigurationModel({}, [], [], undefined, logService);
33
>
}
34
>
35
>
private readonly overrideConfigurations = new Map<string, ConfigurationModel>();
36
>
37
>
constructor(
39
>
private readonly _keys: string[],
40
>
private readonly _overrides: IOverrides[],
41
>
private readonly _raw: IStringDictionary<unknown> | ReadonlyArray<IStringDictionary<unknown> | ConfigurationModel> | undefined,
42
>
private readonly logService: ILogService
43
>
) {
44
>
}
46
>
private _rawConfiguration: ConfigurationModel | undefined;
47
>
get rawConfiguration(): ConfigurationModel {
49
>
if (this._raw) {
50
>
const rawConfigurationModels = (Array.isArray(this._raw) ? this._raw : [this._raw]).map(raw => {
configurationModels.ts ×2
51
>
if (raw instanceof ConfigurationModel) {
53
>
}
55
>
parser.parseRaw(raw);
56
>
return parser.configurationModel;
57
>
});
58
>
this._rawConfiguration = rawConfigurationModels.reduce((previous, current) => current === previous ? current : previous.merge(current), rawConfigurationModels[0]);
61
>
this._rawConfiguration = this;
62
>
}
64
>
return this._rawConfiguration;
65
>
}
67
>
get contents(): IStringDictionary<unknown> {
69
>
}
71
>
get overrides(): IOverrides[] {
73
>
}
75
>
get keys(): string[] {
77
>
}
79
>
get raw(): IStringDictionary<unknown> | IStringDictionary<unknown>[] | undefined {
82
>
}
83
>
if (Array.isArray(this._raw) && this._raw.every(raw => raw instanceof ConfigurationModel)) {
configurationModels.ts ×3
84
return undefined;
85
}
86
>
return this._raw as IStringDictionary<unknown> | IStringDictionary<unknown>[];
configurationModels.ts ×1
89
>
isEmpty(): boolean {
90
>
return this._keys.length === 0 && Object.keys(this._contents).length === 0 && this._overrides.length === 0;
configurationModels.ts ×1
91
>
}
93
>
getValue<V>(section: string | undefined): V | undefined {
94
>
return section ? getConfigurationValue<V>(this.contents, section) : this.contents as V;
configurationModels.ts ×1
95
>
}
97
>
inspect<V>(section: string | undefined, overrideIdentifier?: string | null): InspectValue<V> {
99
>
return {
100
>
get value() {
102
>
},
104
>
return overrideIdentifier ? freeze(that.rawConfiguration.getOverrideValue<V>(section, overrideIdentifier)) : undefined;
configurationModels.ts ×2
105
>
},
107
>
return freeze(overrideIdentifier ? that.rawConfiguration.override(overrideIdentifier).getValue<V>(section) : that.rawConfiguration.getValue<V>(section));
configurationModels.ts ×1
108
>
},
110
>
const overrides: { readonly identifiers: string[]; readonly value: V }[] = [];
configurationModels.ts ×2
111
>
for (const { contents, identifiers, keys } of that.rawConfiguration.overrides) {
112
>
const value = new ConfigurationModel(contents, keys, [], undefined, that.logService).getValue<V>(section);
objects.ts ×1
113
>
if (value !== undefined) {
114
>
overrides.push({ identifiers, value });
115
>
}
116
>
}
118
>
}
120
>
}
122
>
getOverrideValue<V>(section: string | undefined, overrideIdentifier: string): V | undefined {
123
>
const overrideContents = this.getContentsForOverrideIdentifer(overrideIdentifier);
configurationModels.ts ×2
124
>
return overrideContents
125
>
? section ? getConfigurationValue<V>(overrideContents, section) : overrideContents as V
configurationModels.ts ×1
129
>
getKeysForOverrideIdentifier(identifier: string): string[] {
131
>
for (const override of this.overrides) {
132
>
if (override.identifiers.includes(identifier)) {
133
>
keys.push(...override.keys);
134
>
}
135
>
}
136
>
return arrays.distinct(keys);
137
>
}
139
>
getAllOverrideIdentifiers(): string[] {
141
>
for (const override of this.overrides) {
143
>
}
145
>
}
147
>
override(identifier: string): ConfigurationModel {
148
>
let overrideConfigurationModel = this.overrideConfigurations.get(identifier);
configurationModels.ts ×3
149
>
if (!overrideConfigurationModel) {
150
>
overrideConfigurationModel = this.createOverrideConfigurationModel(identifier);
151
>
this.overrideConfigurations.set(identifier, overrideConfigurationModel);
152
>
}
153
>
return overrideConfigurationModel;
154
>
}
156
>
merge(...others: ConfigurationModel[]): ConfigurationModel {
158
>
const overrides = objects.deepClone(this.overrides);
159
>
const keys = [...this.keys];
160
>
const raws = this._raw ? Array.isArray(this._raw) ? [...this._raw] : [this._raw] : [this];
161
>
162
>
for (const other of others) {
163
>
raws.push(...(other._raw ? Array.isArray(other._raw) ? other._raw : [other._raw] : [other]));
164
>
if (other.isEmpty()) {
166
>
}
168
>
169
>
for (const otherOverride of other.overrides) {
170
>
const [override] = overrides.filter(o => arrays.equals(o.identifiers, otherOverride.identifiers));
configurationModels.ts ×3
171
>
if (override) {
173
>
override.keys.push(...otherOverride.keys);
174
>
override.keys = arrays.distinct(override.keys);
177
>
}
180
>
if (keys.indexOf(key) === -1) {
182
>
}
184
>
}
185
>
return new ConfigurationModel(contents, keys, overrides, !raws.length || raws.every(raw => raw instanceof ConfigurationModel) ? undefined : raws, this.logService);
configurationModels.ts ×2
186
>
}
188
>
private createOverrideConfigurationModel(identifier: string): ConfigurationModel {
189
>
const overrideContents = this.getContentsForOverrideIdentifer(identifier);
configurationModels.ts ×3
190
>
191
>
if (!overrideContents || typeof overrideContents !== 'object' || !Object.keys(overrideContents).length) {
193
>
return this;
194
>
}
196
>
const contents: IStringDictionary<unknown> = {};
197
>
for (const key of arrays.distinct([...Object.keys(this.contents), ...Object.keys(overrideContents)])) {
198
>
199
>
let contentsForKey = this.contents[key];
200
>
const overrideContentsForKey = overrideContents[key];
201
>
202
>
// If there are override contents for the key, clone and merge otherwise use base contents
203
>
if (overrideContentsForKey) {
204
>
// Clone and merge only if base contents and override contents are of type object otherwise just override
205
>
if (typeof contentsForKey === 'object' && typeof overrideContentsForKey === 'object') {
207
>
this.mergeContents(contentsForKey as IStringDictionary<unknown>, overrideContentsForKey as IStringDictionary<unknown>);
210
>
}
212
>
213
>
contents[key] = contentsForKey;
214
>
}
215
>
216
>
return new ConfigurationModel(contents, this.keys, this.overrides, undefined, this.logService);
219
>
private mergeContents(source: IStringDictionary<unknown>, target: IStringDictionary<unknown>): void {
221
>
if (key in source) {
223
>
this.mergeContents(source[key] as IStringDictionary<unknown>, target[key] as IStringDictionary<unknown>);
configurationModels.ts ×1
224
>
continue;
225
>
}
228
>
}
229
>
}
231
>
private getContentsForOverrideIdentifer(identifier: string): IStringDictionary<unknown> | null {
232
>
let contentsForIdentifierOnly: IStringDictionary<unknown> | null = null;
configurationModels.ts ×3
233
>
let contents: IStringDictionary<unknown> | null = null;
234
>
const mergeContents = (contentsToMerge: IStringDictionary<unknown> | null) => {
235
>
if (contentsToMerge) {
239
>
contents = objects.deepClone(contentsToMerge);
240
>
}
241
>
}
243
>
for (const override of this.overrides) {
244
>
if (override.identifiers.length === 1 && override.identifiers[0] === identifier) {
configurationModels.ts ×3
248
>
}
250
>
// Merge contents of the identifier only at the end to take precedence.
configurationModels.ts ×3
251
>
mergeContents(contentsForIdentifierOnly);
252
>
return contents;
253
>
}
255
>
toJSON(): IConfigurationModel {
256
return {
257
contents: this.contents,
258
overrides: this.overrides,
259
keys: this.keys
260
};
261
}
263
>
// Update methods
264
>
265
>
public addValue(key: string, value: unknown): void {
266
this.updateValue(key, value, true);
267
}
269
>
public setValue(key: string, value: unknown): void {
271
>
}
273
>
public removeValue(key: string): void {
275
>
if (index === -1) {
277
>
}
279
>
removeFromValueTree(this.contents, key);
280
>
if (OVERRIDE_PROPERTY_REGEX.test(key)) {
281
>
this.overrides.splice(this.overrides.findIndex(o => arrays.equals(o.identifiers, overrideIdentifiersFromKey(key))), 1);
configurationModels.ts ×1
282
>
}
285
>
private updateValue(key: string, value: unknown, add: boolean): void {
286
>
addToValueTree(this.contents, key, value, e => this.logService.error(e));
configurationModels.ts ×4
287
>
add = add || this.keys.indexOf(key) === -1;
288
>
if (add) {
290
>
}
292
>
const overrideContents = this.contents[key] as IStringDictionary<unknown>;
configurationModels.ts ×2
293
>
const identifiers = overrideIdentifiersFromKey(key);
294
>
const override = {
295
>
identifiers,
296
>
keys: Object.keys(overrideContents),
297
>
contents: toValuesTree(overrideContents, message => this.logService.error(message)),
298
>
};
299
>
const index = this.overrides.findIndex(o => arrays.equals(o.identifiers, identifiers));
300
>
if (index !== -1) {
303
>
this.overrides.push(override);
304
>
}
305
>
}
308
>
309
>
export interface ConfigurationParseOptions {
310
>
skipUnregistered?: boolean;
311
>
scopes?: ConfigurationScope[];
312
>
skipRestricted?: boolean;
313
>
include?: string[];
314
>
exclude?: string[];
315
>
}
316
>
317
>
export class ConfigurationModelParser {
318
>
319
>
private _raw: IStringDictionary<unknown> | null = null;
320
>
private _configurationModel: ConfigurationModel | null = null;
321
>
private _restrictedConfigurations: string[] = [];
322
>
private _parseErrors: json.ParseError[] = [];
323
>
324
>
constructor(
326
>
protected readonly logService: ILogService
327
>
) { }
329
>
get configurationModel(): ConfigurationModel {
330
>
return this._configurationModel || ConfigurationModel.createEmptyModel(this.logService);
configurationModels.ts ×1
331
>
}
333
>
get restrictedConfigurations(): string[] {
335
>
}
337
>
get errors(): json.ParseError[] {
338
return this._parseErrors;
339
}
341
>
public parse(content: string | null | undefined, options?: ConfigurationParseOptions): void {
343
>
const raw = this.doParseContent(content);
344
>
this.parseRaw(raw, options);
345
>
}
346
>
}
348
>
public reparse(options: ConfigurationParseOptions): void {
350
>
this.parseRaw(this._raw, options);
351
>
}
352
>
}
354
>
public parseRaw(raw: IStringDictionary<unknown>, options?: ConfigurationParseOptions): void {
356
>
const { contents, keys, overrides, restricted, hasExcludedProperties } = this.doParseRaw(raw, options);
357
>
this._configurationModel = new ConfigurationModel(contents, keys, overrides, hasExcludedProperties ? [raw] : undefined /* raw has not changed */, this.logService);
358
>
this._restrictedConfigurations = restricted || [];
359
>
}
361
>
private doParseContent(content: string): IStringDictionary<unknown> {
363
>
let currentProperty: string | null = null;
364
>
let currentParent: unknown[] | IStringDictionary<unknown> = [];
365
>
const previousParents: (unknown[] | IStringDictionary<unknown>)[] = [];
366
>
const parseErrors: json.ParseError[] = [];
367
>
368
>
function onValue(value: unknown) {
370
>
currentParent.push(value);
371
>
} else if (currentProperty !== null) {
373
>
}
376
>
const visitor: json.JSONVisitor = {
377
>
onObjectBegin: () => {
379
>
onValue(object);
380
>
previousParents.push(currentParent);
381
>
currentParent = object;
382
>
currentProperty = null;
383
>
},
386
>
},
389
>
},
392
>
onValue(array);
393
>
previousParents.push(currentParent);
394
>
currentParent = array;
395
>
currentProperty = null;
396
>
},
399
>
},
401
>
onError: (error: json.ParseErrorCode, offset: number, length: number) => {
403
>
}
405
>
if (content) {
407
>
json.visit(content, visitor);
408
>
raw = (currentParent[0] as IStringDictionary<unknown>) || {};
409
>
} catch (e) {
410
this.logService.error(`Error while parsing settings file ${this._name}: ${e}`);
411
this._parseErrors = [e as json.ParseError];
412
}
415
>
return raw;
416
>
}
418
>
protected doParseRaw(raw: IStringDictionary<unknown>, options?: ConfigurationParseOptions): IConfigurationModel & { restricted?: string[]; hasExcludedProperties?: boolean } {
419
>
const registry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);
configurationModels.ts ×6
420
>
const configurationProperties = registry.getConfigurationProperties();
421
>
const excludedConfigurationProperties = registry.getExcludedConfigurationProperties();
422
>
const filtered = this.filter(raw, configurationProperties, excludedConfigurationProperties, true, options);
423
>
raw = filtered.raw;
424
>
const contents = toValuesTree(raw, message => this.logService.error(`Conflict in settings file ${this._name}: ${message}`));
425
>
const keys = Object.keys(raw);
426
>
const overrides = this.toOverrides(raw, message => this.logService.error(`Conflict in settings file ${this._name}: ${message}`));
427
>
return { contents, keys, overrides, restricted: filtered.restricted, hasExcludedProperties: filtered.hasExcludedProperties };
428
>
}
430
>
private filter(properties: IStringDictionary<unknown>, configurationProperties: IStringDictionary<IRegisteredConfigurationPropertySchema>, excludedConfigurationProperties: IStringDictionary<IRegisteredConfigurationPropertySchema>, filterOverriddenProperties: boolean, options?: ConfigurationParseOptions): { raw: IStringDictionary<unknown>; restricted: string[]; hasExcludedProperties: boolean } {
432
>
if (!options?.scopes && !options?.skipRestricted && !options?.skipUnregistered && !options?.exclude?.length) {
434
>
}
436
>
const restricted: string[] = [];
437
>
for (const key in properties) {
438
>
if (OVERRIDE_PROPERTY_REGEX.test(key) && filterOverriddenProperties) {
439
>
const result = this.filter(properties[key] as IStringDictionary<unknown>, configurationProperties, excludedConfigurationProperties, false, options);
configurationModels.ts ×1
440
>
raw[key] = result.raw;
441
>
hasExcludedProperties = hasExcludedProperties || result.hasExcludedProperties;
442
>
restricted.push(...result.restricted);
444
>
const propertySchema = configurationProperties[key];
445
>
if (propertySchema?.restricted) {
447
>
}
448
>
if (this.shouldInclude(key, propertySchema, excludedConfigurationProperties, options)) {
configurationModels.ts ×11
452
>
}
454
>
}
455
>
return { raw, restricted, hasExcludedProperties };
458
>
private shouldInclude(key: string, propertySchema: IConfigurationPropertySchema | undefined, excludedConfigurationProperties: IStringDictionary<IRegisteredConfigurationPropertySchema>, options: ConfigurationParseOptions): boolean {
461
>
}
463
>
if (options.include?.includes(key)) {
465
>
}
469
>
}
473
>
}
475
>
const schema = propertySchema ?? excludedConfigurationProperties[key];
476
>
const scope = schema ? typeof schema.scope !== 'undefined' ? schema.scope : ConfigurationScope.WINDOW : undefined;
configurationModels.ts ×11
477
>
if (scope === undefined || options.scopes === undefined) {
479
>
}
481
>
return options.scopes.includes(scope);
484
>
private toOverrides(raw: IStringDictionary<unknown>, conflictReporter: (message: string) => void): IOverrides[] {
486
>
for (const key of Object.keys(raw)) {
489
>
const rawKey = raw[key] as IStringDictionary<unknown>;
490
>
for (const keyInOverrideRaw in rawKey) {
491
>
overrideRaw[keyInOverrideRaw] = rawKey[keyInOverrideRaw];
492
>
}
493
>
overrides.push({
494
>
identifiers: overrideIdentifiersFromKey(key),
495
>
keys: Object.keys(overrideRaw),
496
>
contents: toValuesTree(overrideRaw, conflictReporter)
497
>
});
498
>
}
501
>
}
503
>
}
504
>
505
>
export class UserSettings extends Disposable {
506
>
507
>
private readonly parser: ConfigurationModelParser;
508
>
protected readonly _onDidChange: Emitter<void> = this._register(new Emitter<void>());
509
>
readonly onDidChange: Event<void> = this._onDidChange.event;
510
>
511
>
constructor(
513
>
protected parseOptions: ConfigurationParseOptions,
514
>
extUri: IExtUri,
515
>
private readonly fileService: IFileService,
516
>
private readonly logService: ILogService,
517
>
) {
518
>
super();
519
>
this.parser = new ConfigurationModelParser(this.userSettingsResource.toString(), logService);
520
>
this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
521
>
// Also listen to the resource incase the resource is a symlink - https://github.com/microsoft/vscode/issues/118134
522
>
this._register(this.fileService.watch(this.userSettingsResource));
523
>
this._register(Event.any(
524
>
Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)),
525
>
Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(FileOperation.CREATE) || e.isOperation(FileOperation.COPY) || e.isOperation(FileOperation.DELETE) || e.isOperation(FileOperation.WRITE)) && extUri.isEqual(e.resource, userSettingsResource))
526
>
)(() => this._onDidChange.fire()));
527
>
}
529
>
async loadConfiguration(): Promise<ConfigurationModel> {
531
>
const content = await this.fileService.readFile(this.userSettingsResource);
532
>
this.parser.parse(content.value.toString() || '{}', this.parseOptions);
533
>
return this.parser.configurationModel;
534
>
} catch (e) {
536
>
}
539
>
reparse(parseOptions?: ConfigurationParseOptions): ConfigurationModel {
540
if (parseOptions) {
541
this.parseOptions = parseOptions;
542
}
543
this.parser.reparse(this.parseOptions);
544
return this.parser.configurationModel;
545
}
547
>
getRestrictedSettings(): string[] {
548
return this.parser.restrictedConfigurations;
549
}
551
>
552
>
class ConfigurationInspectValue<V> implements IConfigurationValue<V> {
553
>
554
>
constructor(
556
>
private readonly overrides: IConfigurationOverrides,
557
>
private readonly _value: V | undefined,
558
>
readonly overrideIdentifiers: string[] | undefined,
559
>
private readonly defaultConfiguration: ConfigurationModel,
560
>
private readonly policyConfiguration: ConfigurationModel | undefined,
561
>
private readonly applicationConfiguration: ConfigurationModel | undefined,
562
>
private readonly userConfiguration: ConfigurationModel,
563
>
private readonly localUserConfiguration: ConfigurationModel,
564
>
private readonly remoteUserConfiguration: ConfigurationModel,
565
>
private readonly workspaceConfiguration: ConfigurationModel | undefined,
566
>
private readonly folderConfigurationModel: ConfigurationModel | undefined,
567
>
private readonly memoryConfigurationModel: ConfigurationModel
568
>
) {
569
>
}
571
>
get value(): V | undefined {
573
>
}
575
>
private toInspectValue(inspectValue: IInspectValue<V> | undefined | null): IInspectValue<V> | undefined {
576
>
return inspectValue?.value !== undefined || inspectValue?.override !== undefined || inspectValue?.overrides !== undefined ? inspectValue : undefined;
configurationModels.ts ×4
577
>
}
579
>
private _defaultInspectValue: InspectValue<V> | undefined;
580
>
private get defaultInspectValue(): InspectValue<V> {
582
>
this._defaultInspectValue = this.defaultConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
583
>
}
584
>
return this._defaultInspectValue;
585
>
}
587
>
get defaultValue(): V | undefined {
589
>
}
591
>
get default(): IInspectValue<V> | undefined {
592
return this.toInspectValue(this.defaultInspectValue);
593
}
595
>
private _policyInspectValue: InspectValue<V> | undefined | null;
596
>
private get policyInspectValue(): InspectValue<V> | null {
598
>
this._policyInspectValue = this.policyConfiguration ? this.policyConfiguration.inspect<V>(this.key) : null;
599
>
}
600
>
return this._policyInspectValue;
601
>
}
603
>
get policyValue(): V | undefined {
605
>
}
607
>
get policy(): IInspectValue<V> | undefined {
608
return this.policyInspectValue?.value !== undefined ? { value: this.policyInspectValue.value } : undefined;
609
}
611
>
private _applicationInspectValue: InspectValue<V> | undefined | null;
612
>
private get applicationInspectValue(): InspectValue<V> | null {
614
>
this._applicationInspectValue = this.applicationConfiguration ? this.applicationConfiguration.inspect<V>(this.key) : null;
615
>
}
616
>
return this._applicationInspectValue;
617
>
}
619
>
get applicationValue(): V | undefined {
621
>
}
623
>
get application(): IInspectValue<V> | undefined {
624
return this.toInspectValue(this.applicationInspectValue);
625
}
627
>
private _userInspectValue: InspectValue<V> | undefined;
628
>
private get userInspectValue(): InspectValue<V> {
630
>
this._userInspectValue = this.userConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
631
>
}
632
>
return this._userInspectValue;
633
>
}
635
>
get userValue(): V | undefined {
637
>
}
639
>
get user(): IInspectValue<V> | undefined {
641
>
}
643
>
private _userLocalInspectValue: InspectValue<V> | undefined;
644
>
private get userLocalInspectValue(): InspectValue<V> {
646
>
this._userLocalInspectValue = this.localUserConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
647
>
}
648
>
return this._userLocalInspectValue;
649
>
}
651
>
get userLocalValue(): V | undefined {
653
>
}
655
>
get userLocal(): IInspectValue<V> | undefined {
657
>
}
659
>
private _userRemoteInspectValue: InspectValue<V> | undefined;
660
>
private get userRemoteInspectValue(): InspectValue<V> {
662
>
this._userRemoteInspectValue = this.remoteUserConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
663
>
}
664
>
return this._userRemoteInspectValue;
665
>
}
667
>
get userRemoteValue(): V | undefined {
669
>
}
671
>
get userRemote(): IInspectValue<V> | undefined {
673
>
}
675
>
private _workspaceInspectValue: InspectValue<V> | undefined | null;
676
>
private get workspaceInspectValue(): InspectValue<V> | null {
678
>
this._workspaceInspectValue = this.workspaceConfiguration ? this.workspaceConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier) : null;
679
>
}
680
>
return this._workspaceInspectValue;
681
>
}
683
>
get workspaceValue(): V | undefined {
685
>
}
687
>
get workspace(): IInspectValue<V> | undefined {
688
return this.toInspectValue(this.workspaceInspectValue);
689
}
691
>
private _workspaceFolderInspectValue: InspectValue<V> | undefined | null;
692
>
private get workspaceFolderInspectValue(): InspectValue<V> | null {
694
>
this._workspaceFolderInspectValue = this.folderConfigurationModel ? this.folderConfigurationModel.inspect<V>(this.key, this.overrides.overrideIdentifier) : null;
695
>
}
696
>
return this._workspaceFolderInspectValue;
697
>
}
699
>
get workspaceFolderValue(): V | undefined {
701
>
}
703
>
get workspaceFolder(): IInspectValue<V> | undefined {
704
return this.toInspectValue(this.workspaceFolderInspectValue);
705
}
707
>
private _memoryInspectValue: InspectValue<V> | undefined;
708
>
private get memoryInspectValue(): InspectValue<V> {
709
if (this._memoryInspectValue === undefined) {
710
this._memoryInspectValue = this.memoryConfigurationModel.inspect<V>(this.key, this.overrides.overrideIdentifier);
711
}
712
return this._memoryInspectValue;
713
}
715
>
get memoryValue(): V | undefined {
716
return this.memoryInspectValue.merged;
717
}
719
>
get memory(): IInspectValue<V> | undefined {
720
return this.toInspectValue(this.memoryInspectValue);
721
}
723
>
}
724
>
725
>
export class Configuration {
726
>
727
>
private _workspaceConsolidatedConfiguration: ConfigurationModel | null = null;
728
>
private _foldersConsolidatedConfigurations = new ResourceMap<ConfigurationModel>();
729
>
730
>
constructor(
732
>
private _policyConfiguration: ConfigurationModel,
733
>
private _applicationConfiguration: ConfigurationModel,
734
>
private _localUserConfiguration: ConfigurationModel,
735
>
private _remoteUserConfiguration: ConfigurationModel,
736
>
private _workspaceConfiguration: ConfigurationModel,
737
>
private _folderConfigurations: ResourceMap<ConfigurationModel>,
738
>
private _memoryConfiguration: ConfigurationModel,
739
>
private _memoryConfigurationByResource: ResourceMap<ConfigurationModel>,
740
>
private readonly logService: ILogService
741
>
) {
742
>
}
743
>
744
>
getValue(section: string | undefined, overrides: IConfigurationOverrides, workspace: Workspace | undefined): unknown {
745
>
const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(section, overrides, workspace);
configurationModels.ts ×1
746
>
return consolidateConfigurationModel.getValue(section);
747
>
}
749
>
updateValue(key: string, value: unknown, overrides: IConfigurationUpdateOverrides = {}): void {
751
>
if (overrides.resource) {
752
memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
753
if (!memoryConfiguration) {
754
memoryConfiguration = ConfigurationModel.createEmptyModel(this.logService);
755
this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
756
}
758
>
memoryConfiguration = this._memoryConfiguration;
759
>
}
760
>
761
>
if (value === undefined) {
762
memoryConfiguration.removeValue(key);
764
>
memoryConfiguration.setValue(key, value);
765
>
}
766
>
767
>
if (!overrides.resource) {
768
>
this._workspaceConsolidatedConfiguration = null;
769
>
}
770
>
}
772
>
inspect<C>(key: string, overrides: IConfigurationOverrides, workspace: Workspace | undefined): IConfigurationValue<C> {
773
>
const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(key, overrides, workspace);
configurationModels.ts ×5
774
>
const folderConfigurationModel = this.getFolderConfigurationModelForResource(overrides.resource, workspace);
775
>
const memoryConfigurationModel = overrides.resource ? this._memoryConfigurationByResource.get(overrides.resource) || this._memoryConfiguration : this._memoryConfiguration;
776
>
const overrideIdentifiers = new Set<string>();
777
>
for (const override of consolidateConfigurationModel.overrides) {
779
>
if (consolidateConfigurationModel.getOverrideValue(key, overrideIdentifier) !== undefined) {
780
>
overrideIdentifiers.add(overrideIdentifier);
781
>
}
782
>
}
783
>
}
785
>
return new ConfigurationInspectValue<C>(
786
>
key,
787
>
overrides,
788
>
consolidateConfigurationModel.getValue<C>(key),
789
>
overrideIdentifiers.size ? [...overrideIdentifiers] : undefined,
790
>
this._defaultConfiguration,
791
>
this._policyConfiguration.isEmpty() ? undefined : this._policyConfiguration,
792
>
this.applicationConfiguration.isEmpty() ? undefined : this.applicationConfiguration,
793
>
this.userConfiguration,
794
>
this.localUserConfiguration,
795
>
this.remoteUserConfiguration,
796
>
workspace ? this._workspaceConfiguration : undefined,
797
>
folderConfigurationModel ? folderConfigurationModel : undefined,
798
>
memoryConfigurationModel
799
>
);
800
>
801
>
}
803
>
keys(workspace: Workspace | undefined): {
804
default: string[];
805
policy: string[];
806
user: string[];
807
workspace: string[];
808
workspaceFolder: string[];
809
} {
810
const folderConfigurationModel = this.getFolderConfigurationModelForResource(undefined, workspace);
811
return {
812
default: this._defaultConfiguration.keys.slice(0),
813
policy: this._policyConfiguration.keys.slice(0),
814
user: this.userConfiguration.keys.slice(0),
815
workspace: this._workspaceConfiguration.keys.slice(0),
816
workspaceFolder: folderConfigurationModel ? folderConfigurationModel.keys.slice(0) : []
817
};
818
}
820
>
updateDefaultConfiguration(defaultConfiguration: ConfigurationModel): void {
822
>
this._workspaceConsolidatedConfiguration = null;
823
>
this._foldersConsolidatedConfigurations.clear();
824
>
}
826
>
updatePolicyConfiguration(policyConfiguration: ConfigurationModel): void {
827
this._policyConfiguration = policyConfiguration;
828
}
830
>
updateApplicationConfiguration(applicationConfiguration: ConfigurationModel): void {
832
>
this._workspaceConsolidatedConfiguration = null;
833
>
this._foldersConsolidatedConfigurations.clear();
834
>
}
836
>
updateLocalUserConfiguration(localUserConfiguration: ConfigurationModel): void {
838
>
this._userConfiguration = null;
839
>
this._workspaceConsolidatedConfiguration = null;
840
>
this._foldersConsolidatedConfigurations.clear();
841
>
}
843
>
updateRemoteUserConfiguration(remoteUserConfiguration: ConfigurationModel): void {
844
this._remoteUserConfiguration = remoteUserConfiguration;
845
this._userConfiguration = null;
846
this._workspaceConsolidatedConfiguration = null;
847
this._foldersConsolidatedConfigurations.clear();
848
}
850
>
updateWorkspaceConfiguration(workspaceConfiguration: ConfigurationModel): void {
852
>
this._workspaceConsolidatedConfiguration = null;
853
>
this._foldersConsolidatedConfigurations.clear();
854
>
}
856
>
updateFolderConfiguration(resource: URI, configuration: ConfigurationModel): void {
858
>
this._foldersConsolidatedConfigurations.delete(resource);
859
>
}
861
>
deleteFolderConfiguration(resource: URI): void {
863
>
this._foldersConsolidatedConfigurations.delete(resource);
864
>
}
866
>
compareAndUpdateDefaultConfiguration(defaults: ConfigurationModel, keys?: string[]): IConfigurationChange {
868
>
if (!keys) {
869
const { added, updated, removed } = compare(this._defaultConfiguration, defaults);
870
keys = [...added, ...updated, ...removed];
871
}
874
>
const fromKeys = this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier);
875
>
const toKeys = defaults.getKeysForOverrideIdentifier(overrideIdentifier);
876
>
const keys = [
877
>
...toKeys.filter(key => fromKeys.indexOf(key) === -1),
878
>
...fromKeys.filter(key => toKeys.indexOf(key) === -1),
879
>
...fromKeys.filter(key => !objects.equals(this._defaultConfiguration.override(overrideIdentifier).getValue(key), defaults.override(overrideIdentifier).getValue(key)))
880
>
];
881
>
overrides.push([overrideIdentifier, keys]);
882
>
}
883
>
}
885
>
return { keys, overrides };
886
>
}
888
>
compareAndUpdatePolicyConfiguration(policyConfiguration: ConfigurationModel): IConfigurationChange {
889
const { added, updated, removed } = compare(this._policyConfiguration, policyConfiguration);
890
const keys = [...added, ...updated, ...removed];
891
if (keys.length) {
892
this.updatePolicyConfiguration(policyConfiguration);
893
}
894
return { keys, overrides: [] };
895
}
897
>
compareAndUpdateApplicationConfiguration(application: ConfigurationModel): IConfigurationChange {
898
>
const { added, updated, removed, overrides } = compare(this.applicationConfiguration, application);
configurationModels.ts ×2
899
>
const keys = [...added, ...updated, ...removed];
900
>
if (keys.length) {
901
>
this.updateApplicationConfiguration(application);
902
>
}
903
>
return { keys, overrides };
904
>
}
906
>
compareAndUpdateLocalUserConfiguration(user: ConfigurationModel): IConfigurationChange {
907
>
const { added, updated, removed, overrides } = compare(this.localUserConfiguration, user);
configurationModels.ts ×2
908
>
const keys = [...added, ...updated, ...removed];
909
>
if (keys.length) {
911
>
}
913
>
}
915
>
compareAndUpdateRemoteUserConfiguration(user: ConfigurationModel): IConfigurationChange {
916
const { added, updated, removed, overrides } = compare(this.remoteUserConfiguration, user);
917
const keys = [...added, ...updated, ...removed];
918
if (keys.length) {
919
this.updateRemoteUserConfiguration(user);
920
}
921
return { keys, overrides };
922
}
924
>
compareAndUpdateWorkspaceConfiguration(workspaceConfiguration: ConfigurationModel): IConfigurationChange {
925
>
const { added, updated, removed, overrides } = compare(this.workspaceConfiguration, workspaceConfiguration);
configurationModels.ts ×2
926
>
const keys = [...added, ...updated, ...removed];
927
>
if (keys.length) {
928
>
this.updateWorkspaceConfiguration(workspaceConfiguration);
929
>
}
930
>
return { keys, overrides };
931
>
}
933
>
compareAndUpdateFolderConfiguration(resource: URI, folderConfiguration: ConfigurationModel): IConfigurationChange {
934
>
const currentFolderConfiguration = this.folderConfigurations.get(resource);
configurationModels.ts ×1
935
>
const { added, updated, removed, overrides } = compare(currentFolderConfiguration, folderConfiguration);
936
>
const keys = [...added, ...updated, ...removed];
937
>
if (keys.length || !currentFolderConfiguration) {
938
>
this.updateFolderConfiguration(resource, folderConfiguration);
939
>
}
940
>
return { keys, overrides };
941
>
}
943
>
compareAndDeleteFolderConfiguration(folder: URI): IConfigurationChange {
945
>
if (!folderConfig) {
946
throw new Error('Unknown folder');
947
}
949
>
const { added, updated, removed, overrides } = compare(folderConfig, undefined);
950
>
return { keys: [...added, ...updated, ...removed], overrides };
951
>
}
953
>
get defaults(): ConfigurationModel {
954
return this._defaultConfiguration;
955
}
957
>
get applicationConfiguration(): ConfigurationModel {
959
>
}
961
>
private _userConfiguration: ConfigurationModel | null = null;
964
>
if (this._remoteUserConfiguration.isEmpty()) {
967
>
const merged = this._localUserConfiguration.merge(this._remoteUserConfiguration);
configurationModels.ts ×1
968
>
this._userConfiguration = new ConfigurationModel(merged.contents, merged.keys, merged.overrides, undefined, this.logService);
969
>
}
971
>
return this._userConfiguration;
972
>
}
974
>
get localUserConfiguration(): ConfigurationModel {
976
>
}
978
>
get remoteUserConfiguration(): ConfigurationModel {
980
>
}
982
>
get workspaceConfiguration(): ConfigurationModel {
984
>
}
986
>
get folderConfigurations(): ResourceMap<ConfigurationModel> {
988
>
}
990
>
private getConsolidatedConfigurationModel(section: string | undefined, overrides: IConfigurationOverrides, workspace: Workspace | undefined): ConfigurationModel {
991
>
let configurationModel = this.getConsolidatedConfigurationModelForResource(overrides, workspace);
configurationModels.ts ×9
992
>
if (overrides.overrideIdentifier) {
993
>
configurationModel = configurationModel.override(overrides.overrideIdentifier);
configurationModels.ts ×1
994
>
}
995
>
if (!this._policyConfiguration.isEmpty() && this._policyConfiguration.getValue(section) !== undefined) {
configurationModels.ts ×9
997
>
configurationModel = configurationModel.merge();
998
>
for (const key of this._policyConfiguration.keys) {
999
>
configurationModel.setValue(key, this._policyConfiguration.getValue(key));
1000
>
}
1001
>
}
1003
>
}
1005
>
private getConsolidatedConfigurationModelForResource({ resource }: IConfigurationOverrides, workspace: Workspace | undefined): ConfigurationModel {
1006
>
let consolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
configurationModels.ts ×9
1007
>
1008
>
if (workspace && resource) {
1010
>
if (root) {
1011
>
consolidateConfiguration = this.getFolderConsolidatedConfiguration(root.uri) || consolidateConfiguration;
1012
>
}
1013
>
const memoryConfigurationForResource = this._memoryConfigurationByResource.get(resource);
1014
>
if (memoryConfigurationForResource) {
1015
consolidateConfiguration = consolidateConfiguration.merge(memoryConfigurationForResource);
1016
}
1019
>
return consolidateConfiguration;
1020
>
}
1022
>
private getWorkspaceConsolidatedConfiguration(): ConfigurationModel {
1024
>
this._workspaceConsolidatedConfiguration = this._defaultConfiguration.merge(this.applicationConfiguration, this.userConfiguration, this._workspaceConfiguration, this._memoryConfiguration);
1025
>
}
1026
>
return this._workspaceConsolidatedConfiguration;
1027
>
}
1029
>
private getFolderConsolidatedConfiguration(folder: URI): ConfigurationModel {
1030
>
let folderConsolidatedConfiguration = this._foldersConsolidatedConfigurations.get(folder);
configurationModels.ts ×3
1031
>
if (!folderConsolidatedConfiguration) {
1032
>
const workspaceConsolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
1033
>
const folderConfiguration = this._folderConfigurations.get(folder);
1034
>
if (folderConfiguration) {
1035
>
folderConsolidatedConfiguration = workspaceConsolidateConfiguration.merge(folderConfiguration);
1036
>
this._foldersConsolidatedConfigurations.set(folder, folderConsolidatedConfiguration);
1037
>
} else {
1038
>
folderConsolidatedConfiguration = workspaceConsolidateConfiguration;
1039
>
}
1040
>
}
1041
>
return folderConsolidatedConfiguration;
1042
>
}
1044
>
private getFolderConfigurationModelForResource(resource: URI | null | undefined, workspace: Workspace | undefined): ConfigurationModel | undefined {
1046
const root = workspace.getFolder(resource);
1047
if (root) {
1048
return this._folderConfigurations.get(root.uri);
1049
}
1050
}
1052
>
}
1054
>
toData(): IConfigurationData {
1056
>
defaults: {
1057
>
contents: this._defaultConfiguration.contents,
1058
>
overrides: this._defaultConfiguration.overrides,
1059
>
keys: this._defaultConfiguration.keys,
1060
>
},
1061
>
policy: {
1062
>
contents: this._policyConfiguration.contents,
1063
>
overrides: this._policyConfiguration.overrides,
1064
>
keys: this._policyConfiguration.keys
1065
>
},
1066
>
application: {
1067
>
contents: this.applicationConfiguration.contents,
1068
>
overrides: this.applicationConfiguration.overrides,
1069
>
keys: this.applicationConfiguration.keys,
1070
>
raw: Array.isArray(this.applicationConfiguration.raw) ? undefined : this.applicationConfiguration.raw
1071
>
},
1072
>
userLocal: {
1073
>
contents: this.localUserConfiguration.contents,
1074
>
overrides: this.localUserConfiguration.overrides,
1075
>
keys: this.localUserConfiguration.keys,
1076
>
raw: Array.isArray(this.localUserConfiguration.raw) ? undefined : this.localUserConfiguration.raw
1077
>
},
1078
>
userRemote: {
1079
>
contents: this.remoteUserConfiguration.contents,
1080
>
overrides: this.remoteUserConfiguration.overrides,
1081
>
keys: this.remoteUserConfiguration.keys,
1082
>
raw: Array.isArray(this.remoteUserConfiguration.raw) ? undefined : this.remoteUserConfiguration.raw
1083
>
},
1084
>
workspace: {
1085
>
contents: this._workspaceConfiguration.contents,
1086
>
overrides: this._workspaceConfiguration.overrides,
1087
>
keys: this._workspaceConfiguration.keys
1088
>
},
1089
>
folders: [...this._folderConfigurations.keys()].reduce<[UriComponents, IConfigurationModel][]>((result, folder) => {
1090
>
const { contents, overrides, keys } = this._folderConfigurations.get(folder)!;
configurationModels.ts ×2
1091
>
result.push([folder, { contents, overrides, keys }]);
1092
>
return result;
1094
>
};
1095
>
}
1097
>
allKeys(): string[] {
1099
>
this._defaultConfiguration.keys.forEach(key => keys.add(key));
1100
>
this.userConfiguration.keys.forEach(key => keys.add(key));
1101
>
this._workspaceConfiguration.keys.forEach(key => keys.add(key));
1102
>
this._folderConfigurations.forEach(folderConfiguration => folderConfiguration.keys.forEach(key => keys.add(key)));
1103
>
return [...keys.values()];
1104
>
}
1106
>
protected allOverrideIdentifiers(): string[] {
1108
>
this._defaultConfiguration.getAllOverrideIdentifiers().forEach(key => keys.add(key));
1109
>
this.userConfiguration.getAllOverrideIdentifiers().forEach(key => keys.add(key));
1110
>
this._workspaceConfiguration.getAllOverrideIdentifiers().forEach(key => keys.add(key));
1111
>
this._folderConfigurations.forEach(folderConfiguration => folderConfiguration.getAllOverrideIdentifiers().forEach(key => keys.add(key)));
1112
>
return [...keys.values()];
1113
>
}
1115
>
protected getAllKeysForOverrideIdentifier(overrideIdentifier: string): string[] {
1117
>
this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
1118
>
this.userConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
1119
>
this._workspaceConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
1120
>
this._folderConfigurations.forEach(folderConfiguration => folderConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key)));
1121
>
return [...keys.values()];
1122
>
}
1124
>
static parse(data: IConfigurationData, logService: ILogService): Configuration {
1125
>
const defaultConfiguration = this.parseConfigurationModel(data.defaults, logService);
configurationModels.ts ×3
1126
>
const policyConfiguration = this.parseConfigurationModel(data.policy, logService);
1127
>
const applicationConfiguration = this.parseConfigurationModel(data.application, logService);
1128
>
const userLocalConfiguration = this.parseConfigurationModel(data.userLocal, logService);
1129
>
const userRemoteConfiguration = this.parseConfigurationModel(data.userRemote, logService);
1130
>
const workspaceConfiguration = this.parseConfigurationModel(data.workspace, logService);
1131
>
const folders: ResourceMap<ConfigurationModel> = data.folders.reduce((result, value) => {
1132
>
result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1], logService));
configurationModels.ts ×2
1133
>
return result;
1135
>
return new Configuration(
1136
>
defaultConfiguration,
1137
>
policyConfiguration,
1138
>
applicationConfiguration,
1139
>
userLocalConfiguration,
1140
>
userRemoteConfiguration,
1141
>
workspaceConfiguration,
1142
>
folders,
1143
>
ConfigurationModel.createEmptyModel(logService),
1144
>
new ResourceMap<ConfigurationModel>(),
1145
>
logService
1146
>
);
1147
>
}
1149
>
private static parseConfigurationModel(model: IConfigurationModel, logService: ILogService): ConfigurationModel {
1150
>
return new ConfigurationModel(model.contents, model.keys, model.overrides, model.raw, logService);
configurationModels.ts ×3
1151
>
}
1153
>
}
1154
>
1155
>
export function mergeChanges(...changes: IConfigurationChange[]): IConfigurationChange {
1158
>
}
1161
>
}
1163
>
const overridesMap = new Map<string, Set<string>>();
1164
>
for (const change of changes) {
1165
>
change.keys.forEach(key => keysSet.add(key));
1166
>
change.overrides.forEach(([identifier, keys]) => {
1168
>
keys.forEach(key => result.add(key));
1170
>
}
1171
>
const overrides: [string, string[]][] = [];
1172
>
overridesMap.forEach((keys, identifier) => overrides.push([identifier, [...keys.values()]]));
1173
>
return { keys: [...keysSet.values()], overrides };
1174
>
}
1176
>
export class ConfigurationChangeEvent implements IConfigurationChangeEvent {
1177
>
1178
>
private readonly _marker = '\n';
1179
>
private readonly _markerCode1 = this._marker.charCodeAt(0);
1180
>
private readonly _markerCode2 = '.'.charCodeAt(0);
1181
>
private readonly _affectsConfigStr: string;
1182
>
1183
>
readonly affectedKeys = new Set<string>();
1184
>
source!: ConfigurationTarget;
1185
>
1186
>
constructor(
1188
>
private readonly previous: { workspace?: Workspace; data: IConfigurationData } | undefined,
1189
>
private readonly currentConfiguraiton: Configuration,
1190
>
private readonly currentWorkspace: Workspace | undefined,
1191
>
private readonly logService: ILogService
1192
>
) {
1193
>
for (const key of change.keys) {
1195
>
}
1198
>
this.affectedKeys.add(key);
1199
>
}
1200
>
}
1202
>
// Example: '\nfoo.bar\nabc.def\n'
1203
>
this._affectsConfigStr = this._marker;
1204
>
for (const key of this.affectedKeys) {
1206
>
}
1209
>
private _previousConfiguration: Configuration | undefined = undefined;
1210
>
get previousConfiguration(): Configuration | undefined {
1212
>
this._previousConfiguration = Configuration.parse(this.previous.data, this.logService);
configurationModels.ts ×1
1213
>
}
1215
>
}
1217
>
affectsConfiguration(section: string, overrides?: IConfigurationOverrides): boolean {
1218
>
// we have one large string with all keys that have changed. we pad (marker) the section
configurationModels.ts ×3
1219
>
// and check that either find it padded or before a segment character
1220
>
const needle = this._marker + section;
1221
>
const idx = this._affectsConfigStr.indexOf(needle);
1222
>
if (idx < 0) {
1224
>
return false;
1225
>
}
1227
>
if (pos >= this._affectsConfigStr.length) {
1228
return false;
1229
}
1233
>
return false;
1234
>
}
1236
>
const value1 = this.previousConfiguration ? this.previousConfiguration.getValue(section, overrides, this.previous?.workspace) : undefined;
configurationModels.ts ×3
1237
>
const value2 = this.currentConfiguraiton.getValue(section, overrides, this.currentWorkspace);
1238
>
return !objects.equals(value1, value2);
1239
>
}
1243
>
1244
>
function compare(from: ConfigurationModel | undefined, to: ConfigurationModel | undefined): IConfigurationCompareResult {
configurationModels.ts ×8
1245
>
const { added, removed, updated } = compareConfigurationContents(to?.rawConfiguration, from?.rawConfiguration);
1246
>
const overrides: [string, string[]][] = [];
1247
>
1248
>
const fromOverrideIdentifiers = from?.getAllOverrideIdentifiers() || [];
1249
>
const toOverrideIdentifiers = to?.getAllOverrideIdentifiers() || [];
1250
>
1251
>
if (to) {
1252
>
const addedOverrideIdentifiers = toOverrideIdentifiers.filter(key => !fromOverrideIdentifiers.includes(key));
configurationModels.ts ×7
1253
>
for (const identifier of addedOverrideIdentifiers) {
1254
>
overrides.push([identifier, to.getKeysForOverrideIdentifier(identifier)]);
configurationModels.ts ×1
1255
>
}
1258
>
if (from) {
1259
>
const removedOverrideIdentifiers = fromOverrideIdentifiers.filter(key => !toOverrideIdentifiers.includes(key));
1260
>
for (const identifier of removedOverrideIdentifiers) {
1261
>
overrides.push([identifier, from.getKeysForOverrideIdentifier(identifier)]);
configurationModels.ts ×1
1262
>
}
1264
>
1265
>
if (to && from) {
1268
>
const result = compareConfigurationContents({ contents: from.getOverrideValue(undefined, identifier) || {}, keys: from.getKeysForOverrideIdentifier(identifier) }, { contents: to.getOverrideValue(undefined, identifier) || {}, keys: to.getKeysForOverrideIdentifier(identifier) });
1269
>
overrides.push([identifier, [...result.added, ...result.removed, ...result.updated]]);
1270
>
}
1271
>
}
1274
>
return { added, removed, updated, overrides };
1275
>
}
1277
>
function compareConfigurationContents(to: { keys: string[]; contents: IStringDictionary<unknown> } | undefined, from: { keys: string[]; contents: IStringDictionary<unknown> } | undefined) {
configurationModels.ts ×8
1278
>
const added = to
1279
>
? from ? to.keys.filter(key => from.keys.indexOf(key) === -1) : [...to.keys]
configurationModels.ts ×7
1282
>
? to ? from.keys.filter(key => to.keys.indexOf(key) === -1) : [...from.keys]
1285
>
1286
>
if (to && from) {
1290
>
const value2 = getConfigurationValue(to.contents, key);
1291
>
if (!objects.equals(value1, value2)) {
1293
>
}
1298
>
}