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

package/src/i18n/i18nUtil.ts

@@ -3,6 +3,10 @@ import { isInternationalized, Labelable, UISchemaElement } from '../models';
 import { getControlPath } from '../reducers';
 import { formatErrorMessage } from '../util';
 import type { i18nJsonSchema, ErrorTranslator, Translator } from './i18nTypes';
+import {
+  ArrayDefaultTranslation,
+  ArrayTranslations,
+} from './arrayTranslations';
 
 export const getI18nKeyPrefixBySchema = (
   schema: i18nJsonSchema | undefined,
@@ -22,7 +26,7 @@ export const transformPathToI18nPrefix = (path: string): string => {
   return (
     path
       ?.split('.')
-      .filter(segment => !/^\d+$/.test(segment))
+      .filter((segment) => !/^\d+$/.test(segment))
       .join('.') || 'root'
   );
 };
@@ -47,7 +51,17 @@ export const getI18nKey = (
   return `${getI18nKeyPrefix(schema, uischema, path)}.${key}`;
 };
 
-export const defaultTranslator: Translator = (_id: string, defaultMessage: string | undefined) => defaultMessage;
+export const addI18nKeyToPrefix = (
+  i18nKeyPrefix: string,
+  key: string
+): string => {
+  return `${i18nKeyPrefix}.${key}`;
+};
+
+export const defaultTranslator: Translator = (
+  _id: string,
+  defaultMessage: string | undefined
+) => defaultMessage;
 
 export const defaultErrorTranslator: ErrorTranslator = (error, t, uischema) => {
   // check whether there is a special keyword message
@@ -57,13 +71,15 @@ export const defaultErrorTranslator: ErrorTranslator = (error, t, uischema) => {
     getControlPath(error),
     `error.${error.keyword}`
   );
-  const specializedKeywordMessage = t(i18nKey, undefined, { error } );
+  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, { error });
+  const genericKeywordMessage = t(`error.${error.keyword}`, undefined, {
+    error,
+  });
   if (genericKeywordMessage !== undefined) {
     return genericKeywordMessage;
   }
@@ -75,7 +91,10 @@ export const defaultErrorTranslator: ErrorTranslator = (error, t, uischema) => {
   }
 
   // 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')) {
+  if (
+    error.keyword === 'required' &&
+    error.message?.startsWith('must have required property')
+  ) {
     return t('is a required property', 'is a required property', { error });
   }
 
@@ -97,29 +116,60 @@ 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, {schema, uischema, path, errors});
+    const specializedErrorMessage = t(customErrorKey, undefined, {
+      schema,
+      uischema,
+      path,
+      errors,
+    });
     if (specializedErrorMessage !== undefined) {
       return specializedErrorMessage;
     }
   }
-  return formatErrorMessage(
-    errors.map(error => et(error, t, uischema))
-  );
+  return formatErrorMessage(errors.map((error) => et(error, t, uischema)));
 };
 
 /**
  * This can be used to internationalize the label of the given Labelable (e.g. UI Schema elements).
  * This should not be used for controls as there we have additional context in the form of the JSON Schema available.
  */
