@jsonforms/core 3.0.0-beta.2 → 3.0.0-beta.5

package/lib/models/uischema.d.ts

@@ -1,14 +1,42 @@
 import { JsonSchema } from './jsonSchema';
 /**
  * Interface for describing an UI schema element that is referencing
- * a subschema. The value of the scope must be a JSON Pointer.
+ * a subschema. The value of the scope may be a JSON Pointer.
  */
 export interface Scopable {
+    /**
+     * The scope that determines to which part this element should be bound to.
+     */
+    scope?: string;
+}
+/**
+ * Interface for describing an UI schema element that is referencing
+ * a subschema. The value of the scope must be a JSON Pointer.
+ */
+export interface Scoped extends Scopable {
     /**
      * The scope that determines to which part this element should be bound to.
      */
     scope: string;
 }
+/**
+ * Interface for describing an UI schema element that may be labeled.
+ */
+export interface Lableable<T = string> {
+    /**
+     * Label for UI schema element.
+     */
+    label?: string | T;
+}
+/**
+ * Interface for describing an UI schema element that is labeled.
+ */
+export interface Labeled<T = string> extends Lableable<T> {
+    label: string | T;
+}
+export interface Internationalizable {
+    i18n?: string;
+}
 /**
  * A rule that may be attached to any UI schema element.
  */
