@theia/core 1.65.0-next.19 → 1.65.0-next.28

package/src/browser/preferences/preference-proxy.spec.ts

@@ -24,14 +24,10 @@ import * as assert from 'assert';
 import { Container } from 'inversify';
 import { bindPreferenceService } from '../frontend-application-bindings';
 import { bindMockPreferenceProviders, MockPreferenceProvider } from './test';
-import { PreferenceService, PreferenceServiceImpl } from './preference-service';
-import { PreferenceSchemaProvider, PreferenceSchema } from './preference-contribution';
-import { PreferenceScope } from './preference-scope';
-import { PreferenceProvider } from './preference-provider';
+import { PreferenceScope } from '../../common/preferences/preference-scope';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
-import { PreferenceProxyOptions, PreferenceProxy, PreferenceChangeEvent, createPreferenceProxy } from './preference-proxy';
-import { PreferenceProxyFactory } from './injectable-preference-proxy';
-import { waitForEvent } from '../../common/promise-util';
+import { PreferenceProxyOptions, PreferenceProxy, PreferenceChangeEvent, createPreferenceProxy } from '../../common/preferences/preference-proxy';
+import { PreferenceProxyFactory } from '../../common/preferences/injectable-preference-proxy';
 
 disableJSDOM();
 
@@ -41,6 +37,10 @@ process.on('unhandledRejection', (reason, promise) => {
 });
 
 import { expect } from 'chai';
