@jsonforms/core 3.1.0-alpha.0 → 3.1.0-alpha.2

package/src/reducers/selectors.ts

@@ -24,9 +24,9 @@
 */
 
 import get from 'lodash/get';
-import Ajv from 'ajv';
-import { JsonFormsState } from '../store';
-import { JsonSchema, UISchemaElement } from '../models';
+import type Ajv from 'ajv';
+import type { JsonFormsState } from '../store';
+import type { JsonSchema, UISchemaElement } from '../models';
 import {
   extractAjv,
   extractData,
@@ -35,11 +35,11 @@ import {
 } from './core';
 import {
   extractDefaultData,
-  JsonFormsDefaultDataRegistryEntry
+  JsonFormsDefaultDataRegistryEntry,
 } from './default-data';
-import { JsonFormsRendererRegistryEntry } from './renderers';
-import { JsonFormsCellRendererRegistryEntry } from './cells';
-import { JsonFormsUISchemaRegistryEntry } from './uischemas';
+import type { JsonFormsRendererRegistryEntry } from './renderers';
+import type { JsonFormsCellRendererRegistryEntry } from './cells';
+import type { JsonFormsUISchemaRegistryEntry } from './uischemas';
 
 export const getData = (state: JsonFormsState) =>
   extractData(get(state, 'jsonforms.core'));
@@ -47,9 +47,8 @@ export const getSchema = (state: JsonFormsState): JsonSchema =>
   extractSchema(get(state, 'jsonforms.core'));
 export const getUiSchema = (state: JsonFormsState): UISchemaElement =>
   extractUiSchema(get(state, 'jsonforms.core'));
-export const getAjv = (
-  state: JsonFormsState
-): Ajv => extractAjv(get(state, 'jsonforms.core'));
+export const getAjv = (state: JsonFormsState): Ajv =>
+  extractAjv(get(state, 'jsonforms.core'));
 export const getDefaultData = (
   state: JsonFormsState
 ): JsonFormsDefaultDataRegistryEntry[] =>
@@ -62,4 +61,4 @@ export const getCells = (
 ): JsonFormsCellRendererRegistryEntry[] => get(state, 'jsonforms.cells');
 export const getUISchemas = (
   state: JsonFormsState
-): JsonFormsUISchemaRegistryEntry[] => get(state, 'jsonforms.uischemas')
+): JsonFormsUISchemaRegistryEntry[] => get(state, 'jsonforms.uischemas');

package/src/reducers/uischemas.ts

@@ -27,8 +27,8 @@ import maxBy from 'lodash/maxBy';
 import remove from 'lodash/remove';
 import { ADD_UI_SCHEMA, REMOVE_UI_SCHEMA, UISchemaActions } from '../actions';
 import { NOT_APPLICABLE } from '../testers';
