feat(@angular-devkit/core): auto discover multiselect schema prompt types

If a prompt is present on a schema property and the type is an array with a set of enum values, then the prompt type is a list with multiselect capabilites.  This eliminates the need to specify the longhand form for typical multiselect prompts.

Author: clydin

etc/api/angular_devkit/core/src/_golden-api.d.ts

@@ -798,7 +798,7 @@ export interface PromptDefinition {
     multiselect?: boolean;
     raw?: string | JsonObject;
     type: string;
-    validator?: (value: string) => boolean | string | Promise<boolean | string>;
+    validator?: (value: JsonValue) => boolean | string | Promise<boolean | string>;
 }
 
 export declare type PromptProvider = (definitions: Array<PromptDefinition>) => SubscribableOrPromise<{

packages/angular_devkit/core/src/json/schema/interface.ts

@@ -100,7 +100,7 @@ export interface PromptDefinition {
   type: string;
   message: string;
   default?: string | string[] | number | boolean | null;
-  validator?: (value: string) => boolean | string | Promise<boolean | string>;
+  validator?: (value: JsonValue) => boolean | string | Promise<boolean | string>;
 
   items?: Array<string | { value: JsonValue, label: string }>;
 

packages/angular_devkit/core/src/json/schema/prompt_spec.ts

@@ -262,7 +262,7 @@ describe('Prompt Provider', () => {
         .toPromise().then(done, done.fail);
     });
 
-    it('analyzes list with multiselect option and object items', done => {
+    it('analyzes list with true multiselect option and object items', done => {
       const registry = new CoreSchemaRegistry();
       const data: any = {};
 
@@ -301,14 +301,53 @@ describe('Prompt Provider', () => {
         .toPromise().then(done, done.fail);
     });
 
+    it('analyzes list with false multiselect option and object items', done => {
+      const registry = new CoreSchemaRegistry();
+      const data: any = {};
+
+      registry.usePromptProvider(async definitions => {
+        expect(definitions.length).toBe(1);
+        expect(definitions[0].type).toBe('list');
+        expect(definitions[0].multiselect).toBe(false);
+        expect(definitions[0].items).toEqual([
+          { 'value': 'one', 'label': 'one' },
+          { 'value': 'two', 'label': 'two' },
+        ]);
+
+        return { [definitions[0].id]: { 'value': 'one', 'label': 'one' } };
+      });
+
+      registry
+        .compile({
+          properties: {
+            test: {
+              type: 'array',
+              'x-prompt': {
+                'type': 'list',
+                'multiselect': false,
+                'items': [
+                  { 'value': 'one', 'label': 'one' },
+                  { 'value': 'two', 'label': 'two' },
+                ],
+                'message': 'test-message',
+              },
+            },
+          },
+        })
+        .pipe(
+          mergeMap(validator => validator(data)),
+        )
+        .toPromise().then(done, done.fail);
+    });
+
     it('analyzes list without multiselect option and object items', done => {
       const registry = new CoreSchemaRegistry();
       const data: any = {};
 
       registry.usePromptProvider(async definitions => {
         expect(definitions.length).toBe(1);
         expect(definitions[0].type).toBe('list');
-        expect(definitions[0].multiselect).toBeUndefined();
+        expect(definitions[0].multiselect).toBe(true);
         expect(definitions[0].items).toEqual([
           { 'value': 'one', 'label': 'one' },
           { 'value': 'two', 'label': 'two' },
@@ -346,6 +385,7 @@ describe('Prompt Provider', () => {
       registry.usePromptProvider(async definitions => {
         expect(definitions.length).toBe(1);
         expect(definitions[0].type).toBe('list');
+        expect(definitions[0].multiselect).toBeFalsy();
         expect(definitions[0].items).toEqual([
           'one',
           'two',
@@ -377,6 +417,45 @@ describe('Prompt Provider', () => {
         .toPromise().then(done, done.fail);
     });
 
+    it('analyzes enums WITHOUT explicit list type and multiselect', done => {
+      const registry = new CoreSchemaRegistry();
+      const data: any = {};
+
+      registry.usePromptProvider(async definitions => {
+        expect(definitions.length).toBe(1);
+        expect(definitions[0].type).toBe('list');
+        expect(definitions[0].multiselect).toBe(true);
+        expect(definitions[0].items).toEqual([
+          'one',
+          'two',
+          'three',
+        ]);
+
+        return {};
+      });
+
+      registry
+        .compile({
+          properties: {
+            test: {
+              type: 'array',
+              items: {
+                enum: [
+                  'one',
+                  'two',
+                  'three',
+                ],
+              },
+              'x-prompt': 'test-message',
+            },
+          },
+        })
+        .pipe(
+          mergeMap(validator => validator(data)),
+        )
+        .toPromise().then(done, done.fail);
+    });
+
     it('analyzes boolean properties', done => {
       const registry = new CoreSchemaRegistry();
       const data: any = {};

packages/angular_devkit/core/src/json/schema/registry.ts

@@ -28,6 +28,7 @@ import {
   SmartDefaultProvider,
 } from './interface';
 import { JsonSchema } from './schema';
+import { getTypesOfSchema } from './utility';
 import { visitJson, visitJsonSchema } from './visitor';
 
 // This interface should be exported from ajv, but they only export the class and not the type.
@@ -539,26 +540,44 @@ export class CoreSchemaRegistry implements SchemaRegistry {
           items = schema.items;
         }
 
+        const propertyTypes = getTypesOfSchema(parentSchema);
         if (!type) {
-          if (parentSchema.type === 'boolean') {
+          if (propertyTypes.size === 1 && propertyTypes.has('boolean')) {
             type = 'confirmation';
           } else if (Array.isArray(parentSchema.enum)) {
             type = 'list';
+          } else if (
+            propertyTypes.size === 1 &&
+            propertyTypes.has('array') &&
+            parentSchema.items &&
+            Array.isArray((parentSchema.items as JsonObject).enum)
+          ) {
+            type = 'list';
           } else {
             type = 'input';
           }
         }
 
-        if (type === 'list' && !items && Array.isArray(parentSchema.enum)) {
-          type = 'list';
-          items = [];
-          for (const value of parentSchema.enum) {
-            if (typeof value == 'string') {
-              items.push(value);
-            } else if (typeof value == 'object') {
-              // Invalid
-            } else {
-              items.push({ label: value.toString(), value });
+        let multiselect;
+        if (type === 'list') {
+          multiselect =
+            schema.multiselect === undefined
+              ? propertyTypes.size === 1 && propertyTypes.has('array')
+              : schema.multiselect;
+
+          const enumValues = multiselect
+            ? parentSchema.items && (parentSchema.items as JsonObject).enum
+            : parentSchema.enum;
+          if (!items && Array.isArray(enumValues)) {
+            items = [];
+            for (const value of enumValues) {
+              if (typeof value == 'string') {
+                items.push(value);
+              } else if (typeof value == 'object') {
+                // Invalid
+              } else {
+                items.push({ label: value.toString(), value });
+              }
             }
           }
         }
@@ -569,20 +588,13 @@ export class CoreSchemaRegistry implements SchemaRegistry {
           message,
           raw: schema,
           items,
-          multiselect: type === 'list' ? schema.multiselect : false,
+          multiselect,
           default: typeof parentSchema.default == 'object' ? undefined : parentSchema.default,
-          async validator(data: string) {
-            const result = it.self.validate(parentSchema, data);
-            if (typeof result === 'boolean') {
-              return result;
-            } else {
-              try {
-                await result;
-
-                return true;
-              } catch {
-                return false;
-              }
+          async validator(data: JsonValue) {
+            try {
+              return await it.self.validate(parentSchema, data);
+            } catch {
+              return false;
             }
           },
         };