@jsonforms/core 3.0.0-alpha.3 → 3.0.0-beta.2

package/src/generators/uischema.ts

@@ -35,7 +35,7 @@ import {
   Layout,
   UISchemaElement
 } from '../models';
-import { deriveTypes, resolveSchema } from '../util';
+import { deriveTypes, encode, resolveSchema } from '../util';
 
 /**
  * Creates a new ILayout.
@@ -122,7 +122,7 @@ const generateUISchema = (
 ): UISchemaElement => {
   if (!isEmpty(jsonSchema) && jsonSchema.$ref !== undefined) {
     return generateUISchema(
-      resolveSchema(rootSchema, jsonSchema.$ref),
+      resolveSchema(rootSchema, jsonSchema.$ref, rootSchema),
       schemaElements,
       currentRef,
       schemaName,
@@ -162,9 +162,9 @@ const generateUISchema = (
       const nextRef: string = currentRef + '/properties';
       Object.keys(jsonSchema.properties).map(propName => {
         let value = jsonSchema.properties[propName];
-        const ref = `${nextRef}/${propName}`;
+        const ref = `${nextRef}/${encode(propName)}`;
         if (value.$ref !== undefined) {
-          value = resolveSchema(rootSchema, value.$ref);
+          value = resolveSchema(rootSchema, value.$ref, rootSchema);
         }
         generateUISchema(
           value,

package/src/reducers/reducers.ts

@@ -32,9 +32,9 @@ import {
 import { defaultDataReducer } from './default-data';
 import { rendererReducer } from './renderers';
 import { JsonFormsState } from '../store';
+import type { JsonFormsUISchemaRegistryEntry } from './uischemas';
 import {
   findMatchingUISchema,
-  JsonFormsUISchemaRegistryEntry,
   uischemaRegistryReducer,
 } from './uischemas';
 import {
@@ -59,7 +59,7 @@ export const jsonFormsReducerConfig = {
   config: configReducer,
   uischemas: uischemaRegistryReducer,
   defaultData: defaultDataReducer,
-  i18n: i18nReducer
+  i18n: i18nReducer,
 };
 
 /**
@@ -67,7 +67,7 @@ export const jsonFormsReducerConfig = {
  * @param schema the JSON schema describing the data to be rendered
  * @param schemaPath the according schema path
  * @param path the instance path
- * @param fallbackLayoutType the type of the layout to use
+ * @param fallback the type of the layout to use or a UI-schema-generator function
  * @param control may be checked for embedded inline uischema options
  */
 export const findUISchema = (
@@ -75,7 +75,7 @@ export const findUISchema = (
   schema: JsonSchema,
   schemaPath: string,
   path: string,
-  fallbackLayoutType = 'VerticalLayout',
+  fallback: string | (() => UISchemaElement) = 'VerticalLayout',
   control?: ControlElement,
   rootSchema?: JsonSchema
 ): UISchemaElement => {
@@ -83,8 +83,12 @@ export const findUISchema = (
   if (control && control.options && control.options.detail) {
     if (typeof control.options.detail === 'string') {
       if (control.options.detail.toUpperCase() === 'GENERATE') {
+        //use fallback generation function
+        if(typeof fallback === "function"){
+          return fallback();
+        }
         // force generation of uischema
-        return Generate.uiSchema(schema, fallbackLayoutType);
+        return Generate.uiSchema(schema, fallback);
       }
     } else if (typeof control.options.detail === 'object') {
       // check if detail is a valid uischema
@@ -99,7 +103,11 @@ export const findUISchema = (
   // default
   const uiSchema = findMatchingUISchema(uischemas)(schema, schemaPath, path);
   if (uiSchema === undefined) {
-    return Generate.uiSchema(schema, fallbackLayoutType, '#', rootSchema);
+    //use fallback generation function
+    if(typeof fallback === 'function'){
+      return fallback();
+    }
+    return Generate.uiSchema(schema, fallback, '#', rootSchema);
   }
   return uiSchema;
 };

package/src/testers/testers.ts

@@ -47,15 +47,17 @@ import { deriveTypes, hasType, resolveSchema } from '../util';
 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) => boolean;
+export type Tester = (uischema: UISchemaElement, schema: JsonSchema, rootSchema: JsonSchema) => boolean;
 
 /**
  * A ranked tester associates a tester with a number.
  */
 export type RankedTester = (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ) => number;
 
 export const isControl = (uischema: any): uischema is ControlElement =>
@@ -72,8 +74,8 @@ export const isControl = (uischema: any): uischema is ControlElement =>
  *        applied to the resolved sub-schema
  */
 export const schemaMatches = (
-  predicate: (schema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema): boolean => {
+  predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
+): Tester => (uischema: UISchemaElement, schema: JsonSchema, rootSchema: JsonSchema): boolean => {
   if (isEmpty(uischema) || !isControl(uischema)) {
     return false;
   }
@@ -86,26 +88,26 @@ export const schemaMatches = (
   }
   let currentDataSchema = schema;
   if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath);
+    currentDataSchema = resolveSchema(schema, schemaPath, rootSchema);
   }
   if (currentDataSchema === undefined) {
     return false;
   }
 
-  return predicate(currentDataSchema);
+  return predicate(currentDataSchema, rootSchema);
 };
 
 export const schemaSubPathMatches = (
   subPath: string,
-  predicate: (schema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema): boolean => {
+  predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
+): Tester => (uischema: UISchemaElement, schema: JsonSchema, rootSchema: JsonSchema): boolean => {
   if (isEmpty(uischema) || !isControl(uischema)) {
     return false;
   }
   const schemaPath = uischema.scope;
   let currentDataSchema: JsonSchema = schema;
   if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath);
+    currentDataSchema = resolveSchema(schema, schemaPath, rootSchema);
   }
   currentDataSchema = get(currentDataSchema, subPath);
 
@@ -113,7 +115,7 @@ export const schemaSubPathMatches = (
     return false;
   }
 
-  return predicate(currentDataSchema);
+  return predicate(currentDataSchema, rootSchema);
 };
 
 /**
@@ -215,8 +217,9 @@ export const scopeEndIs = (expected: string): Tester => (
  */
 export const and = (...testers: Tester[]): Tester => (
   uischema: UISchemaElement,
-  schema: JsonSchema
-) => testers.reduce((acc, tester) => acc && tester(uischema, schema), true);
+  schema: JsonSchema,
+  rootSchema: JsonSchema
+) => testers.reduce((acc, tester) => acc && tester(uischema, schema, rootSchema), true);
 
 /**
  * A tester that allow composing other testers by || them.
@@ -225,8 +228,9 @@ export const and = (...testers: Tester[]): Tester => (
  */
 export const or = (...testers: Tester[]): Tester => (
   uischema: UISchemaElement,
-  schema: JsonSchema
-) => testers.reduce((acc, tester) => acc || tester(uischema, schema), false);
+  schema: JsonSchema,
+  rootSchema: JsonSchema
+) => testers.reduce((acc, tester) => acc || tester(uischema, schema, rootSchema), false);
 /**
  * Create a ranked tester that will associate a number with a given tester, if the
  * latter returns true.
@@ -236,9 +240,10 @@ export const or = (...testers: Tester[]): Tester => (
  */
 export const rankWith = (rank: number, tester: Tester) => (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ): number => {
-  if (tester(uischema, schema)) {
+  if (tester(uischema, schema, rootSchema)) {
     return rank;
   }
 
@@ -247,9 +252,10 @@ export const rankWith = (rank: number, tester: Tester) => (
 
 export const withIncreasedRank = (by: number, rankedTester: RankedTester) => (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ): number => {
-  const rank = rankedTester(uischema, schema);
+  const rank = rankedTester(uischema, schema, rootSchema);
   if (rank === NOT_APPLICABLE) {
     return NOT_APPLICABLE;
   }
@@ -380,9 +386,12 @@ export const isDateTimeControl = and(
  */
 export const isObjectArray = and(
   schemaMatches(
-    schema => hasType(schema, 'array') && !Array.isArray(schema.items) // 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 => hasType(schema, 'object'))
+  schemaSubPathMatches('items', (schema, rootSchema) => {
+    const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
+    return hasType(resolvedSchema, 'object')
+  })
 );
 
 /**
@@ -394,22 +403,31 @@ export const isObjectArrayControl = and(uiTypeIs('Control'), isObjectArray);
 
 const traverse = (
   any: JsonSchema | JsonSchema[],
-  pred: (obj: JsonSchema) => boolean
+  pred: (obj: JsonSchema) => boolean,
+  rootSchema: JsonSchema
 ): boolean => {
   if (isArray(any)) {
-    return reduce(any, (acc, el) => acc || traverse(el, pred), false);
+    return reduce(any, (acc, el) => acc || traverse(el, pred, rootSchema), false);
   }
 
   if (pred(any)) {
     return true;
   }
+
+  if (any.$ref) {
+    const toTraverse = resolveSchema(rootSchema, any.$ref, rootSchema);
+    if (toTraverse && !toTraverse.$ref) {
+      return traverse(toTraverse, pred, rootSchema);
+    }
+  }
+
   if (any.items) {
-    return traverse(any.items, pred);
+    return traverse(any.items, pred, rootSchema);
   }
   if (any.properties) {
     return reduce(
       toPairs(any.properties),
-      (acc, [_key, val]) => acc || traverse(val, pred),
+      (acc, [_key, val]) => acc || traverse(val, pred, rootSchema),
       false
     );
   }
@@ -419,13 +437,14 @@ const traverse = (
 
 export const isObjectArrayWithNesting = (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ): boolean => {
-  if (!uiTypeIs('Control')(uischema, schema)) {
+  if (!uiTypeIs('Control')(uischema, schema, rootSchema)) {
     return false;
   }
   const schemaPath = (uischema as ControlElement).scope;
-  const resolvedSchema = resolveSchema(schema, schemaPath);
+  const resolvedSchema = resolveSchema(schema, schemaPath, rootSchema ?? schema);
   const wantedNestingByType: { [key: string]: number } = {
     object: 2,
     array: 1
@@ -437,6 +456,9 @@ export const isObjectArrayWithNesting = (
         if (val === schema) {
           return false;
         }
+        if (val.$ref !== undefined) {
+          return false;
+        }
         // we don't support multiple types
         if (typeof val.type !== 'string') {
           return true;
@@ -447,7 +469,7 @@ export const isObjectArrayWithNesting = (
         }
         wantedNestingByType[val.type] = typeCount - 1;
         return wantedNestingByType[val.type] === 0;
-      })
+      }, rootSchema)
     ) {
       return true;
     }
@@ -479,10 +501,13 @@ export const isArrayObjectControl = isObjectArrayControl;
 export const isPrimitiveArrayControl = and(
   uiTypeIs('Control'),
   schemaMatches(
-    schema => deriveTypes(schema).length !== 0 && !Array.isArray(schema.items) // we don't care about tuples
+    (schema, rootSchema) =>
+      deriveTypes(schema).length !== 0 &&
+      !Array.isArray(resolveSchema(schema, 'items', rootSchema)) // we don't care about tuples
   ),
-  schemaSubPathMatches('items', schema => {
-    const types = deriveTypes(schema);
+  schemaSubPathMatches('items', (schema, rootSchema) => {
+    const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
+    const types = deriveTypes(resolvedSchema);
     return (
       types.length === 1 &&
       includes(['integer', 'number', 'boolean', 'string'], types[0])
@@ -543,5 +568,7 @@ export const categorizationHasCategory = (uischema: UISchemaElement) =>
 
 export const not = (tester: Tester): Tester => (
   uischema: UISchemaElement,
-  schema: JsonSchema
-) => !tester(uischema, schema);
+  schema: JsonSchema,
+  rootSchema: JsonSchema
+
+) => !tester(uischema, schema, rootSchema);

package/src/util/cell.ts

@@ -25,14 +25,14 @@
 
 import isEmpty from 'lodash/isEmpty';
 import union from 'lodash/union';
+import type { JsonFormsCellRendererRegistryEntry } from '../reducers';
 import {
+  getAjv,
   getConfig,
   getData,
   getErrorAt,
   getSchema,
-  getAjv,
-  JsonFormsCellRendererRegistryEntry,
-  getTranslator
+  getTranslator,
 } from '../reducers';
 import { AnyAction, Dispatch } from './type';
 import {
@@ -57,7 +57,7 @@ import { JsonFormsState } from '../store';
 import { JsonSchema } from '../models';
 import { getI18nKeyPrefix } from '../i18n';
 
-export { JsonFormsCellRendererRegistryEntry };
+export type { JsonFormsCellRendererRegistryEntry };
 
 export interface OwnPropsOfCell extends OwnPropsOfControl {
   data?: any;

package/src/util/combinators.ts

@@ -24,8 +24,8 @@
 */
 
 import { ControlElement, JsonSchema, UISchemaElement } from '../models';
-import { resolveSchema } from './resolvers';
 import { findUISchema, JsonFormsUISchemaRegistryEntry } from '../reducers';
+import { Resolve } from './util';
 
 export interface CombinatorSubSchemaRenderInfo {
   schema: JsonSchema;
@@ -47,24 +47,6 @@ const createLabel = (
   }
 };
 
-export const resolveSubSchemas = (
-  schema: JsonSchema,
-  rootSchema: JsonSchema,
-  keyword: CombinatorKeyword
-) => {
-  // resolve any $refs, otherwise the generated UI schema can't match the schema???
-  const schemas = schema[keyword] as any[];
-  if (schemas.findIndex(e => e.$ref !== undefined) !== -1) {
-    return {
-      ...schema,
-      [keyword]: (schema[keyword] as any[]).map(e =>
-        e.$ref ? resolveSchema(rootSchema, e.$ref) : e
-      )
-    };
-  }
-  return schema;
-};
-
 export const createCombinatorRenderInfos = (
   combinatorSubSchemas: JsonSchema[],
   rootSchema: JsonSchema,
@@ -73,16 +55,19 @@ export const createCombinatorRenderInfos = (
   path: string,
   uischemas: JsonFormsUISchemaRegistryEntry[]
 ): CombinatorSubSchemaRenderInfo[] =>
-  combinatorSubSchemas.map((subSchema, subSchemaIndex) => ({
-    schema: subSchema,
-    uischema: findUISchema(
-      uischemas,
-      subSchema,
-      control.scope,
-      path,
-      undefined,
-      control,
-      rootSchema
-    ),
-    label: createLabel(subSchema, subSchemaIndex, keyword)
-  }));
+  combinatorSubSchemas.map((subSchema, subSchemaIndex) => {
+    const schema = subSchema.$ref ? Resolve.schema(rootSchema, subSchema.$ref, rootSchema) : subSchema;
+    return {
+      schema,
+      uischema: findUISchema(
+        uischemas,
+        schema,
+        control.scope,
+        path,
+        undefined,
+        control,
+        rootSchema
+      ),
+      label: createLabel(subSchema, subSchemaIndex, keyword)
+    }
+  });

package/src/util/label.ts

@@ -26,6 +26,7 @@
 import startCase from 'lodash/startCase';
 
 import { ControlElement, JsonSchema, LabelDescription } from '../models';
+import { decode } from './path';
 
 const deriveLabel = (
   controlElement: ControlElement,
@@ -36,8 +37,7 @@ const deriveLabel = (
   }
   if (typeof controlElement.scope === 'string') {
     const ref = controlElement.scope;
-    const label = ref.substr(ref.lastIndexOf('/') + 1);
-
+    const label = decode(ref.substr(ref.lastIndexOf('/') + 1));
     return startCase(label);
   }
 

package/src/util/path.ts

@@ -57,14 +57,15 @@ export { compose as composePaths };
  */
 export const toDataPathSegments = (schemaPath: string): string[] => {
   const s = schemaPath
-    .replace(/anyOf\/[\d]\//g, '')
-    .replace(/allOf\/[\d]\//g, '')
-    .replace(/oneOf\/[\d]\//g, '');
+    .replace(/(anyOf|allOf|oneOf)\/[\d]\//g, '')
+    .replace(/(then|else)\//g, '');
   const segments = s.split('/');
 
-  const startFromRoot = segments[0] === '#' || segments[0] === '';
+  const decodedSegments = segments.map(decode);
+
+  const startFromRoot = decodedSegments[0] === '#' || decodedSegments[0] === '';
   const startIndex = startFromRoot ? 2 : 1;
-  return range(startIndex, segments.length, 2).map(idx => segments[idx]);
+  return range(startIndex, decodedSegments.length, 2).map(idx => decodedSegments[idx]);
 };
 
 /**
@@ -77,7 +78,7 @@ export const toDataPathSegments = (schemaPath: string): string[] => {
  */
 export const toDataPath = (schemaPath: string): string => {
   return toDataPathSegments(schemaPath).join('.');
-};
+    };
 
 export const composeWithUi = (scopableUi: Scopable, path: string): string => {
   const segments = toDataPathSegments(scopableUi.scope);
@@ -88,3 +89,14 @@ export const composeWithUi = (scopableUi: Scopable, path: string): string => {
 
   return isEmpty(segments) ? path : compose(path, segments.join('.'));
 };
+
+/**
+ * Encodes the given segment to be used as part of a JSON Pointer
+ * 
+ * JSON Pointer has special meaning for "/" and "~", therefore these must be encoded
+ */
+export const encode = (segment: string) => segment?.replace(/~/g, '~0').replace(/\//g, '~1');
+/**
+ * Decodes a given JSON Pointer segment to its "normal" representation
+ */
+export const decode = (pointerSegment: string) => pointerSegment?.replace(/~1/g, '/').replace(/~0/, '~');

package/src/util/renderer.ts

@@ -26,6 +26,11 @@
 import get from 'lodash/get';
 import { ControlElement, JsonSchema, UISchemaElement } from '../models';
 import find from 'lodash/find';
+import {
+  getUISchemas,
+  JsonFormsCellRendererRegistryEntry,
+  JsonFormsRendererRegistryEntry,
+} from '../reducers';
 import {
   findUISchema,
   getAjv,
@@ -39,19 +44,16 @@ import {
   getSubErrorsAt,
   getTranslator,
   getUiSchema,
-  JsonFormsCellRendererRegistryEntry,
-  JsonFormsRendererRegistryEntry,
   JsonFormsUISchemaRegistryEntry,
 } from '../reducers';
 import { RankedTester } from '../testers';
-import { isInherentlyEnabled, hasShowRule } from './runtime';
+import { hasShowRule, isInherentlyEnabled, isVisible } from './runtime';
 import { createLabelDescriptionFrom } from './label';
-import { CombinatorKeyword, resolveSubSchemas } from './combinators';
+import { CombinatorKeyword } from './combinators';
 import { moveDown, moveUp } from './array';
 import { AnyAction, Dispatch } from './type';
 import { Resolve } from './util';
 import { composePaths, composeWithUi } from './path';
-import { isVisible } from './runtime';
 import { CoreActions, update } from '../actions';
 import { ErrorObject } from 'ajv';
 import { JsonFormsState } from '../store';
@@ -64,6 +66,7 @@ const isRequired = (
 ): boolean => {
   const pathSegments = schemaPath.split('/');
   const lastSegment = pathSegments[pathSegments.length - 1];
+  // Skip "properties", "items" etc. to resolve the parent
   const nextHigherSchemaSegments = pathSegments.slice(
     0,
     pathSegments.length - 2
@@ -86,17 +89,17 @@ const isRequired = (
  * Adds an asterisk to the given label string based
  * on the required parameter.
  *
- * @param {string} label the label string
+ * @param {string | undefined} label the label string
  * @param {boolean} required whether the label belongs to a control which is required
  * @param {boolean} hideRequiredAsterisk applied UI Schema option
  * @returns {string} the label string
  */
 export const computeLabel = (
-  label: string,
+  label: string | undefined,
   required: boolean,
   hideRequiredAsterisk: boolean
 ): string => {
-  return required && !hideRequiredAsterisk ? label + '*' : label;
+  return `${label ?? ''}${ required && !hideRequiredAsterisk ? '*' : ''}`;
 };
 
 /**
@@ -154,7 +157,7 @@ export const createDefaultValue = (schema: JsonSchema) => {
  */
 export const isDescriptionHidden = (
   visible: boolean,
-  description: string,
+  description: string | undefined,
   isFocused: boolean,
   showUnfocusedDescription: boolean
 ): boolean => {
@@ -864,7 +867,8 @@ export const mapStateToLayoutProps = (
     data,
     uischema: ownProps.uischema,
     schema: ownProps.schema,
-    direction: ownProps.direction ?? getDirection(uischema)
+    direction: ownProps.direction ?? getDirection(uischema),
+    config
   };
 };
 
@@ -912,7 +916,7 @@ export const controlDefaultProps = {
   errors: [] as string[]
 };
 
-export interface StatePropsOfCombinator extends OwnPropsOfControl {
+export interface StatePropsOfCombinator extends StatePropsOfControl {
   rootSchema: JsonSchema;
   path: string;
   id: string;
@@ -926,25 +930,12 @@ export const mapStateToCombinatorRendererProps = (
   ownProps: OwnPropsOfControl,
   keyword: CombinatorKeyword
 ): StatePropsOfCombinator => {
-  const { uischema } = ownProps;
-  const path = composeWithUi(uischema, ownProps.path);
-  const rootSchema = getSchema(state);
-  const resolvedSchema = Resolve.schema(
-    ownProps.schema || rootSchema,
-    uischema.scope,
-    rootSchema
+  const { data, schema, ...props } = mapStateToControlProps(
+    state,
+    ownProps
   );
-  const visible: boolean =
-    ownProps.visible === undefined || hasShowRule(uischema)
-      ? isVisible(uischema, getData(state), ownProps.path, getAjv(state))
-      : ownProps.visible;
-  const id = ownProps.id;
-
-  const data = Resolve.data(getData(state), path);
 
   const ajv = state.jsonforms.core.ajv;
-  const schema = resolvedSchema || rootSchema;
-  const _schema = resolveSubSchemas(schema, rootSchema, keyword);
   const structuralKeywords = [
     'required',
     'additionalProperties',
@@ -963,9 +954,9 @@ export const mapStateToCombinatorRendererProps = (
   // TODO instead of compiling the combinator subschemas we can compile the original schema
   // without the combinator alternatives and then revalidate and check the errors for the
   // element
-  for (let i = 0; i < _schema[keyword].length; i++) {
+  for (let i = 0; i < schema[keyword]?.length; i++) {
     try {
-      const valFn = ajv.compile(_schema[keyword][i]);
+      const valFn = ajv.compile(schema[keyword][i]);
       valFn(data);
       if (dataIsValid(valFn.errors)) {
         indexOfFittingSchema = i;
@@ -978,14 +969,10 @@ export const mapStateToCombinatorRendererProps = (
 
   return {
     data,
-    path,
     schema,
-    rootSchema,
-    visible,
-    id,
+    ...props,
     indexOfFittingSchema,
-    uischemas: state.jsonforms.uischemas,
-    uischema
+    uischemas: getUISchemas(state)
   };
 };
 
@@ -1043,7 +1030,6 @@ export const mapStateToArrayLayoutProps = (
 
   const resolvedSchema = Resolve.schema(schema, 'items', props.rootSchema);
 
-  // TODO Does not consider a specialized '.custom' error message overriding all other error messages
   // TODO Does not consider 'i18n' keys which are specified in the ui schemas of the sub errors
   const childErrors = getCombinedErrorMessage(
     getSubErrorsAt(path, resolvedSchema)(state),