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

package/src/generators/schema.ts

@@ -23,7 +23,7 @@
   THE SOFTWARE.
 */
 
-import { JsonSchema4 } from '../models';
+import type { JsonSchema4 } from '../models';
 
 const ADDITIONAL_PROPERTIES = 'additionalProperties';
 const REQUIRED_PROPERTIES = 'required';
@@ -36,7 +36,7 @@ const distinct = (
 ): JsonSchema4[] => {
   const known: { [property: string]: boolean } = {};
 
-  return properties.filter(item => {
+  return properties.filter((item) => {
     const discriminatorValue = discriminator(item);
     if (known.hasOwnProperty(discriminatorValue)) {
       return false;
@@ -52,12 +52,14 @@ class Gen {
     private findOption: (props: Properties) => (optionName: string) => any
   ) {}
 
+  // TODO fix @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/ban-types
   schemaObject = (data: Object): JsonSchema4 => {
     const props: Properties = this.properties(data);
     const schema: JsonSchema4 = {
       type: 'object',
       properties: props,
-      additionalProperties: this.findOption(props)(ADDITIONAL_PROPERTIES)
+      additionalProperties: this.findOption(props)(ADDITIONAL_PROPERTIES),
     };
     const required = this.findOption(props)(REQUIRED_PROPERTIES);
     if (required.length > 0) {
@@ -111,26 +113,26 @@ class Gen {
   schemaArray = (data: any[]): JsonSchema4 => {
     if (data.length > 0) {
       const allProperties: JsonSchema4[] = data.map(this.property);
-      const uniqueProperties = distinct(allProperties, prop =>
+      const uniqueProperties = distinct(allProperties, (prop) =>
         JSON.stringify(prop)
       );
       if (uniqueProperties.length === 1) {
         return {
           type: 'array',
-          items: uniqueProperties[0]
+          items: uniqueProperties[0],
         };
       } else {
         return {
           type: 'array',
           items: {
-            oneOf: uniqueProperties
-          }
+            oneOf: uniqueProperties,
+          },
         };
       }
     } else {
       return {
         type: 'array',
-        items: {}
+        items: {},
       };
     }
   };
@@ -143,29 +145,31 @@ class Gen {
  * @returns {JsonSchema} the generated schema
  */
 export const generateJsonSchema = (
+  // TODO fix @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/ban-types
   instance: Object,
   options: any = {}
 ): JsonSchema4 => {
-  const findOption = (props: Properties) => (
-    optionName: string
-  ): boolean | string[] => {
-    switch (optionName) {
-      case ADDITIONAL_PROPERTIES:
-        if (options.hasOwnProperty(ADDITIONAL_PROPERTIES)) {
-          return options[ADDITIONAL_PROPERTIES];
-        }
+  const findOption =
+    (props: Properties) =>
+    (optionName: string): boolean | string[] => {
+      switch (optionName) {
+        case ADDITIONAL_PROPERTIES:
+          if (options.hasOwnProperty(ADDITIONAL_PROPERTIES)) {
+            return options[ADDITIONAL_PROPERTIES];
+          }
 
-        return true;
-      case REQUIRED_PROPERTIES:
-        if (options.hasOwnProperty(REQUIRED_PROPERTIES)) {
-          return options[REQUIRED_PROPERTIES](props);
-        }
+          return true;
+        case REQUIRED_PROPERTIES:
+          if (options.hasOwnProperty(REQUIRED_PROPERTIES)) {
+            return options[REQUIRED_PROPERTIES](props);
+          }
 
-        return Object.keys(props);
-      default:
-        return;
-    }
-  };
+          return Object.keys(props);
+        default:
+          return;
+      }
+    };
 
   const gen = new Gen(findOption);
 

package/src/generators/uischema.ts

@@ -33,7 +33,7 @@ import {
   JsonSchema,
   LabelElement,
   Layout,
-  UISchemaElement
+  UISchemaElement,
 } from '../models';
 import { deriveTypes, encode, resolveSchema } from '../util';
 
@@ -44,7 +44,7 @@ import { deriveTypes, encode, resolveSchema } from '../util';
  */
 const createLayout = (layoutType: string): Layout => ({
   type: layoutType,
-  elements: []
+  elements: [],
 });
 
 /**
@@ -52,7 +52,7 @@ const createLayout = (layoutType: string): Layout => ({
  */
 export const createControlElement = (ref: string): ControlElement => ({
   type: 'Control',
-  scope: ref
+  scope: ref,
 });
 
 /**
@@ -91,7 +91,7 @@ const addLabel = (layout: Layout, labelName: string) => {
       // add label with name
       const label: LabelElement = {
         type: 'Label',
-        text: fixedLabel
+        text: fixedLabel,
       };
       layout.elements.push(label);
     }
@@ -160,7 +160,7 @@ const generateUISchema = (
     if (!isEmpty(jsonSchema.properties)) {
       // traverse properties
       const nextRef: string = currentRef + '/properties';
-      Object.keys(jsonSchema.properties).map(propName => {
+      Object.keys(jsonSchema.properties).map((propName) => {
         let value = jsonSchema.properties[propName];
         const ref = `${nextRef}/${encode(propName)}`;
         if (value.$ref !== undefined) {
@@ -191,11 +191,12 @@ const generateUISchema = (
     /* falls through */
     case 'integer':
     /* falls through */
-    case 'boolean':
+    case 'boolean': {
       const controlObject: ControlElement = createControlElement(currentRef);
       schemaElements.push(controlObject);
 
       return controlObject;
+    }
     default:
       throw new Error('Unknown type: ' + JSON.stringify(jsonSchema));
   }

package/src/i18n/arrayTranslations.ts

@@ -0,0 +1,54 @@
+export interface ArrayDefaultTranslation {
+  key: ArrayTranslationEnum;
+  default: (variable?: string) => string;
+}
+
+export enum ArrayTranslationEnum {
+  addTooltip = 'addTooltip',
+  addAriaLabel = 'addAriaLabel',
+  removeTooltip = 'removeTooltip',
+  upAriaLabel = 'upAriaLabel',
+  downAriaLabel = 'downAriaLabel',
+  noSelection = 'noSelection',
+  removeAriaLabel = 'removeAriaLabel',
+  noDataMessage = 'noDataMessage',
+  deleteDialogTitle = 'deleteDialogTitle',
+  deleteDialogMessage = 'deleteDialogMessage',
+  deleteDialogAccept = 'deleteDialogAccept',
+  deleteDialogDecline = 'deleteDialogDecline',
+  up = 'up',
+  down = 'down',
+}
+
+export type ArrayTranslations = {
+  [key in ArrayTranslationEnum]?: string;
+};
+
+export const arrayDefaultTranslations: ArrayDefaultTranslation[] = [
+  {
+    key: ArrayTranslationEnum.addTooltip,
+    default: (input) => (input ? `Add to ${input}` : 'Add'),
+  },
+  {
+    key: ArrayTranslationEnum.addAriaLabel,
+    default: (input) => (input ? `Add to ${input} button` : 'Add button'),
+  },
+  { key: ArrayTranslationEnum.removeTooltip, default: () => 'Delete' },
+  { key: ArrayTranslationEnum.removeAriaLabel, default: () => 'Delete button' },
+  { key: ArrayTranslationEnum.upAriaLabel, default: () => `Move item up` },
+  { key: ArrayTranslationEnum.up, default: () => 'Up' },
+  { key: ArrayTranslationEnum.down, default: () => 'Down' },
+  { key: ArrayTranslationEnum.downAriaLabel, default: () => `Move item down` },
+  { key: ArrayTranslationEnum.noDataMessage, default: () => 'No data' },
+  { key: ArrayTranslationEnum.noSelection, default: () => 'No selection' },
+  {
+    key: ArrayTranslationEnum.deleteDialogTitle,
+    default: () => 'Confirm Deletion',
+  },
+  {
+    key: ArrayTranslationEnum.deleteDialogMessage,
+    default: () => 'Are you sure you want to delete the selected entry?',
+  },
+  { key: ArrayTranslationEnum.deleteDialogAccept, default: () => 'Yes' },
+  { key: ArrayTranslationEnum.deleteDialogDecline, default: () => 'No' },
+];

package/src/i18n/i18nTypes.ts

@@ -1,12 +1,17 @@
-import { ErrorObject } from 'ajv';
-import { JsonSchema, UISchemaElement } from '../models';
+import type { ErrorObject } from 'ajv';
+import type { JsonSchema, UISchemaElement } from '../models';
 
 export type Translator = {
-    (id: string, defaultMessage: string, values?: any): string;
-    (id: string, defaultMessage: undefined, values?: any): string | undefined;
-}
+  (id: string, defaultMessage: string, values?: any): string;
+  (id: string, defaultMessage: undefined, values?: any): string | undefined;
+  (id: string, defaultMessage?: string, values?: any): string | undefined;
+};
 
-export type ErrorTranslator = (error: ErrorObject, translate: Translator, uischema?: UISchemaElement) => string;
+export type ErrorTranslator = (
+  error: ErrorObject,
+  translate: Translator,
+  uischema?: UISchemaElement
+) => string;
 
 export interface JsonFormsI18nState {
   locale?: string;
@@ -14,4 +19,4 @@ export interface JsonFormsI18nState {
   translateError?: ErrorTranslator;
 }
 
-export type i18nJsonSchema = JsonSchema & {i18n?: string};
+export type i18nJsonSchema = JsonSchema & { i18n?: string };

package/src/i18n/i18nUtil.ts

@@ -1,8 +1,12 @@
-import { ErrorObject } from 'ajv';
+import type { ErrorObject } from 'ajv';
 import { isInternationalized, Labelable, UISchemaElement } from '../models';
 import { getControlPath } from '../reducers';
 import { formatErrorMessage } from '../util';
-import { i18nJsonSchema, ErrorTranslator, Translator } from './i18nTypes';
+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/jsonSchema.ts

@@ -23,7 +23,7 @@
   THE SOFTWARE.
 */
 
-import { JsonSchema4 } from './jsonSchema4';
-import { JsonSchema7 } from './jsonSchema7';
+import type { JsonSchema4 } from './jsonSchema4';
+import type { JsonSchema7 } from './jsonSchema7';
 
 export type JsonSchema = JsonSchema4 | JsonSchema7;

package/src/models/uischema.ts

@@ -23,7 +23,7 @@
   THE SOFTWARE.
 */
 
-import { JsonSchema } from './jsonSchema';
+import type { JsonSchema } from './jsonSchema';
 
 /**
  * Interface for describing an UI schema element that is referencing
@@ -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';