+import { PreferenceProvider } from '../../common/preferences/preference-provider';
+import { PreferenceSchema, PreferenceSchemaService } from '../../common/preferences/preference-schema';
+import { PreferenceService, PreferenceServiceImpl } from '../../common/preferences';
+import { waitForEvent } from '../../common/promise-util';
 let testContainer: Container;
 
 function createTestContainer(): Container {
@@ -52,7 +52,7 @@ function createTestContainer(): Container {
 
 describe('Preference Proxy', () => {
     let prefService: PreferenceServiceImpl;
-    let prefSchema: PreferenceSchemaProvider;
+    let prefSchema: PreferenceSchemaService;
 
     before(() => {
         disableJSDOM = enableJSDOM();
@@ -65,7 +65,7 @@ describe('Preference Proxy', () => {
 
     beforeEach(async () => {
         testContainer = createTestContainer();
-        prefSchema = testContainer.get(PreferenceSchemaProvider);
+        prefSchema = testContainer.get(PreferenceSchemaService);
         prefService = testContainer.get<PreferenceService>(PreferenceService) as PreferenceServiceImpl;
         getProvider(PreferenceScope.User).markReady();
         getProvider(PreferenceScope.Workspace).markReady();
@@ -100,24 +100,25 @@ describe('Preference Proxy', () => {
                 promisedSchema?: Promise<PreferenceSchema>
             } {
                 const s: PreferenceSchema = schema || {
+                    scope: PreferenceScope.Folder,
                     properties: {
                         'my.pref': {
                             type: 'string',
-                            defaultValue: 'foo'
+                            default: 'foo'
                         }
                     }
                 };
                 if (testOptions.asyncSchema) {
                     const promisedSchema = new Promise<PreferenceSchema>(resolve => setTimeout(() => {
-                        prefSchema.setSchema(s);
+                        prefSchema.addSchema(s);
                         resolve(s);
-                    }, 1000));
+                    }, 500));
                     const proxy = testOptions.useFactory
                         ? testContainer.get<PreferenceProxyFactory>(PreferenceProxyFactory)(promisedSchema, options)
                         : createPreferenceProxy(prefService, promisedSchema, options);
                     return { proxy, promisedSchema };
                 } else {
-                    prefSchema.setSchema(s);
+                    prefSchema.addSchema(s);
                     const proxy = testOptions.useFactory
                         ? testContainer.get<PreferenceProxyFactory>(PreferenceProxyFactory)(s, options)
                         : createPreferenceProxy(prefService, s, options);
@@ -141,6 +142,7 @@ describe('Preference Proxy', () => {
                     expect(Object.keys(proxy).length).to.equal(0);
                     // Once the schema is resolved, operations should be working:
                     await promisedSchema!;
+                    changed = 0;
                     expect(proxy['my.pref']).to.equal('bar');
                     expect(Object.keys(proxy)).members(['my.pref']);
                     await getProvider(PreferenceScope.User).setPreference('my.pref', 'fizz');
@@ -185,6 +187,7 @@ describe('Preference Proxy', () => {
                 if (promisedSchema) {
                     await promisedSchema;
                 }
+                await waitForEvent(prefService.onPreferenceChanged, 500);
                 let theChange: PreferenceChangeEvent<{ [key: string]: any }>;
                 proxy.onPreferenceChanged(change => {
                     expect(theChange).to.equal(undefined);
@@ -208,10 +211,11 @@ describe('Preference Proxy', () => {
 
             it("should not forward changes that don't match the proxy's language override", async () => {
                 const { proxy, promisedSchema } = getProxy({
+                    scope: PreferenceScope.User,
                     properties: {
                         'my.pref': {
                             type: 'string',
-                            defaultValue: 'foo',
+                            default: 'foo',
                             overridable: true,
                         }
                     }
@@ -222,7 +226,8 @@ describe('Preference Proxy', () => {
                 prefSchema.registerOverrideIdentifier('swift');
                 prefSchema.registerOverrideIdentifier('typescript');
                 // The service will emit events related to updating the overrides - those are irrelevant
-                await waitForEvent(prefService.onPreferencesChanged, 500);
+                await waitForEvent(prefService.onPreferenceChanged, 500);
+
                 prefService.onPreferencesChanged(() => changeEventsEmittedByService++);
                 proxy.onPreferenceChanged(() => changeEventsEmittedByProxy++);
                 await prefService.set(prefService.overridePreferenceName({ overrideIdentifier: 'swift', preferenceName: 'my.pref' }), 'boo', PreferenceScope.User);
@@ -241,10 +246,11 @@ describe('Preference Proxy', () => {
 
             it('`affects` should only return `true` if the language overrides match', async () => {
                 const { proxy, promisedSchema } = getProxy({
+                    scope: PreferenceScope.User,
                     properties: {
                         'my.pref': {
                             type: 'string',
-                            defaultValue: 'foo',
+                            default: 'foo',
                             overridable: true,
                         }
                     }
@@ -268,6 +274,7 @@ describe('Preference Proxy', () => {
 
             it('toJSON with deep', async () => {
                 const { proxy, promisedSchema } = getProxy({
+                    scope: PreferenceScope.Default,
                     properties: {
                         'foo.baz': {
                             type: 'number',
@@ -290,7 +297,9 @@ describe('Preference Proxy', () => {
                 if (promisedSchema) {
                     await promisedSchema;
                 }
-                assert.deepStrictEqual(JSON.stringify(proxy, undefined, 2), JSON.stringify({
+
+                const result = JSON.stringify(proxy, undefined, 2);
+                assert.equal(result, JSON.stringify({
                     foo: {
                         baz: 4,
                         bar: {
@@ -304,6 +313,7 @@ describe('Preference Proxy', () => {
 
             it('get nested default', async () => {
                 const { proxy, promisedSchema } = getProxy({
+                    scope: PreferenceScope.Default,
                     properties: {
                         'foo': {
                             'anyOf': [

package/src/browser/preferences/preference-schema-provider.spec.ts

@@ -21,8 +21,9 @@ let disableJSDOM = enableJSDOM();
 import * as assert from 'assert';
 import { Container } from 'inversify';
 import { bindPreferenceService } from '../frontend-application-bindings';
-import { PreferenceSchemaProperties, PreferenceSchemaProvider } from './preference-contribution';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+import { IndexedAccess, PreferenceDataProperty, PreferenceSchemaService } from '../../common/preferences/preference-schema';
+import { PreferenceProvider, PreferenceProviderProvider, PreferenceScope } from '../../common/preferences';
 
 disableJSDOM();
 
@@ -40,14 +41,14 @@ function createTestContainer(): Container {
     return result;
 }
 
-const EDITOR_FONT_SIZE_PROPERTIES: PreferenceSchemaProperties = {
+const EDITOR_FONT_SIZE_PROPERTIES: IndexedAccess<PreferenceDataProperty> = {
     'editor.fontSize': {
         type: 'number',
         default: 14,
         overridable: true
     },
 };
-const EDITOR_INSERT_SPACES_PROPERTIES: PreferenceSchemaProperties = {
+const EDITOR_INSERT_SPACES_PROPERTIES: IndexedAccess<PreferenceDataProperty> = {
     'editor.insertSpaces': {
         type: 'boolean',
         default: true,
@@ -56,7 +57,8 @@ const EDITOR_INSERT_SPACES_PROPERTIES: PreferenceSchemaProperties = {
 };
 
 describe('Preference Schema Provider', () => {
-    let prefSchema: PreferenceSchemaProvider;
+    let prefSchema: PreferenceSchemaService;
+    let prefDefaults: PreferenceProvider;
 
     before(() => {
         disableJSDOM = enableJSDOM();
@@ -74,57 +76,43 @@ describe('Preference Schema Provider', () => {
 
     beforeEach(async () => {
         testContainer = createTestContainer();
-        prefSchema = testContainer.get(PreferenceSchemaProvider);
+        prefSchema = testContainer.get(PreferenceSchemaService);
+        await prefSchema.ready;
+        prefSchema.registerOverrideIdentifier('typescript');
+        const providerProvider: PreferenceProviderProvider = testContainer.get(PreferenceProviderProvider);
+        prefDefaults = providerProvider(PreferenceScope.Default)!;
+        await prefDefaults.ready;
     });
 
     it('Should load all preferences specified in the frontend config.', () => {
-        assert.strictEqual(prefSchema.get('editor.fontSize'), 20);
-        assert.strictEqual(prefSchema.get('[typescript].editor.fontSize'), 24);
+        assert.strictEqual(prefDefaults.get('editor.fontSize'), 20);
+        assert.strictEqual(prefDefaults.get('[typescript].editor.fontSize'), 24);
     });
 
     it('Should favor the default specified in the package.json over a default registered by a schema', () => {
-        prefSchema.setSchema({
+        prefSchema.addSchema({
+            scope: PreferenceScope.User,
             properties: {
                 ...EDITOR_FONT_SIZE_PROPERTIES
             }
         });
 
-        assert.strictEqual(prefSchema.get('editor.fontSize'), 20);
+        assert.strictEqual(prefDefaults.get('editor.fontSize'), 20);
     });
 
     it('Should merge language-specific overrides from schemas and the package.json', () => {
-        prefSchema.setSchema({
+        prefSchema.addSchema({
             properties: {
                 ...EDITOR_FONT_SIZE_PROPERTIES,
                 ...EDITOR_INSERT_SPACES_PROPERTIES,
-                '[typescript]': {
-                    type: 'object',
-                    default: {
-                        'editor.insertSpaces': false
-                    }
-                }
-            }
+            },
+            scope: PreferenceScope.Default
         });
-        assert.strictEqual(prefSchema.get('editor.insertSpaces'), true);
-        assert.strictEqual(prefSchema.get('[typescript].editor.insertSpaces'), false);
-        assert.strictEqual(prefSchema.get('[typescript].editor.fontSize'), 24);
-    });
 
-    it('Should favor package.json specifications in the merge process', () => {
-        prefSchema.setSchema({
-            properties: {
-                ...EDITOR_FONT_SIZE_PROPERTIES,
-                ...EDITOR_INSERT_SPACES_PROPERTIES,
-                '[typescript]': {
-                    type: 'object',
-                    default: {
-                        'editor.insertSpaces': false,
-                        'editor.fontSize': 36,
-                    }
-                }
-            }
-        });
-        assert.strictEqual(prefSchema.get('[typescript].editor.insertSpaces'), false);
-        assert.strictEqual(prefSchema.get('[typescript].editor.fontSize'), 24);
+        prefSchema.registerOverride('editor.insertSpaces', 'typescript', false);
+
+        assert.strictEqual(prefDefaults.get('editor.insertSpaces'), true);
+        assert.strictEqual(prefDefaults.get('[typescript].editor.insertSpaces'), false);
+        assert.strictEqual(prefDefaults.get('[typescript].editor.fontSize'), 24);
     });
 });

package/src/browser/preferences/preference-service.spec.ts

@@ -22,14 +22,12 @@ let disableJSDOM = enableJSDOM();
 
 import * as assert from 'assert';
 import { Container } from 'inversify';
-import { bindPreferenceService } from '../frontend-application-bindings';
-import { bindMockPreferenceProviders, MockPreferenceProvider } from './test';
-import { PreferenceService, PreferenceServiceImpl, PreferenceChange, PreferenceChanges } from './preference-service';
-import { PreferenceSchemaProvider, PreferenceSchema } from './preference-contribution';
-import { PreferenceScope } from './preference-scope';
-import { PreferenceProvider } from './preference-provider';
+import { PreferenceChange, PreferenceChanges, PreferenceProvider, PreferenceScope, PreferenceService, PreferenceServiceImpl } from '../../common/preferences';
+import { PreferenceSchema, PreferenceSchemaService } from '../../common/preferences/preference-schema';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
-import { createPreferenceProxy, PreferenceChangeEvent } from './preference-proxy';
+import { bindMockPreferenceProviders, MockPreferenceProvider } from './test';
+import { PreferenceChangeEvent, createPreferenceProxy } from '../../common/preferences/preference-proxy';
+import { bindPreferenceService } from '../frontend-application-bindings';
 
 disableJSDOM();
 
@@ -50,7 +48,7 @@ function createTestContainer(): Container {
 
 describe('Preference Service', () => {
     let prefService: PreferenceServiceImpl;
-    let prefSchema: PreferenceSchemaProvider;
+    let prefSchema: PreferenceSchemaService;
 
     before(() => {
         disableJSDOM = enableJSDOM();
@@ -63,7 +61,7 @@ describe('Preference Service', () => {
 
     beforeEach(async () => {
         testContainer = createTestContainer();
-        prefSchema = testContainer.get(PreferenceSchemaProvider);
+        prefSchema = testContainer.get(PreferenceSchemaService);
         prefService = testContainer.get<PreferenceService>(PreferenceService) as PreferenceServiceImpl;
         getProvider(PreferenceScope.User).markReady();
         getProvider(PreferenceScope.Workspace).markReady();
@@ -85,11 +83,11 @@ describe('Preference Service', () => {
     }
 
     it('should return the preference from the more specific scope (user > workspace)', () => {
-        prefSchema.setSchema({
+        prefSchema.addSchema({
+            scope: PreferenceScope.Folder,
             properties: {
                 'test.number': {
                     type: 'number',
-                    scope: 'resource'
                 }
             }
         });
@@ -109,14 +107,14 @@ describe('Preference Service', () => {
     });
 
     it('should throw a TypeError if the preference (reference object) is modified', () => {
-        prefSchema.setSchema({
+        prefSchema.addSchema({
+            scope: PreferenceScope.Folder,
             properties: {
                 'test.immutable': {
                     type: 'array',
                     items: {
                         type: 'string'
                     },
-                    scope: 'resource'
                 }
             }
         });
@@ -132,11 +130,11 @@ describe('Preference Service', () => {
     });
 
     it('should still report the more specific preference even though the less specific one changed', () => {
-        prefSchema.setSchema({
+        prefSchema.addSchema({
+            scope: PreferenceScope.Folder,
             properties: {
                 'test.number': {
                     type: 'number',
-                    scope: 'resource'
                 }
             }
         });
@@ -155,21 +153,18 @@ describe('Preference Service', () => {
         prefService.onPreferenceChanged(event => events.push(event));
         prefSchema.registerOverrideIdentifier('go');
 
-        const toUnset = prefSchema.setSchema({
+        const toUnset = prefSchema.addSchema({
+            scope: PreferenceScope.User,
             properties: {
                 'editor.insertSpaces': {
                     type: 'boolean',
                     default: true,
                     overridable: true
-                },
-                '[go]': {
-                    type: 'object',
-                    default: {
-                        'editor.insertSpaces': false
-                    }
                 }
             }
         });
+
+        prefSchema.registerOverride('editor.insertSpaces', 'go', false);
         assert.deepStrictEqual([], events.map(e => ({
             preferenceName: e.preferenceName,
             newValue: e.newValue,
@@ -185,8 +180,8 @@ describe('Preference Service', () => {
             newValue: e.newValue,
             oldValue: e.oldValue
         })), 'events after unset in the same tick');
-        assert.strictEqual(prefService.get('editor.insertSpaces'), undefined, 'get after');
-        assert.strictEqual(prefService.get('[go].editor.insertSpaces'), undefined, 'get after overridden');
+        assert.strictEqual(prefService.get('editor.insertSpaces'), undefined, 'get after'); // removing the schema does not removes the default value
+        assert.strictEqual(prefService.get('[go].editor.insertSpaces'), false, 'get after overridden'); // but not the override
 
         assert.deepStrictEqual([], events.map(e => ({
             preferenceName: e.preferenceName,
@@ -199,21 +194,17 @@ describe('Preference Service', () => {
         prefSchema.registerOverrideIdentifier('go');
 
         let pending = new Promise<PreferenceChanges>(resolve => prefService.onPreferencesChanged(resolve));
-        const toUnset = prefSchema.setSchema({
+        const toUnset = prefSchema.addSchema({
+            scope: PreferenceScope.User,
             properties: {
                 'editor.insertSpaces': {
                     type: 'boolean',
                     default: true,
                     overridable: true
-                },
-                '[go]': {
-                    type: 'object',
-                    default: {
-                        'editor.insertSpaces': false
-                    }
                 }
             }
         });
+        prefSchema.registerOverride('editor.insertSpaces', 'go', false);
         let changes = await pending;
 
         assert.deepStrictEqual([{
@@ -248,20 +239,21 @@ describe('Preference Service', () => {
             return { preferenceName, newValue, oldValue };
         }), 'events after');
         assert.strictEqual(prefService.get('editor.insertSpaces'), undefined, 'get after');
-        assert.strictEqual(prefService.get('[go].editor.insertSpaces'), undefined, 'get after overridden');
+        assert.strictEqual(prefService.get('[go].editor.insertSpaces'), false, 'get after overridden');
     });
 
     function prepareServices(options?: { schema: PreferenceSchema }): {
         preferences: PreferenceServiceImpl;
-        schema: PreferenceSchemaProvider;
+        schema: PreferenceSchemaService;
     } {
-        prefSchema.setSchema(options && options.schema || {
+        prefSchema.addSchema(options && options.schema || {
+            scope: PreferenceScope.User,
             properties: {
                 'editor.tabSize': {
                     type: 'number',
+                    default: 4,
                     description: '',
                     overridable: true,
-                    default: 4
                 }
             }
         });
@@ -355,15 +347,10 @@ describe('Preference Service', () => {
     describe('overridden preferences', () => {
 
         it('get #0', () => {
-            const { preferences, schema } = prepareServices();
+            const { preferences } = prepareServices();
 
             preferences.set('[json].editor.tabSize', 2, PreferenceScope.User);
 
-            expect(preferences.get('editor.tabSize')).to.equal(4);
-            expect(preferences.get('[json].editor.tabSize')).to.equal(undefined);
-
-            schema.registerOverrideIdentifier('json');
-
             expect(preferences.get('editor.tabSize')).to.equal(4);
             expect(preferences.get('[json].editor.tabSize')).to.equal(2);
         });
@@ -532,7 +519,7 @@ describe('Preference Service', () => {
             await preferences.set('editor.tabSize', 3, PreferenceScope.User);
 
             const events: PreferenceChangeEvent<{ [key: string]: any }>[] = [];
-            const proxy = createPreferenceProxy<{ [key: string]: any }>(preferences, schema.getCombinedSchema(), { overrideIdentifier: 'json' });
+            const proxy = createPreferenceProxy<{ [key: string]: any }>(preferences, schema.getJSONSchema(PreferenceScope.Folder), { overrideIdentifier: 'json' });
             proxy.onPreferenceChanged(event => events.push(event));
 
             await preferences.set('[javascript].editor.tabSize', 4, PreferenceScope.User);
@@ -567,6 +554,7 @@ describe('Preference Service', () => {
         it('defaultOverrides [go].editor.formatOnSave', () => {
             const { preferences, schema } = prepareServices({
                 schema: {
+                    scope: PreferenceScope.Folder,
                     properties: {
                         'editor.insertSpaces': {
                             type: 'boolean',
@@ -588,20 +576,8 @@ describe('Preference Service', () => {
             assert.strictEqual(undefined, preferences.get('[go].editor.formatOnSave'));
 
             schema.registerOverrideIdentifier('go');
-            schema.setSchema({
-                id: 'defaultOverrides',
-                title: 'Default Configuration Overrides',
-                properties: {
-                    '[go]': {
-                        type: 'object',
-                        default: {
-                            'editor.insertSpaces': false,
-                            'editor.formatOnSave': true
-                        },
-                        description: 'Configure editor settings to be overridden for go language.'
-                    }
-                }
-            });
+            prefSchema.registerOverride('editor.insertSpaces', 'go', false);
+            prefSchema.registerOverride('editor.formatOnSave', 'go', true);
 
             assert.strictEqual(true, preferences.get('editor.insertSpaces'));
             assert.strictEqual(false, preferences.get('[go].editor.insertSpaces'));

package/src/browser/preferences/preference-validation-service.spec.ts

@@ -16,20 +16,28 @@
 
 import { Container } from 'inversify';
 import { PreferenceValidationService } from './preference-validation-service';
-import { PreferenceItem, PreferenceSchemaProvider } from './preference-contribution';
-import { PreferenceLanguageOverrideService } from './preference-language-override-service';
 import * as assert from 'assert';
 import { JSONValue } from '@lumino/coreutils';
 import { IJSONSchema, JsonType } from '../../common/json-schema';
+import {
+    DefaultsPreferenceProvider, Disposable, PreferenceDataProperty, PreferenceProvider,
+    PreferenceSchemaService, PreferenceSchemaServiceImpl, PreferenceScope
+} from '../../common';
+import { PreferenceLanguageOverrideService } from '../../common/preferences/preference-language-override-service';
 
 /* eslint-disable no-null/no-null */
 
 describe('Preference Validation Service', () => {
     const container = new Container();
-    container.bind(PreferenceSchemaProvider).toConstantValue({ getDefaultValue: PreferenceSchemaProvider.prototype.getDefaultValue } as PreferenceSchemaProvider);
-    container.bind(PreferenceLanguageOverrideService).toSelf().inSingletonScope();
+    container.bind(PreferenceSchemaService).toConstantValue({
+        getDefaultValue: PreferenceSchemaServiceImpl.prototype.getDefaultValue,
+        onDidChangeDefaultValue: () => Disposable.NULL
+    } as unknown as PreferenceSchemaService);
+    container.bind(PreferenceLanguageOverrideService).to(PreferenceLanguageOverrideService).inSingletonScope();
+    container.bind(PreferenceProvider).to(DefaultsPreferenceProvider).inSingletonScope().whenTargetNamed(PreferenceScope.Default);
+
     const validator = container.resolve(PreferenceValidationService);
-    const validateBySchema: (value: JSONValue, schema: PreferenceItem) => JSONValue = validator.validateBySchema.bind(validator, 'dummy');
+    const validateBySchema: (value: JSONValue, schema: PreferenceDataProperty) => JSONValue = validator.validateBySchema.bind(validator, 'dummy');
 
     describe('should validate strings', () => {
         const expected = 'expected';
@@ -137,7 +145,7 @@ describe('Preference Validation Service', () => {
             assert.strictEqual(actual, expected);
         });
         it('bad value -> should return default value', () => {
-            const actual = validateBySchema('not-in-enum', { enum: options, defaultValue });
+            const actual = validateBySchema('not-in-enum', { enum: options, default: defaultValue });
             assert.strictEqual(actual, defaultValue);
         });
         it('bad value -> should return first value if no default or bad default', () => {
@@ -155,29 +163,29 @@ describe('Preference Validation Service', () => {
             assert.deepStrictEqual(validateBySchema(3, schema), {});
         });
         it('should reject objects that are missing required fields', () => {
-            const schema: PreferenceItem = { type: 'object', properties: { 'required': { type: 'string' }, 'not-required': { type: 'number' } }, required: ['required'] };
+            const schema: PreferenceDataProperty = { type: 'object', properties: { 'required': { type: 'string' }, 'not-required': { type: 'number' } }, required: ['required'] };
             assert.deepStrictEqual(validateBySchema({ 'not-required': 3 }, schema), {});
             const defaultValue = { required: 'present' };
-            assert.deepStrictEqual(validateBySchema({ 'not-required': 3 }, { ...schema, defaultValue }), defaultValue);
+            assert.deepStrictEqual(validateBySchema({ 'not-required': 3 }, { ...schema, default: defaultValue }), defaultValue);
         });
         it('should reject objects that have impermissible extra properties', () => {
-            const schema: PreferenceItem = { type: 'object', properties: { 'required': { type: 'string' } }, additionalProperties: false };
+            const schema: PreferenceDataProperty = { type: 'object', properties: { 'required': { type: 'string' } }, additionalProperties: false };
             assert.deepStrictEqual(validateBySchema({ 'required': 'hello', 'not-required': 3 }, schema), {});
         });
         it('should accept objects with extra properties if extra properties are not forbidden', () => {
             const input = { 'required': 'hello', 'not-forbidden': 3 };
-            const schema: PreferenceItem = { type: 'object', properties: { 'required': { type: 'string' } }, additionalProperties: true };
+            const schema: PreferenceDataProperty = { type: 'object', properties: { 'required': { type: 'string' } }, additionalProperties: true };
             assert.deepStrictEqual(validateBySchema(input, schema), input);
             assert.deepStrictEqual(validateBySchema(input, { ...schema, additionalProperties: undefined }), input);
         });
         it("should reject objects with properties that violate the property's rules", () => {
             const input = { required: 'not-a-number!' };
-            const schema: PreferenceItem = { type: 'object', properties: { required: { type: 'number' } } };
+            const schema: PreferenceDataProperty = { type: 'object', properties: { required: { type: 'number' } } };
             assert.deepStrictEqual(validateBySchema(input, schema), {});
         });
         it('should reject objects with extra properties that violate the extra property rules', () => {
             const input = { required: 3, 'not-required': 'not-a-number!' };
-            const schema: PreferenceItem = { type: 'object', properties: { required: { type: 'number' } }, additionalProperties: { type: 'number' } };
+            const schema: PreferenceDataProperty = { type: 'object', properties: { required: { type: 'number' } }, additionalProperties: { type: 'number' } };
             assert.deepStrictEqual(validateBySchema(input, schema), {});
         });
     });
@@ -196,7 +204,7 @@ describe('Preference Validation Service', () => {
         });
     });
     describe('should validate tuples', () => {
-        const schema: PreferenceItem & { items: IJSONSchema[] } = {
+        const schema: PreferenceDataProperty & { items: IJSONSchema[] } = {
             'type': 'array',
             'items': [{
                 'type': 'number',
@@ -218,7 +226,7 @@ describe('Preference Validation Service', () => {
             assert.strictEqual(validateBySchema([2, ['second fails']], withDefault), defaultValue);
         });
         it('bad input -> in the absence of a default, it should return any good values or the default for each subschema', () => {
-            const withSubDefault: PreferenceItem = { ...schema, items: [{ type: 'string', default: 'cool' }, ...schema.items] };
+            const withSubDefault: PreferenceDataProperty = { ...schema, items: [{ type: 'string', default: 'cool' }, ...schema.items] };
             assert.deepStrictEqual(validateBySchema('not an array', withSubDefault), ['cool', 0, '']);
             assert.deepStrictEqual(validateBySchema([2, 8, null], withSubDefault), ['cool', 8, '']);
         });
@@ -252,7 +260,7 @@ describe('Preference Validation Service', () => {
         });
     });
     describe('should validate anyOfs', () => {
-        const schema: PreferenceItem = { anyOf: [{ type: 'number', minimum: 1 }, { type: 'array', items: { type: 'string' } }], default: 5 };
+        const schema: PreferenceDataProperty = { anyOf: [{ type: 'number', minimum: 1 }, { type: 'array', items: { type: 'string' } }], default: 5 };
         it('good input -> returns same value', () => {
             assert.strictEqual(validateBySchema(3, schema), 3);
             const goodArray = ['a string', 'here too'];
@@ -268,7 +276,7 @@ describe('Preference Validation Service', () => {
     });
     describe('should validate oneOfs', () => {
         // Between 4 and 6 should be rejected
-        const schema: PreferenceItem = { oneOf: [{ type: 'number', minimum: 1, maximum: 6 }, { type: 'number', minimum: 4, maximum: 10 }], default: 8 };
+        const schema: PreferenceDataProperty = { oneOf: [{ type: 'number', minimum: 1, maximum: 6 }, { type: 'number', minimum: 4, maximum: 10 }], default: 8 };
         it('good input -> returns same value', () => {
             assert.strictEqual(validateBySchema(2, schema), 2);
             assert.strictEqual(validateBySchema(7, schema), 7);
@@ -281,7 +289,7 @@ describe('Preference Validation Service', () => {
         });
     });
     describe('should validate consts', () => {
-        const schema: PreferenceItem = { const: { 'the only': 'possible value' }, default: 'ignore-the-default' };
+        const schema: PreferenceDataProperty = { const: { 'the only': 'possible value' }, default: 'ignore-the-default' };
         const goodValue = { 'the only': 'possible value' };
         it('good input -> returns same value', () => {
             assert.strictEqual(validateBySchema(goodValue, schema), goodValue);
@@ -292,7 +300,7 @@ describe('Preference Validation Service', () => {
         });
     });
     describe('should maintain triple equality for valid object types', () => {
-        const arraySchema: PreferenceItem = { type: 'array', items: { type: 'string' } };
+        const arraySchema: PreferenceDataProperty = { type: 'array', items: { type: 'string' } };
         it('maintains triple equality for arrays', () => {
             const input = ['one-string', 'two-string'];
             assert(validateBySchema(input, arraySchema) === input);
@@ -302,7 +310,7 @@ describe('Preference Validation Service', () => {
             assert.notStrictEqual(validateBySchema(input, arraySchema), input);
         });
         it('maintains triple equality for objects', () => {
-            const schema: PreferenceItem = {
+            const schema: PreferenceDataProperty = {
                 'type': 'object',
                 properties: {
                     primitive: { type: 'string' },