@@ -56,14 +84,14 @@ export interface Condition {
 /**
  * A leaf condition.
  */
-export interface LeafCondition extends Condition, Scopable {
+export interface LeafCondition extends Condition, Scoped {
     type: 'LEAF';
     /**
      * The expected value when evaluating the condition
      */
     expectedValue: any;
 }
-export interface SchemaBasedCondition extends Condition, Scopable {
+export interface SchemaBasedCondition extends Condition, Scoped {
     schema: JsonSchema;
 }
 /**
@@ -129,12 +157,8 @@ export interface HorizontalLayout extends Layout {
  * A group resembles a vertical layout, but additionally might have a label.
  * This layout is useful when grouping different elements by a certain criteria.
  */
-export interface GroupLayout extends Layout {
+export interface GroupLayout extends Layout, Lableable {
     type: 'Group';
-    /**
-     * The label of this group layout.
-     */
-    label?: string;
 }
 /**
  * Represents an object that can be used to configure a label.
@@ -163,39 +187,32 @@ export interface LabelElement extends UISchemaElement {
  * A control element. The scope property of the control determines
  * to which part of the schema the control should be bound.
  */
-export interface ControlElement extends UISchemaElement, Scopable {
+export interface ControlElement extends UISchemaElement, Scoped, Lableable<string | boolean | LabelDescription>, Internationalizable {
     type: 'Control';
-    /**
-     * An optional label that will be associated with the control
-     */
-    label?: string | boolean | LabelDescription;
 }
 /**
  * The category layout.
  */
-export interface Category extends Layout {
+export interface Category extends Layout, Labeled {
     type: 'Category';
-    /**
-     * The label associated with this category layout.
-     */
-    label: string;
 }
 /**
  * The categorization element, which may have children elements.
  * A child element may either be itself a Categorization or a Category, hence
  * the categorization element can be used to represent recursive structures like trees.
  */
-export interface Categorization extends UISchemaElement {
+export interface Categorization extends UISchemaElement, Labeled {
     type: 'Categorization';
-    /**
-     * The label of this categorization.
-     */
-    label: string;
     /**
      * The child elements of this categorization which are either of type
      * {@link Category} or {@link Categorization}.
      */
     elements: (Category | Categorization)[];
 }
+export declare const isInternationalized: (element: unknown) => element is Required<Internationalizable>;
 export declare const isGroup: (layout: Layout) => layout is GroupLayout;
 export declare const isLayout: (uischema: UISchemaElement) => uischema is Layout;
+export declare const isScopable: (obj: unknown) => obj is Scopable;
+export declare const isScoped: (obj: unknown) => obj is Scoped;
+export declare const isLabelable: (obj: unknown) => obj is Lableable<string>;
+export declare const isLabeled: (obj: unknown) => obj is Labeled<string>;

package/lib/reducers/core.d.ts

@@ -9,6 +9,7 @@ export interface JsonFormsCore {
     schema: JsonSchema;
     uischema: UISchemaElement;
     errors?: ErrorObject[];
+    additionalErrors?: ErrorObject[];
     validator?: ValidateFunction;
     ajv?: Ajv;
     validationMode?: ValidationMode;

package/lib/util/runtime.d.ts

@@ -1,7 +1,6 @@
-import { UISchemaElement } from '../models';
+import { JsonSchema, UISchemaElement } from '../models';
 import Ajv from 'ajv';
 import { JsonFormsState } from '../store';
-import { JsonSchema } from '../models/jsonSchema';
 export declare const evalVisibility: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
 export declare const evalEnablement: (uischema: UISchemaElement, data: any, path: string, ajv: Ajv) => boolean;
 export declare const hasShowRule: (uischema: UISchemaElement) => boolean;

package/lib/util/util.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchema, Scopable, UISchemaElement } from '..';
+import { JsonSchema, Scoped, UISchemaElement } from '..';
 import Ajv from 'ajv';
 /**
  * Escape the given string such that it can be used as a class name,
@@ -11,19 +11,19 @@ export declare const convertToValidClassName: (s: string) => string;
 export declare const formatErrorMessage: (errors: string[]) => string;
 export declare const hasType: (jsonSchema: JsonSchema, expected: string) => boolean;
 /**
-* Derives the type of the jsonSchema element
-*/
+ * Derives the type of the jsonSchema element
+ */
 export declare const deriveTypes: (jsonSchema: JsonSchema) => string[];
 /**
-* Convenience wrapper around resolveData and resolveSchema.
-*/
+ * Convenience wrapper around resolveData and resolveSchema.
+ */
 export declare const Resolve: {
     schema(schema: JsonSchema, schemaPath: string, rootSchema: JsonSchema): JsonSchema;
     data(data: any, path: string): any;
 };
 export declare const Paths: {
     compose: (path1: string, path2: string) => string;
-    fromScopable: (scopable: Scopable) => string;
+    fromScoped: (scopable: Scoped) => string;
 };
 export declare const Runtime: {
     isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonforms/core",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.5",
   "description": "Core module of JSON Forms",
   "repository": "https://github.com/eclipsesource/jsonforms",
   "bugs": "https://github.com/eclipsesource/jsonforms/issues",
@@ -88,5 +88,5 @@
     "typedoc": "^0.19.2",
     "typescript": "4.2.3"
   },
-  "gitHead": "8e9c14dcf049ee4b31baf9c40a86b394cba33139"
+  "gitHead": "b66023cf081e56baa3194ac3d6658e23fd267bf9"
 }

package/src/actions/actions.ts

@@ -100,6 +100,7 @@ export interface UpdateCoreAction {
 export interface InitActionOptions {
   ajv?: AJV;
   validationMode?: ValidationMode;
+  additionalErrors?: ErrorObject[];
 }
 
 export interface SetValidationModeAction {

package/src/i18n/i18nUtil.ts

@@ -1,5 +1,5 @@
 import { ErrorObject } from 'ajv';
-import { UISchemaElement } from '../models';
+import { isInternationalized, UISchemaElement } from '../models';
 import { getControlPath } from '../reducers';
 import { formatErrorMessage } from '../util';
 import { i18nJsonSchema, ErrorTranslator, Translator } from './i18nTypes';
@@ -8,7 +8,10 @@ export const getI18nKeyPrefixBySchema = (
   schema: i18nJsonSchema | undefined,
   uischema: UISchemaElement | undefined
 ): string | undefined => {
-  return uischema?.options?.i18n ?? schema?.i18n ?? undefined;
+  if (isInternationalized(uischema)) {
+    return uischema.i18n;
+  }
+  return schema?.i18n ?? undefined;
 };
 
 /**
@@ -54,26 +57,26 @@ export const defaultErrorTranslator: ErrorTranslator = (error, t, uischema) => {
     getControlPath(error),
     `error.${error.keyword}`
   );
-  const specializedKeywordMessage = t(i18nKey, undefined);
+  const specializedKeywordMessage = t(i18nKey, undefined, { error } );
   if (specializedKeywordMessage !== undefined) {
     return specializedKeywordMessage;
   }
 
   // check whether there is a generic keyword message
-  const genericKeywordMessage = t(`error.${error.keyword}`, undefined);
+  const genericKeywordMessage = t(`error.${error.keyword}`, undefined, { error });
   if (genericKeywordMessage !== undefined) {
     return genericKeywordMessage;
   }
 
   // check whether there is a customization for the default message
-  const messageCustomization = t(error.message, undefined);
+  const messageCustomization = t(error.message, undefined, { error });
   if (messageCustomization !== undefined) {
     return messageCustomization;
   }
 
   // rewrite required property messages (if they were not customized) as we place them next to the respective input
   if (error.keyword === 'required' && error.message?.startsWith('must have required property')) {
-    return t('is a required property', 'is a required property');
+    return t('is a required property', 'is a required property', { error });
   }
 
   return error.message;
@@ -94,7 +97,7 @@ export const getCombinedErrorMessage = (
   if (errors.length > 0 && t) {
     // check whether there is a special message which overwrites all others
     const customErrorKey = getI18nKey(schema, uischema, path, 'error.custom');
-    const specializedErrorMessage = t(customErrorKey, undefined);
+    const specializedErrorMessage = t(customErrorKey, undefined, {schema, uischema, path, errors});
     if (specializedErrorMessage !== undefined) {
       return specializedErrorMessage;
     }

package/src/models/uischema.ts

@@ -27,15 +27,52 @@ import { JsonSchema } from './jsonSchema';
 
 /**
  * Interface for describing an UI schema element that is referencing
- * a subschema. The value of the scope must be a JSON Pointer.
+ * a subschema. The value of the scope may be a JSON Pointer.
  */
 export interface Scopable {
+  /**
+   * The scope that determines to which part this element should be bound to.
+   */
+  scope?: string;
+}
+
+/**
+ * Interface for describing an UI schema element that is referencing
+ * a subschema. The value of the scope must be a JSON Pointer.
+ */
+export interface Scoped extends Scopable {
   /**
    * The scope that determines to which part this element should be bound to.
    */
   scope: string;
 }
 
+/**
+ * Interface for describing an UI schema element that may be labeled.
+ */
+export interface Lableable<T = string> {
+  /**
+   * Label for UI schema element.
+   */
+  label?: string|T;
+}
+
+/**
+ * Interface for describing an UI schema element that is labeled.
+ */
+export interface Labeled<T = string> extends Lableable<T> {
+  label: string | T;
+}
+
+/*
+ * Interface for describing an UI schema element that can provide an internationalization base key.
+ * If defined, this key is suffixed to derive applicable message keys for the UI schema element.
+ * For example, such suffixes are `.label` or `.description` to derive the corresponding message keys for a control element.
+ */
+export interface Internationalizable {
+  i18n?: string;
+}
+
 /**
  * A rule that may be attached to any UI schema element.
  */
@@ -87,7 +124,7 @@ export interface Condition {
 /**
  * A leaf condition.
  */
-export interface LeafCondition extends Condition, Scopable {
+export interface LeafCondition extends Condition, Scoped {
   type: 'LEAF';
 
   /**
@@ -96,7 +133,7 @@ export interface LeafCondition extends Condition, Scopable {
   expectedValue: any;
 }
 
-export interface SchemaBasedCondition extends Condition, Scopable {
+export interface SchemaBasedCondition extends Condition, Scoped {
   schema: JsonSchema;
 }
 
@@ -170,12 +207,8 @@ export interface HorizontalLayout extends Layout {
  * A group resembles a vertical layout, but additionally might have a label.
  * This layout is useful when grouping different elements by a certain criteria.
  */
-export interface GroupLayout extends Layout {
+export interface GroupLayout extends Layout, Lableable {
   type: 'Group';
-  /**
-   * The label of this group layout.
-   */
-  label?: string;
 }
 
 /**
@@ -207,23 +240,15 @@ export interface LabelElement extends UISchemaElement {
  * A control element. The scope property of the control determines
  * to which part of the schema the control should be bound.
  */
-export interface ControlElement extends UISchemaElement, Scopable {
+export interface ControlElement extends UISchemaElement, Scoped, Lableable<string | boolean | LabelDescription>, Internationalizable {
   type: 'Control';
-  /**
-   * An optional label that will be associated with the control
-   */
-  label?: string | boolean | LabelDescription;
 }
 
 /**
  * The category layout.
  */
-export interface Category extends Layout {
+export interface Category extends Layout, Labeled {
   type: 'Category';
-  /**
-   * The label associated with this category layout.
-   */
-  label: string;
 }
 
 /**
@@ -231,12 +256,8 @@ export interface Category extends Layout {
  * A child element may either be itself a Categorization or a Category, hence
  * the categorization element can be used to represent recursive structures like trees.
  */
-export interface Categorization extends UISchemaElement {
+export interface Categorization extends UISchemaElement, Labeled {
   type: 'Categorization';
-  /**
-   * The label of this categorization.
-   */
-  label: string;
   /**
    * The child elements of this categorization which are either of type
    * {@link Category} or {@link Categorization}.
@@ -244,8 +265,23 @@ export interface Categorization extends UISchemaElement {
   elements: (Category | Categorization)[];
 }
 
+export const isInternationalized = (element: unknown): element is Required<Internationalizable> =>
+  typeof element === 'object' && element !== null && typeof (element as Internationalizable).i18n === 'string';
+
 export const isGroup = (layout: Layout): layout is GroupLayout =>
   layout.type === 'Group';
 
 export const isLayout = (uischema: UISchemaElement): uischema is Layout =>
   (uischema as Layout).elements !== undefined;
+
+export const isScopable = (obj: unknown): obj is Scopable =>
+  obj && typeof obj === 'object';
+
+export const isScoped = (obj: unknown): obj is Scoped =>
+  isScopable(obj) && typeof obj.scope === 'string';
+
+export const isLabelable = (obj: unknown): obj is Lableable =>
+  obj && typeof obj === 'object';
+
+export const isLabeled = (obj: unknown): obj is Labeled =>
+  isLabelable(obj) && ['string', 'object'].includes(typeof obj.label);

package/src/reducers/core.ts

@@ -65,6 +65,7 @@ export interface JsonFormsCore {
   schema: JsonSchema;
   uischema: UISchemaElement;
   errors?: ErrorObject[];
+  additionalErrors?: ErrorObject[];
   validator?: ValidateFunction;
   ajv?: Ajv;
   validationMode?: ValidationMode;
@@ -78,6 +79,7 @@ const initState: JsonFormsCore = {
   validator: undefined,
   ajv: undefined,
   validationMode: 'ValidateAndShow',
+  additionalErrors: []
 };
 
 const reuseAjvForSchema = (ajv: Ajv, schema: JsonSchema): Ajv => {
@@ -133,6 +135,23 @@ const hasValidationModeOption = (option: any): option is InitActionOptions => {
   return false;
 };
 
+const hasAdditionalErrorsOption = (option: any): option is InitActionOptions => {
+  if (option) {
+    return option.additionalErrors !== undefined;
+  }
+  return false;
+};
+
+const getAdditionalErrors = (
+  state: JsonFormsCore,
+  action?: InitAction | UpdateCoreAction
+): ErrorObject[] => {
+  if (action && hasAdditionalErrorsOption(action.options)) {
+    return action.options.additionalErrors;
+  }
+  return state.additionalErrors;
+};
+
 // tslint:disable-next-line: cyclomatic-complexity
 export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
   state = initState,
@@ -145,12 +164,14 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
       const validationMode = getValidationMode(state, action);
       const v = validationMode === 'NoValidation' ? undefined : thisAjv.compile(action.schema);
       const e = validate(v, action.data);
+      const additionalErrors = getAdditionalErrors(state, action);
 
       return {
         ...state,
         data: action.data,
         schema: action.schema,
         uischema: action.uischema,
+        additionalErrors,
         errors: e,
         validator: v,
         ajv: thisAjv,
@@ -176,6 +197,7 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
       } else if (state.data !== action.data) {
         errors = validate(validator, action.data);
       }
+      const additionalErrors = getAdditionalErrors(state, action);
 
       const stateChanged =
         state.data !== action.data ||
@@ -184,7 +206,8 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
         state.ajv !== thisAjv ||
         state.errors !== errors ||
         state.validator !== validator ||
-        state.validationMode !== validationMode
+        state.validationMode !== validationMode ||
+        state.additionalErrors !== additionalErrors
       return stateChanged
         ? {
             ...state,
@@ -195,6 +218,7 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
             errors: isEqual(errors, state.errors) ? state.errors : errors,
             validator: validator,
             validationMode: validationMode,
+            additionalErrors
           }
         : state;
     }
@@ -391,8 +415,11 @@ const getErrorsAt = (
   instancePath: string,
   schema: JsonSchema,
   matchPath: (path: string) => boolean
-) => (state: JsonFormsCore): ErrorObject[] =>
-  errorsAt(instancePath, schema, matchPath)(state.validationMode === 'ValidateAndHide' ? [] : state.errors);
+) => (state: JsonFormsCore): ErrorObject[] => {
+  const errors = state.errors ?? [];
+  const additionalErrors = state.additionalErrors ?? [];
+  return errorsAt(instancePath, schema, matchPath)(state.validationMode === 'ValidateAndHide' ? additionalErrors : [...errors, ...additionalErrors]);
+}
 
 export const errorAt = (instancePath: string, schema: JsonSchema) =>
   getErrorsAt(instancePath, schema, path => path === instancePath);

package/src/testers/testers.ts

@@ -144,7 +144,7 @@ export const formatIs = (expectedFormat: string): Tester =>
     schema =>
       !isEmpty(schema) &&
       schema.format === expectedFormat &&
-      schema.type === 'string'
+      hasType(schema, 'string')
   );
 
 /**
@@ -445,10 +445,7 @@ export const isObjectArrayWithNesting = (
   }
   const schemaPath = (uischema as ControlElement).scope;
   const resolvedSchema = resolveSchema(schema, schemaPath, rootSchema ?? schema);
-  const wantedNestingByType: { [key: string]: number } = {
-    object: 2,
-    array: 1
-  };
+  let objectDepth = 0;
   if (resolvedSchema !== undefined && resolvedSchema.items !== undefined) {
     // check if nested arrays
     if (
@@ -459,16 +456,16 @@ export const isObjectArrayWithNesting = (
         if (val.$ref !== undefined) {
           return false;
         }
-        // we don't support multiple types
-        if (typeof val.type !== 'string') {
-          return true;
+        if (hasType(val, 'object')) {
+          objectDepth++;
+          if (objectDepth === 2) {
+            return true;
+          }
         }
-        const typeCount = wantedNestingByType[val.type];
-        if (typeCount === undefined) {
-          return false;
+        if (hasType(val, 'array')) {
+          return true;
         }
-        wantedNestingByType[val.type] = typeCount - 1;
-        return wantedNestingByType[val.type] === 0;
+        return false;
       }, rootSchema)
     ) {
       return true;

package/src/util/path.ts

@@ -25,7 +25,7 @@
 
 import isEmpty from 'lodash/isEmpty';
 import range from 'lodash/range';
-import { Scopable } from '../models';
+import { isScoped, Scopable } from '../models';
 
 export const compose = (path1: string, path2: string) => {
   let p1 = path1;
@@ -81,13 +81,17 @@ export const toDataPath = (schemaPath: string): string => {
     };
 
 export const composeWithUi = (scopableUi: Scopable, path: string): string => {
+  if (!isScoped(scopableUi)) {
+    return path ?? '';
+  }
+
   const segments = toDataPathSegments(scopableUi.scope);
 
-  if (isEmpty(segments) && path === undefined) {
-    return '';
+  if (isEmpty(segments)) {
+    return path ?? '';
   }
 
-  return isEmpty(segments) ? path : compose(path, segments.join('.'));
+  return compose(path, segments.join('.'));
 };
 
 /**
@@ -99,4 +103,4 @@ export const encode = (segment: string) => segment?.replace(/~/g, '~0').replace(
 /**
  * Decodes a given JSON Pointer segment to its "normal" representation
  */
-export const decode = (pointerSegment: string) => pointerSegment?.replace(/~1/g, '/').replace(/~0/, '~');
+export const decode = (pointerSegment: string) => pointerSegment?.replace(/~1/g, '/').replace(/~0/, '~');

package/src/util/renderer.ts

@@ -465,8 +465,8 @@ export const mapStateToControlProps = (
   const schema = resolvedSchema ?? rootSchema;
   const t = getTranslator()(state);
   const te = getErrorTranslator()(state);
-  const i18nLabel = t(getI18nKey(schema, uischema, path, 'label'), label);
-  const i18nDescription = t(getI18nKey(schema, uischema, path, 'description'), description);
+  const i18nLabel = t(getI18nKey(schema, uischema, path, 'label'), label, {schema, uischema, path, errors} );
+  const i18nDescription = t(getI18nKey(schema, uischema, path, 'description'), description, {schema, uischema, path, errors});
   const i18nErrorMessage = getCombinedErrorMessage(errors, te, t, schema, uischema, path);
 
   return {
@@ -894,7 +894,10 @@ export const mapStateToJsonFormsRendererProps = (
         state.jsonforms.uischemas,
         ownProps.schema,
         undefined,
-        ownProps.path
+        ownProps.path,
+        undefined,
+        undefined,
+        state.jsonforms.core.schema
       );
     } else {
       uischema = getUiSchema(state);

package/src/util/runtime.ts

@@ -27,6 +27,7 @@ import has from 'lodash/has';
 import {
   AndCondition,
   Condition,
+  JsonSchema,
   LeafCondition,
   OrCondition,
   RuleEffect,
@@ -39,7 +40,6 @@ import { composeWithUi } from './path';
 import Ajv from 'ajv';
 import { getAjv } from '../reducers';
 import { JsonFormsState } from '../store';
-import { JsonSchema } from '../models/jsonSchema';
 
 const isOrCondition = (condition: Condition): condition is OrCondition =>
   condition.type === 'OR';

package/src/util/util.ts

@@ -27,7 +27,7 @@ import isEmpty from 'lodash/isEmpty';
 import isArray from 'lodash/isArray';
 import includes from 'lodash/includes';
 import find from 'lodash/find';
-import { JsonSchema, Scopable, UISchemaElement } from '..';
+import { JsonSchema, Scoped, UISchemaElement } from '..';
 import { resolveData, resolveSchema } from './resolvers';
 import { composePaths, toDataPathSegments } from './path';
 import { isEnabled, isVisible } from './runtime';
@@ -56,8 +56,8 @@ export const hasType = (jsonSchema: JsonSchema, expected: string): boolean => {
 };
 
 /**
-* Derives the type of the jsonSchema element
-*/
+ * Derives the type of the jsonSchema element
+ */
 export const deriveTypes = (jsonSchema: JsonSchema): string[] => {
  if (isEmpty(jsonSchema)) {
    return [];
@@ -93,8 +93,8 @@ export const deriveTypes = (jsonSchema: JsonSchema): string[] => {
 };
 
 /**
-* Convenience wrapper around resolveData and resolveSchema.
-*/
+ * Convenience wrapper around resolveData and resolveSchema.
+ */
 export const Resolve: {
  schema(
    schema: JsonSchema,
@@ -108,18 +108,18 @@ export const Resolve: {
 };
 
 // Paths --
-const fromScopable = (scopable: Scopable) =>
+const fromScoped = (scopable: Scoped): string =>
  toDataPathSegments(scopable.scope).join('.');
 
 export const Paths = {
  compose: composePaths,
- fromScopable
+ fromScoped
 };
 
 // Runtime --
 export const Runtime = {
  isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean {
-   return isEnabled(uischema, data,undefined, ajv);
+   return isEnabled(uischema, data, undefined, ajv);
  },
  isVisible(uischema: UISchemaElement, data: any, ajv: Ajv): boolean {
    return isVisible(uischema, data, undefined, ajv);