-import { JsonSchema, UISchemaElement } from '../models';
-import { Reducer } from '../util';
+import type { JsonSchema, UISchemaElement } from '../models';
+import type { Reducer } from '../util';
 
 export type UISchemaTester = (
   schema: JsonSchema,
@@ -41,39 +41,40 @@ export interface JsonFormsUISchemaRegistryEntry {
   uischema: UISchemaElement;
 }
 
-export const uischemaRegistryReducer: Reducer<JsonFormsUISchemaRegistryEntry[], UISchemaActions> = (
-  state = [],
-  action
-) => {
+export const uischemaRegistryReducer: Reducer<
+  JsonFormsUISchemaRegistryEntry[],
+  UISchemaActions
+> = (state = [], action) => {
   switch (action.type) {
     case ADD_UI_SCHEMA:
       return state
         .slice()
         .concat({ tester: action.tester, uischema: action.uischema });
-    case REMOVE_UI_SCHEMA:
+    case REMOVE_UI_SCHEMA: {
       const copy = state.slice();
-      remove(copy, entry => entry.tester === action.tester);
+      remove(copy, (entry) => entry.tester === action.tester);
       return copy;
+    }
     default:
       return state;
   }
 };
 
-export const findMatchingUISchema = (
-  state: JsonFormsUISchemaRegistryEntry[]
-) => (
-  jsonSchema: JsonSchema,
-  schemaPath: string,
-  path: string
-): UISchemaElement => {
-  const match = maxBy(state, entry =>
-    entry.tester(jsonSchema, schemaPath, path)
-  );
-  if (
-    match !== undefined &&
-    match.tester(jsonSchema, schemaPath, path) !== NOT_APPLICABLE
-  ) {
-    return match.uischema;
-  }
-  return undefined;
-};
+export const findMatchingUISchema =
+  (state: JsonFormsUISchemaRegistryEntry[]) =>
+  (
+    jsonSchema: JsonSchema,
+    schemaPath: string,
+    path: string
+  ): UISchemaElement => {
+    const match = maxBy(state, (entry) =>
+      entry.tester(jsonSchema, schemaPath, path)
+    );
+    if (
+      match !== undefined &&
+      match.tester(jsonSchema, schemaPath, path) !== NOT_APPLICABLE
+    ) {
+      return match.uischema;
+    }
+    return undefined;
+  };

package/src/store.ts

@@ -23,14 +23,14 @@
   THE SOFTWARE.
 */
 
-import { Store } from './util';
-import {
+import type { Store } from './util';
+import type {
   JsonFormsCore,
   JsonFormsCellRendererRegistryEntry,
   JsonFormsRendererRegistryEntry,
-  JsonFormsUISchemaRegistryEntry
+  JsonFormsUISchemaRegistryEntry,
 } from './reducers';
-import { JsonFormsI18nState } from './i18n';
+import type { JsonFormsI18nState } from './i18n';
 
 /**
  * JSONForms store.

package/src/testers/testers.ts

@@ -31,11 +31,11 @@ import isArray from 'lodash/isArray';
 import reduce from 'lodash/reduce';
 import toPairs from 'lodash/toPairs';
 import includes from 'lodash/includes';
-import {
+import type {
   Categorization,
   ControlElement,
   JsonSchema,
-  UISchemaElement
+  UISchemaElement,
 } from '../models';
 import { deriveTypes, hasType, resolveSchema } from '../util';
 
@@ -49,7 +49,11 @@ export const NOT_APPLICABLE = -1;
  * A tester is a function that receives an UI schema and a JSON schema and returns a boolean.
  * The rootSchema is handed over as context. Can be used to resolve references.
  */
-export type Tester = (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) => boolean;
+export type Tester = (
+  uischema: UISchemaElement,
+  schema: JsonSchema,
+  context: TesterContext
+) => boolean;
 
 /**
  * A ranked tester associates a tester with a number.
@@ -83,50 +87,70 @@ export const isControl = (uischema: any): uischema is ControlElement =>
  * @param {(JsonSchema) => boolean} predicate the predicate that should be
  *        applied to the resolved sub-schema
  */
-export const schemaMatches = (
-  predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext): boolean => {
-  if (isEmpty(uischema) || !isControl(uischema)) {
-    return false;
-  }
-  if (isEmpty(schema)) {
-    return false;
-  }
-  const schemaPath = uischema.scope;
-  if (isEmpty(schemaPath)) {
-    return false;
-  }
-  let currentDataSchema = schema;
-  if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath, context?.rootSchema);
-  }
-  if (currentDataSchema === undefined) {
-    return false;
-  }
-
-  return predicate(currentDataSchema, context?.rootSchema);
-};
+export const schemaMatches =
+  (
+    predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
+  ): Tester =>
+  (
+    uischema: UISchemaElement,
+    schema: JsonSchema,
+    context: TesterContext
+  ): boolean => {
+    if (isEmpty(uischema) || !isControl(uischema)) {
+      return false;
+    }
+    if (isEmpty(schema)) {
+      return false;
+    }
+    const schemaPath = uischema.scope;
+    if (isEmpty(schemaPath)) {
+      return false;
+    }
+    let currentDataSchema = schema;
+    if (hasType(schema, 'object')) {
+      currentDataSchema = resolveSchema(
+        schema,
+        schemaPath,
+        context?.rootSchema
+      );
+    }
+    if (currentDataSchema === undefined) {
+      return false;
+    }
 
-export const schemaSubPathMatches = (
-  subPath: string,
-  predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext): boolean => {
-  if (isEmpty(uischema) || !isControl(uischema)) {
-    return false;
-  }
-  const schemaPath = uischema.scope;
-  let currentDataSchema: JsonSchema = schema;
-  if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath, context?.rootSchema);
-  }
-  currentDataSchema = get(currentDataSchema, subPath);
+    return predicate(currentDataSchema, context?.rootSchema);
+  };
+
+export const schemaSubPathMatches =
+  (
+    subPath: string,
+    predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
+  ): Tester =>
+  (
+    uischema: UISchemaElement,
+    schema: JsonSchema,
+    context: TesterContext
+  ): boolean => {
+    if (isEmpty(uischema) || !isControl(uischema)) {
+      return false;
+    }
+    const schemaPath = uischema.scope;
+    let currentDataSchema: JsonSchema = schema;
+    if (hasType(schema, 'object')) {
+      currentDataSchema = resolveSchema(
+        schema,
+        schemaPath,
+        context?.rootSchema
+      );
+    }
+    currentDataSchema = get(currentDataSchema, subPath);
 
-  if (currentDataSchema === undefined) {
-    return false;
-  }
+    if (currentDataSchema === undefined) {
+      return false;
+    }
 
-  return predicate(currentDataSchema, context?.rootSchema);
-};
+    return predicate(currentDataSchema, context?.rootSchema);
+  };
 
 /**
  * Only applicable for Controls.
@@ -138,7 +162,7 @@ export const schemaSubPathMatches = (
  * @param {string} expectedType the expected type of the resolved sub-schema
  */
 export const schemaTypeIs = (expectedType: string): Tester =>