-export const deriveLabelForUISchemaElement = (uischema: Labelable<boolean>, t: Translator): string | undefined => {
+export const deriveLabelForUISchemaElement = (
+  uischema: Labelable<boolean>,
+  t: Translator
+): string | undefined => {
   if (uischema.label === false) {
     return undefined;
   }
-  if ((uischema.label === undefined || uischema.label === null || uischema.label === true) && !isInternationalized(uischema)) {
+  if (
+    (uischema.label === undefined ||
+      uischema.label === null ||
+      uischema.label === true) &&
+    !isInternationalized(uischema)
+  ) {
     return undefined;
   }
-  const stringifiedLabel = typeof uischema.label === 'string' ? uischema.label : JSON.stringify(uischema.label);
+  const stringifiedLabel =
+    typeof uischema.label === 'string'
+      ? uischema.label
+      : JSON.stringify(uischema.label);
   const i18nKeyPrefix = getI18nKeyPrefixBySchema(undefined, uischema);
-  const i18nKey = typeof i18nKeyPrefix === 'string' ? `${i18nKeyPrefix}.label` : stringifiedLabel;
+  const i18nKey =
+    typeof i18nKeyPrefix === 'string'
+      ? `${i18nKeyPrefix}.label`
+      : stringifiedLabel;
   return t(i18nKey, stringifiedLabel, { uischema: uischema });
-}
+};
+
+export const getArrayTranslations = (
+  t: Translator,
+  defaultTranslations: ArrayDefaultTranslation[],
+  i18nKeyPrefix: string,
+  label: string
+): ArrayTranslations => {
+  const translations: ArrayTranslations = {};
+  defaultTranslations.forEach((controlElement) => {
+    const key = addI18nKeyToPrefix(i18nKeyPrefix, controlElement.key);
+    translations[controlElement.key] = t(key, controlElement.default(label));
+  });
+  return translations;
+};

package/src/i18n/index.ts

@@ -1,2 +1,3 @@
 export * from './i18nTypes';
 export * from './i18nUtil';
+export * from './arrayTranslations';

package/src/models/draft4.ts

@@ -31,14 +31,14 @@ export const Draft4 = {
     schemaArray: {
       type: 'array',
       minItems: 1,
-      items: { $ref: '#' }
+      items: { $ref: '#' },
     },
     positiveInteger: {
       type: 'integer',
-      minimum: 0
+      minimum: 0,
     },
     positiveIntegerDefault0: {
-      allOf: [{ $ref: '#/definitions/positiveInteger' }, { default: 0 }]
+      allOf: [{ $ref: '#/definitions/positiveInteger' }, { default: 0 }],
     },
     simpleTypes: {
       enum: [
@@ -48,104 +48,104 @@ export const Draft4 = {
         'null',
         'number',
         'object',
-        'string'
-      ]
+        'string',
+      ],
     },
     stringArray: {
       type: 'array',
       items: { type: 'string' },
       minItems: 1,
-      uniqueItems: true
-    }
+      uniqueItems: true,
+    },
   },
   type: 'object',
   properties: {
     id: {
       type: 'string',
-      format: 'uri'
+      format: 'uri',
     },
     $schema: {
       type: 'string',
-      format: 'uri'
+      format: 'uri',
     },
     title: {
-      type: 'string'
+      type: 'string',
     },
     description: {
-      type: 'string'
+      type: 'string',
     },
     default: {},
     multipleOf: {
       type: 'number',
       minimum: 0,
-      exclusiveMinimum: true
+      exclusiveMinimum: true,
     },
     maximum: {
-      type: 'number'
+      type: 'number',
     },
     exclusiveMaximum: {
       type: 'boolean',
-      default: false
+      default: false,
     },
     minimum: {
-      type: 'number'
+      type: 'number',
     },
     exclusiveMinimum: {
       type: 'boolean',
-      default: false
+      default: false,
     },
     maxLength: { $ref: '#/definitions/positiveInteger' },
     minLength: { $ref: '#/definitions/positiveIntegerDefault0' },
     pattern: {
       type: 'string',
-      format: 'regex'
+      format: 'regex',
     },
     additionalItems: {
       anyOf: [{ type: 'boolean' }, { $ref: '#' }],
-      default: {}
+      default: {},
     },
     items: {
       anyOf: [{ $ref: '#' }, { $ref: '#/definitions/schemaArray' }],
-      default: {}
+      default: {},
     },
     maxItems: { $ref: '#/definitions/positiveInteger' },
     minItems: { $ref: '#/definitions/positiveIntegerDefault0' },
     uniqueItems: {
       type: 'boolean',
-      default: false
+      default: false,
     },
     maxProperties: { $ref: '#/definitions/positiveInteger' },
     minProperties: { $ref: '#/definitions/positiveIntegerDefault0' },
     required: { $ref: '#/definitions/stringArray' },
     additionalProperties: {
       anyOf: [{ type: 'boolean' }, { $ref: '#' }],
-      default: {}
+      default: {},
     },
     definitions: {
       type: 'object',
       additionalProperties: { $ref: '#' },
-      default: {}
+      default: {},
     },
     properties: {
       type: 'object',
       additionalProperties: { $ref: '#' },
-      default: {}
+      default: {},
     },
     patternProperties: {
       type: 'object',
       additionalProperties: { $ref: '#' },
-      default: {}
+      default: {},
     },
     dependencies: {
       type: 'object',
       additionalProperties: {
-        anyOf: [{ $ref: '#' }, { $ref: '#/definitions/stringArray' }]
-      }
+        anyOf: [{ $ref: '#' }, { $ref: '#/definitions/stringArray' }],
+      },
     },
     enum: {
       type: 'array',
       minItems: 1,
-      uniqueItems: true
+      uniqueItems: true,
     },
     type: {
       anyOf: [
@@ -154,18 +154,18 @@ export const Draft4 = {
           type: 'array',
           items: { $ref: '#/definitions/simpleTypes' },
           minItems: 1,
-          uniqueItems: true
-        }
-      ]
+          uniqueItems: true,
+        },
+      ],
     },
     allOf: { $ref: '#/definitions/schemaArray' },
     anyOf: { $ref: '#/definitions/schemaArray' },
     oneOf: { $ref: '#/definitions/schemaArray' },