-  schemaMatches(schema => !isEmpty(schema) && hasType(schema, expectedType));
+  schemaMatches((schema) => !isEmpty(schema) && hasType(schema, expectedType));
 
 /**
  * Only applicable for Controls.
@@ -151,7 +175,7 @@ export const schemaTypeIs = (expectedType: string): Tester =>
  */
 export const formatIs = (expectedFormat: string): Tester =>
   schemaMatches(
-    schema =>
+    (schema) =>
       !isEmpty(schema) &&
       schema.format === expectedFormat &&
       hasType(schema, 'string')
@@ -162,9 +186,10 @@ export const formatIs = (expectedFormat: string): Tester =>
  *
  * @param {string} expected the expected UI schema type
  */
-export const uiTypeIs = (expected: string): Tester => (
-  uischema: UISchemaElement
-): boolean => !isEmpty(uischema) && uischema.type === expected;
+export const uiTypeIs =
+  (expected: string): Tester =>
+  (uischema: UISchemaElement): boolean =>
+    !isEmpty(uischema) && uischema.type === expected;
 
 /**
  * Checks whether the given UI schema has an option with the given
@@ -174,16 +199,16 @@ export const uiTypeIs = (expected: string): Tester => (
  * @param {string} optionName the name of the option to check
  * @param {any} optionValue the expected value of the option
  */
-export const optionIs = (optionName: string, optionValue: any): Tester => (
-  uischema: UISchemaElement
-): boolean => {
-  if (isEmpty(uischema)) {
-    return false;
-  }
+export const optionIs =
+  (optionName: string, optionValue: any): Tester =>
+  (uischema: UISchemaElement): boolean => {
+    if (isEmpty(uischema)) {
+      return false;
+    }
 
-  const options = uischema.options;
-  return !isEmpty(options) && options[optionName] === optionValue;
-};
+    const options = uischema.options;
+    return !isEmpty(options) && options[optionName] === optionValue;
+  };
 
 /**
  * Only applicable for Controls.
@@ -192,15 +217,15 @@ export const optionIs = (optionName: string, optionValue: any): Tester => (
  *
  * @param {string} expected the expected ending of the reference
  */
-export const scopeEndsWith = (expected: string): Tester => (
-  uischema: UISchemaElement
-): boolean => {
-  if (isEmpty(expected) || !isControl(uischema)) {
-    return false;
-  }
+export const scopeEndsWith =
+  (expected: string): Tester =>
+  (uischema: UISchemaElement): boolean => {
+    if (isEmpty(expected) || !isControl(uischema)) {
+      return false;
+    }
 
-  return endsWith(uischema.scope, expected);
-};
+    return endsWith(uischema.scope, expected);
+  };
 
 /**
  * Only applicable for Controls.
@@ -209,38 +234,42 @@ export const scopeEndsWith = (expected: string): Tester => (
  *
  * @param {string} expected the expected ending of the reference
  */
-export const scopeEndIs = (expected: string): Tester => (
-  uischema: UISchemaElement
-): boolean => {
-  if (isEmpty(expected) || !isControl(uischema)) {
-    return false;
-  }
-  const schemaPath = uischema.scope;
+export const scopeEndIs =
+  (expected: string): Tester =>
+  (uischema: UISchemaElement): boolean => {
+    if (isEmpty(expected) || !isControl(uischema)) {
+      return false;
+    }
+    const schemaPath = uischema.scope;
 
-  return !isEmpty(schemaPath) && last(schemaPath.split('/')) === expected;
-};
+    return !isEmpty(schemaPath) && last(schemaPath.split('/')) === expected;
+  };
 
 /**
  * A tester that allow composing other testers by && them.
  *
  * @param {Array<Tester>} testers the testers to be composed
  */
-export const and = (...testers: Tester[]): Tester => (
-  uischema: UISchemaElement,
-  schema: JsonSchema,
-  context: TesterContext
-) => testers.reduce((acc, tester) => acc && tester(uischema, schema, context), true);
+export const and =
+  (...testers: Tester[]): Tester =>
+  (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) =>
+    testers.reduce(
+      (acc, tester) => acc && tester(uischema, schema, context),
+      true
+    );
 
 /**
  * A tester that allow composing other testers by || them.
  *
  * @param {Array<Tester>} testers the testers to be composed
  */
-export const or = (...testers: Tester[]): Tester => (
-  uischema: UISchemaElement,
-  schema: JsonSchema,
-  context: TesterContext
-) => testers.reduce((acc, tester) => acc || tester(uischema, schema, context), false);
+export const or =
+  (...testers: Tester[]): Tester =>
+  (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) =>
+    testers.reduce(
+      (acc, tester) => acc || tester(uischema, schema, context),
+      false
+    );
 /**
  * Create a ranked tester that will associate a number with a given tester, if the
  * latter returns true.
@@ -248,30 +277,34 @@ export const or = (...testers: Tester[]): Tester => (
  * @param {number} rank the rank to be returned in case the tester returns true
  * @param {Tester} tester a tester
  */
-export const rankWith = (rank: number, tester: Tester) => (
-  uischema: UISchemaElement,
-  schema: JsonSchema,
-  context: TesterContext
-): number => {
-  if (tester(uischema, schema, context)) {
-    return rank;
-  }
-
-  return NOT_APPLICABLE;
-};
+export const rankWith =
+  (rank: number, tester: Tester) =>
+  (
+    uischema: UISchemaElement,
+    schema: JsonSchema,
+    context: TesterContext
+  ): number => {
+    if (tester(uischema, schema, context)) {
+      return rank;
+    }
 
-export const withIncreasedRank = (by: number, rankedTester: RankedTester) => (
-  uischema: UISchemaElement,
-  schema: JsonSchema,
-  context: TesterContext
-): number => {
-  const rank = rankedTester(uischema, schema, context);
-  if (rank === NOT_APPLICABLE) {
     return NOT_APPLICABLE;
-  }
+  };
+
+export const withIncreasedRank =
+  (by: number, rankedTester: RankedTester) =>
+  (
+    uischema: UISchemaElement,
+    schema: JsonSchema,
+    context: TesterContext
+  ): number => {
+    const rank = rankedTester(uischema, schema, context);
+    if (rank === NOT_APPLICABLE) {
+      return NOT_APPLICABLE;
+    }
 
-  return rank + by;
-};
+    return rank + by;
+  };
 
 /**
  * Default tester for boolean.
@@ -287,17 +320,17 @@ export const isObjectControl = and(uiTypeIs('Control'), schemaTypeIs('object'));
 
 export const isAllOfControl = and(
   uiTypeIs('Control'),
-  schemaMatches(schema => schema.hasOwnProperty('allOf'))
+  schemaMatches((schema) => schema.hasOwnProperty('allOf'))
 );
 
 export const isAnyOfControl = and(
   uiTypeIs('Control'),
-  schemaMatches(schema => schema.hasOwnProperty('anyOf'))
+  schemaMatches((schema) => schema.hasOwnProperty('anyOf'))
 );
 
 export const isOneOfControl = and(
   uiTypeIs('Control'),
-  schemaMatches(schema => schema.hasOwnProperty('oneOf'))
+  schemaMatches((schema) => schema.hasOwnProperty('oneOf'))
 );
 
 /**
@@ -308,8 +341,8 @@ export const isOneOfControl = and(
 export const isEnumControl = and(
   uiTypeIs('Control'),
   or(
-    schemaMatches(schema => schema.hasOwnProperty('enum')),
-    schemaMatches(schema => schema.hasOwnProperty('const'))
+    schemaMatches((schema) => schema.hasOwnProperty('enum')),
+    schemaMatches((schema) => schema.hasOwnProperty('const'))
   )
 );
 
@@ -320,9 +353,10 @@ export const isEnumControl = and(
  */
 export const isOneOfEnumControl = and(
   uiTypeIs('Control'),
-  schemaMatches(schema =>
-    schema.hasOwnProperty('oneOf') &&
-    (schema.oneOf as JsonSchema[]).every(s => s.const !== undefined)
+  schemaMatches(
+    (schema) =>
+      schema.hasOwnProperty('oneOf') &&
+      (schema.oneOf as JsonSchema[]).every((s) => s.const !== undefined)
   )
 );
 
@@ -396,11 +430,15 @@ export const isDateTimeControl = and(
  */
 export const isObjectArray = and(
   schemaMatches(
-    (schema, rootSchema) => hasType(schema, 'array') && !Array.isArray(resolveSchema(schema, 'items', rootSchema)) // we don't care about tuples
+    (schema, rootSchema) =>
+      hasType(schema, 'array') &&
+      !Array.isArray(resolveSchema(schema, 'items', rootSchema)) // we don't care about tuples
   ),
   schemaSubPathMatches('items', (schema, rootSchema) => {
-    const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
-    return hasType(resolvedSchema, 'object')
+    const resolvedSchema = schema.$ref
+      ? resolveSchema(rootSchema, schema.$ref, rootSchema)
+      : schema;
+    return hasType(resolvedSchema, 'object');
   })
 );
 
@@ -417,7 +455,11 @@ const traverse = (
   rootSchema: JsonSchema
 ): boolean => {
   if (isArray(any)) {
-    return reduce(any, (acc, el) => acc || traverse(el, pred, rootSchema), false);
+    return reduce(
+      any,
+      (acc, el) => acc || traverse(el, pred, rootSchema),
+      false
+    );
   }
 
   if (pred(any)) {
@@ -454,32 +496,43 @@ export const isObjectArrayWithNesting = (
     return false;
   }
   const schemaPath = (uischema as ControlElement).scope;
-  const resolvedSchema = resolveSchema(schema, schemaPath, context?.rootSchema ?? schema);
+  const resolvedSchema = resolveSchema(
+    schema,
+    schemaPath,
+    context?.rootSchema ?? schema
+  );
   let objectDepth = 0;
   if (resolvedSchema !== undefined && resolvedSchema.items !== undefined) {
     // check if nested arrays
     if (
-      traverse(resolvedSchema.items, val => {
-        if (val === schema) {
-          return false;
-        }
-        if (val.$ref !== undefined) {
-          return false;
-        }
-        if (val.anyOf || val.oneOf) {
-          return true;
-        }
-        if (hasType(val, 'object')) {
-          objectDepth++;
-          if (objectDepth === 2) {
+      traverse(
+        resolvedSchema.items,
+        (val) => {
+          if (val === schema) {
+            return false;
+          }
+          if (val.$ref !== undefined) {
+            return false;
+          }
+          if (val.anyOf || val.allOf) {
             return true;
           }
-        }
-        if (hasType(val, 'array')) {
-          return true;
-        }
-        return false;
-      }, context?.rootSchema)
+          if (val.oneOf && !isOneOfEnumControl(uischema, val, context)) {
+            return true;
+          }
+          if (hasType(val, 'object')) {
+            objectDepth++;
+            if (objectDepth === 2) {
+              return true;
+            }
+          }
+          if (hasType(val, 'array')) {
+            return true;
+          }
+          return false;
+        },
+        context?.rootSchema
+      )
     ) {
       return true;
     }
@@ -516,7 +569,9 @@ export const isPrimitiveArrayControl = and(
       !Array.isArray(resolveSchema(schema, 'items', rootSchema)) // we don't care about tuples
   ),
   schemaSubPathMatches('items', (schema, rootSchema) => {
-    const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
+    const resolvedSchema = schema.$ref
+      ? resolveSchema(rootSchema, schema.$ref, rootSchema)
+      : schema;
     const types = deriveTypes(resolvedSchema);
     return (
       types.length === 1 &&
@@ -535,7 +590,7 @@ export const isRangeControl = and(
   uiTypeIs('Control'),
   or(schemaTypeIs('number'), schemaTypeIs('integer')),
   schemaMatches(
-    schema =>
+    (schema) =>
       schema.hasOwnProperty('maximum') &&
       schema.hasOwnProperty('minimum') &&
       schema.hasOwnProperty('default')
@@ -567,7 +622,7 @@ export const hasCategory = (categorization: Categorization): boolean => {
   }
   // all children of the categorization have to be categories
   return categorization.elements
-    .map(elem =>
+    .map((elem) =>
       isCategorization(elem) ? hasCategory(elem) : isCategory(elem)
     )
     .reduce((prev, curr) => prev && curr, true);
@@ -576,9 +631,7 @@ export const hasCategory = (categorization: Categorization): boolean => {
 export const categorizationHasCategory = (uischema: UISchemaElement) =>
   hasCategory(uischema as Categorization);
 
-export const not = (tester: Tester): Tester => (
-  uischema: UISchemaElement,
-  schema: JsonSchema,
-  context: TesterContext
-
-) => !tester(uischema, schema, context);
+export const not =
+  (tester: Tester): Tester =>
+  (uischema: UISchemaElement, schema: JsonSchema, context: TesterContext) =>
+    !tester(uischema, schema, context);