-    not: { $ref: '#' }
+    not: { $ref: '#' },
   },
   dependencies: {
     exclusiveMaximum: ['maximum'],
-    exclusiveMinimum: ['minimum']
+    exclusiveMinimum: ['minimum'],
   },
-  default: {}
+  default: {},
 };

package/src/models/uischema.ts

@@ -54,7 +54,7 @@ export interface Labelable<T = string> {
   /**
    * Label for UI schema element.
    */
-  label?: string|T;
+  label?: string | T;
 }
 
 /**
@@ -108,7 +108,7 @@ export enum RuleEffect {
   /**
    * Effect that disables the associated element.
    */
-  DISABLE = 'DISABLE'
+  DISABLE = 'DISABLE',
 }
 
 /**
@@ -240,7 +240,11 @@ export interface LabelElement extends UISchemaElement, Internationalizable {
  * 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, Scoped, Labelable<string | boolean | LabelDescription>, Internationalizable {
+export interface ControlElement
+  extends UISchemaElement,
+    Scoped,
+    Labelable<string | boolean | LabelDescription>,
+    Internationalizable {
   type: 'Control';
 }
 
@@ -256,7 +260,10 @@ export interface Category extends Layout, Labeled, Internationalizable {
  * 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, Labeled, Internationalizable {
+export interface Categorization
+  extends UISchemaElement,
+    Labeled,
+    Internationalizable {
   type: 'Categorization';
   /**
    * The child elements of this categorization which are either of type
@@ -265,8 +272,12 @@ export interface Categorization extends UISchemaElement, Labeled, Internationali
   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 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';

package/src/reducers/cells.ts

@@ -28,28 +28,29 @@ import {
   ADD_CELL,
   AddCellRendererAction,
   REMOVE_CELL,
-  RemoveCellRendererAction
+  RemoveCellRendererAction,
 } from '../actions';
 import type { Reducer } from '../util';
 
 type ValidCellReducerActions = AddCellRendererAction | RemoveCellRendererAction;
 
-export type JsonFormsCellRendererRegistryState = JsonFormsCellRendererRegistryEntry[];
+export type JsonFormsCellRendererRegistryState =
+  JsonFormsCellRendererRegistryEntry[];
 
 export interface JsonFormsCellRendererRegistryEntry {
   tester: RankedTester;
   cell: any;
 }
 
-export const cellReducer: Reducer<JsonFormsCellRendererRegistryState, ValidCellReducerActions> = (
-  state = [],
-  { type, tester, cell }
-) => {
+export const cellReducer: Reducer<
+  JsonFormsCellRendererRegistryState,
+  ValidCellReducerActions
+> = (state = [], { type, tester, cell }) => {
   switch (type) {
     case ADD_CELL:
       return state.concat([{ tester, cell }]);
     case REMOVE_CELL:
-      return state.filter(t => t.tester !== tester);
+      return state.filter((t) => t.tester !== tester);
     default:
       return state;
   }