@jsonforms/core 2.5.2 → 3.0.0-alpha.3

package/src/reducers/config.ts

@@ -22,10 +22,11 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+
 import merge from 'lodash/merge';
 import { SET_CONFIG, SetConfigAction } from '../actions';
 import { configDefault } from '../configDefault';
-import { Reducer } from '../util/type';
+import { Reducer } from '../util';
 
 const applyDefaultConfiguration = (config: any = {}) =>
   merge({}, configDefault, config);

package/src/reducers/core.ts

@@ -22,14 +22,14 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+
 import cloneDeep from 'lodash/cloneDeep';
 import setFp from 'lodash/fp/set';
 import get from 'lodash/get';
 import filter from 'lodash/filter';
 import isEqual from 'lodash/isEqual';
 import isFunction from 'lodash/isFunction';
-import { Ajv, ErrorObject, ValidateFunction } from 'ajv';
-import RefParser from 'json-schema-ref-parser';
+import Ajv, { ErrorObject, ValidateFunction } from 'ajv';
 import {
   CoreActions,
   INIT,
@@ -44,32 +44,20 @@ import {
   UPDATE_CORE,
   UpdateCoreAction
 } from '../actions';
-import { createAjv } from '../util/validator';
-import { Reducer } from '../util/type';
-import { JsonSchema, UISchemaElement } from '..';
+import { createAjv, Reducer } from '../util';
+import { JsonSchema, UISchemaElement } from '../models';
 
-const validate = (validator: ValidateFunction, data: any): ErrorObject[] => {
+export const validate = (validator: ValidateFunction | undefined, data: any): ErrorObject[] => {
+  if (validator === undefined) {
+    return [];
+  }
   const valid = validator(data);
   if (valid) {
     return [];
   }
-
   return validator.errors;
 };
 
-export const sanitizeErrors = (validator: ValidateFunction, data: any) => {
-  if (validator === alwaysValid) {
-    return [];
-  }
-  return validate(validator, data).map(error => {
-    error.dataPath = error.dataPath.replace(/\//g, '.').substr(1);
-
-    return error;
-  });
-};
-
-const alwaysValid: ValidateFunction = () => true;
-
 export type ValidationMode = 'ValidateAndShow' | 'ValidateAndHide' | 'NoValidation';
 
 export interface JsonFormsCore {
@@ -79,7 +67,6 @@ export interface JsonFormsCore {
   errors?: ErrorObject[];
   validator?: ValidateFunction;
   ajv?: Ajv;
-  refParserOptions?: RefParser.Options;
   validationMode?: ValidationMode;
 }
 
@@ -88,10 +75,9 @@ const initState: JsonFormsCore = {
   schema: {},
   uischema: undefined,
   errors: [],
-  validator: alwaysValid,
+  validator: undefined,
   ajv: undefined,
-  refParserOptions: undefined,
-  validationMode: 'ValidateAndShow'
+  validationMode: 'ValidateAndShow',
 };
 
 const reuseAjvForSchema = (ajv: Ajv, schema: JsonSchema): Ajv => {
@@ -107,8 +93,7 @@ const getOrCreateAjv = (state: JsonFormsCore, action?: InitAction | UpdateCoreAc
       // options object with ajv
       return action.options.ajv;
     } else if (
-      action.options !== undefined &&
-      !hasRefParserOption(action.options)
+      action.options !== undefined
     ) {
       // it is not an option object => should be ajv itself => check for compile function
       if (isFunction(action.options.compile)) {
@@ -124,23 +109,6 @@ const getOrCreateAjv = (state: JsonFormsCore, action?: InitAction | UpdateCoreAc
   return createAjv();
 };
 
-const getRefParserOptions = (
-  state: JsonFormsCore,
-  action?: InitAction | UpdateCoreAction
-): RefParser.Options => {
-  if (action && hasRefParserOption(action.options)) {
-    return action.options.refParserOptions;
-  }
-  return state.refParserOptions;
-};
-
-const hasRefParserOption = (option: any): option is InitActionOptions => {
-  if (option) {
-    return option.refParserOptions !== undefined;
-  }
-  return false;
-};
-
 const hasAjvOption = (option: any): option is InitActionOptions => {
   if (option) {
     return option.ajv !== undefined;
@@ -173,11 +141,10 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
   switch (action.type) {
     case INIT: {
       const thisAjv = getOrCreateAjv(state, action);
-      const o = getRefParserOptions(state, action);
 
       const validationMode = getValidationMode(state, action);
-      const v = validationMode === 'NoValidation' ? alwaysValid : thisAjv.compile(action.schema);
-      const e = sanitizeErrors(v, action.data);
+      const v = validationMode === 'NoValidation' ? undefined : thisAjv.compile(action.schema);
+      const e = validate(v, action.data);
 
       return {
         ...state,
@@ -187,13 +154,11 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
         errors: e,
         validator: v,
         ajv: thisAjv,
-        refParserOptions: o,
-        validationMode
+        validationMode,
       };
     }
     case UPDATE_CORE: {
       const thisAjv = getOrCreateAjv(state, action);
-      const refParserOptions = getRefParserOptions(state, action);
       const validationMode = getValidationMode(state, action);
       let validator = state.validator;
       let errors = state.errors;
@@ -205,11 +170,11 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
         // revalidate only if necessary
         validator =
           validationMode === 'NoValidation'
-            ? alwaysValid
+            ? undefined
             : thisAjv.compile(action.schema);
-        errors = sanitizeErrors(validator, action.data);
+        errors = validate(validator, action.data);
       } else if (state.data !== action.data) {
-        errors = sanitizeErrors(validator, action.data);
+        errors = validate(validator, action.data);
       }
 
       const stateChanged =
@@ -219,26 +184,24 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
         state.ajv !== thisAjv ||
         state.errors !== errors ||
         state.validator !== validator ||
-        state.refParserOptions !== refParserOptions ||
-        state.validationMode !== validationMode;
+        state.validationMode !== validationMode
       return stateChanged
         ? {
             ...state,
-            data: state.data === action.data ? state.data : action.data,
-            schema: state.schema === action.schema ? state.schema : action.schema,
-            uischema: state.uischema === action.uischema ? state.uischema : action.uischema,
-            ajv: thisAjv === state.ajv ? state.ajv : thisAjv,
+            data: action.data,
+            schema: action.schema,
+            uischema: action.uischema,
+            ajv: thisAjv,
             errors: isEqual(errors, state.errors) ? state.errors : errors,
-            validator: validator === state.validator ? state.validator : validator,
-            refParserOptions: refParserOptions === state.refParserOptions ? state.refParserOptions : refParserOptions,
-            validationMode: validationMode === state.validationMode ? state.validationMode : validationMode
+            validator: validator,
+            validationMode: validationMode,
           }
         : state;
     }
     case SET_AJV: {
       const currentAjv = action.ajv;
-      const validator = state.validationMode === 'NoValidation' ? alwaysValid : currentAjv.compile(state.schema);
-      const errors = sanitizeErrors(validator, state.data);
+      const validator = state.validationMode === 'NoValidation' ? undefined : currentAjv.compile(state.schema);
+      const errors = validate(validator, state.data);
       return {
         ...state,
         validator,
@@ -250,7 +213,7 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
       const v = needsNewValidator
         ? reuseAjvForSchema(state.ajv, action.schema).compile(action.schema)
         : state.validator;
-      const errors = sanitizeErrors(v, state.data);
+      const errors = validate(v, state.data);
       return {
         ...state,
         validator: v,
@@ -270,7 +233,7 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
       } else if (action.path === '') {
         // empty path is ok
         const result = action.updater(cloneDeep(state.data));
-        const errors = sanitizeErrors(state.validator, result);
+        const errors = validate(state.validator, result);
         return {
           ...state,
           data: result,
@@ -284,7 +247,7 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
           newData,
           state.data === undefined ? {} : state.data
         );
-        const errors = sanitizeErrors(state.validator, newState);
+        const errors = validate(state.validator, newState);
         return {
           ...state,
           data: newState,
@@ -303,17 +266,16 @@ export const coreReducer: Reducer<JsonFormsCore, CoreActions> = (
         return state;
       }
       if (action.validationMode === 'NoValidation') {
-        const errors = sanitizeErrors(alwaysValid, state.data);
+        const errors = validate(undefined, state.data);
         return {
           ...state,
-          validator: alwaysValid,
           errors,
           validationMode: action.validationMode
         };
       }
       if (state.validationMode === 'NoValidation') {
         const validator = reuseAjvForSchema(state.ajv, state.schema).compile(state.schema);
-        const errors = sanitizeErrors(validator, state.data);
+        const errors = validate(validator, state.data);
         return {
           ...state,
           validator,
@@ -336,6 +298,40 @@ export const extractSchema = (state: JsonFormsCore) => get(state, 'schema');
 export const extractUiSchema = (state: JsonFormsCore) => get(state, 'uischema');
 export const extractAjv = (state: JsonFormsCore) => get(state, 'ajv');
 
+const getInvalidProperty = (error: ErrorObject): string | undefined => {
+  switch (error.keyword) {
+    case 'required':
+    case 'dependencies':
+      return error.params.missingProperty;
+    case 'additionalProperties':
+      return error.params.additionalProperty;
+    default:
+      return undefined;
+  }
+};
+
+export const getControlPath = (error: ErrorObject) => {
+  const dataPath = (error as any).dataPath;
+  // older AJV version
+  if (dataPath) {
+    return dataPath.replace(/\//g, '.').substr(1);
+  }
+  // dataPath was renamed to instancePath in AJV v8
+  var controlPath: string = error.instancePath;
+
+  // change '/' chars to '.'
+  controlPath = controlPath.replace(/\//g, '.');
+  
+  const invalidProperty = getInvalidProperty(error);
+  if (invalidProperty !== undefined && !controlPath.endsWith(invalidProperty)) {
+    controlPath = `${controlPath}.${invalidProperty}`;
+  }
+  
+  // remove '.' chars at the beginning of paths
+  controlPath = controlPath.replace(/^./, '');
+  return controlPath;
+}
+
 export const errorsAt = (
   instancePath: string,
   schema: JsonSchema,
@@ -345,15 +341,15 @@ export const errorsAt = (
   const combinatorPaths = filter(
     errors,
     error => error.keyword === 'oneOf' || error.keyword === 'anyOf'
-  ).map(error => error.dataPath);
-
-  return filter(errors, error => {
-    // Filter errors that match any keyword that we don't want to show in the UI
-    if (filteredErrorKeywords.indexOf(error.keyword) !== -1) {
-      return false;
-    }
-
-    let result = matchPath(error.dataPath);
+    ).map(error => getControlPath(error));
+    
+    return filter(errors, error => {
+      // Filter errors that match any keyword that we don't want to show in the UI
+      if (filteredErrorKeywords.indexOf(error.keyword) !== -1) {
+        return false;
+      }
+    const controlPath = getControlPath(error);
+    let result = matchPath(controlPath);
     // In anyOf and oneOf blocks with "primitive" (i.e. string, number etc.) or array subschemas,
     // we want to make sure that errors are only shown for the correct subschema.
     // Therefore, we compare the error's parent schema with the property's schema.
@@ -402,6 +398,3 @@ export const errorAt = (instancePath: string, schema: JsonSchema) =>
   getErrorsAt(instancePath, schema, path => path === instancePath);
 export const subErrorsAt = (instancePath: string, schema: JsonSchema) =>
   getErrorsAt(instancePath, schema, path => path.startsWith(instancePath));
-
-export const extractRefParserOptions = (state: JsonFormsCore) =>
-  get(state, 'refParserOptions');

package/src/reducers/default-data.ts

@@ -22,13 +22,14 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+
 import {
   ADD_DEFAULT_DATA,
   RegisterDefaultDataAction,
   REMOVE_DEFAULT_DATA,
   UnregisterDefaultDataAction
 } from '../actions';
-import { Reducer } from '../util/type';
+import { Reducer } from '../util';
 
 export interface JsonFormsDefaultDataRegistryEntry {
   schemaPath: string;

package/src/reducers/i18n.ts

@@ -22,66 +22,73 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
-import { SET_LOCALE, SET_LOCALIZED_SCHEMAS } from '../actions';
-import { JsonSchema, SET_LOCALIZED_UISCHEMAS, UISchemaElement } from '..';
-import { Reducer } from '../util/type';
 
-export interface JsonFormsLocaleState {
-  locale?: string;
-  localizedSchemas: Map<string, JsonSchema>;
-  localizedUISchemas: Map<string, UISchemaElement>;
-}
+import { defaultErrorTranslator, defaultTranslator, JsonFormsI18nState } from '../i18n';
+import { I18nActions, SET_LOCALE, SET_TRANSLATOR, UPDATE_I18N } from '../actions';
+import { Reducer } from '../util';
 
-const initState: JsonFormsLocaleState = {
-  locale: undefined,
-  localizedSchemas: new Map(),
-  localizedUISchemas: new Map()
+export const defaultJsonFormsI18nState: JsonFormsI18nState = {
+  locale: 'en',
+  translate: defaultTranslator,
+  translateError: defaultErrorTranslator
 };
 
-export const i18nReducer: Reducer<any, any> = (state = initState, action) => {
+export const i18nReducer: Reducer<JsonFormsI18nState, I18nActions> = (state = defaultJsonFormsI18nState, action) => {
   switch (action.type) {
-    case SET_LOCALIZED_SCHEMAS:
-      return {
-        ...state,
-        localizedSchemas: action.localizedSchemas
-      };
-    case SET_LOCALIZED_UISCHEMAS:
+    case UPDATE_I18N: {
+      const locale = action.locale ?? defaultJsonFormsI18nState.locale;
+      const translate =
+        action.translator ?? defaultJsonFormsI18nState.translate;
+      const translateError =
+        action.errorTranslator ?? defaultJsonFormsI18nState.translateError;
+
+      if (
+        locale !== state.locale ||
+        translate !== state.translate ||
+        translateError !== state.translateError
+      ) {
+        return {
+          ...state,
+          locale,
+          translate,
+          translateError
+        };
+      }
+      return state;
+    }
+    case SET_TRANSLATOR:
       return {
         ...state,
-        localizedUISchemas: action.localizedUISchemas
+        translate: action.translator ?? defaultTranslator,
+        translateError: action.errorTranslator ?? defaultErrorTranslator
       };
     case SET_LOCALE:
       return {
         ...state,
-        locale:
-          action.locale === undefined ? navigator.languages[0] : action.locale
+        locale: action.locale ?? navigator.languages[0]
       };
     default:
       return state;
   }
 };
 
-export const fetchLocale = (state?: JsonFormsLocaleState) => {
+export const fetchLocale = (state?: JsonFormsI18nState) => {
   if (state === undefined) {
     return undefined;
   }
   return state.locale;
 };
 
-export const findLocalizedSchema = (locale: string) => (
-  state?: JsonFormsLocaleState
-): JsonSchema => {
+export const fetchTranslator = (state?: JsonFormsI18nState) => {
   if (state === undefined) {
-    return undefined;
+    return defaultTranslator;
   }
-  return state.localizedSchemas.get(locale);
-};
+  return state.translate;
+}
 
-export const findLocalizedUISchema = (locale: string) => (
-  state?: JsonFormsLocaleState
-): UISchemaElement => {
+export const fetchErrorTranslator = (state?: JsonFormsI18nState) => {
   if (state === undefined) {
-    return undefined;
+    return defaultErrorTranslator;
   }
-  return state.localizedUISchemas.get(locale);
-};
+  return state.translateError;
+}

package/src/reducers/index.ts

@@ -22,162 +22,13 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
-import { ControlElement, UISchemaElement } from '../models/uischema';
-import {
-  coreReducer,
-  errorAt,
-  errorsAt,
-  extractAjv,
-  extractData,
-  extractRefParserOptions,
-  extractSchema,
-  extractUiSchema,
-  JsonFormsCore,
-  subErrorsAt,
-  ValidationMode
-} from './core';
-import {
-  extractDefaultData,
-  JsonFormsDefaultDataRegistryEntry
-} from './default-data';
-import { defaultDataReducer } from '../reducers/default-data';
-import { JsonFormsRendererRegistryEntry, rendererReducer } from './renderers';
-import { JsonFormsState } from '../store';
-import {
-  findMatchingUISchema,
-  JsonFormsUISchemaRegistryEntry,
-  uischemaRegistryReducer,
-  UISchemaTester
-} from './uischemas';
-import {
-  fetchLocale,
-  findLocalizedSchema,
-  findLocalizedUISchema,
-  i18nReducer
-} from './i18n';
 
-import { Generate } from '../generators';
-import { JsonFormsCellRendererRegistryEntry } from './cells';
-import { JsonSchema } from '../models/jsonSchema';
-import RefParser from 'json-schema-ref-parser';
-
-import { cellReducer } from './cells';
-import { configReducer } from './config';
-import get from 'lodash/get';
-import { Ajv } from 'ajv';
-
-export {
-  rendererReducer,
-  cellReducer,
-  coreReducer,
-  i18nReducer,
-  configReducer,
-  UISchemaTester,
-  uischemaRegistryReducer,
-  findMatchingUISchema,
-  JsonFormsUISchemaRegistryEntry
-};
-export { JsonFormsCore, ValidationMode };
-
-export const jsonFormsReducerConfig = {
-  core: coreReducer,
-  renderers: rendererReducer,
-  cells: cellReducer,
-  config: configReducer,
-  uischemas: uischemaRegistryReducer,
-  defaultData: defaultDataReducer,
-  i18n: i18nReducer
-};
-
-export const getData = (state: JsonFormsState) =>
-  extractData(get(state, 'jsonforms.core'));
-export const getSchema = (state: JsonFormsState): JsonSchema =>
-  extractSchema(get(state, 'jsonforms.core'));
-export const getUiSchema = (state: JsonFormsState): UISchemaElement =>
-  extractUiSchema(get(state, 'jsonforms.core'));
-export const getRefParserOptions = (state: JsonFormsState): RefParser.Options =>
-  extractRefParserOptions(get(state, 'jsonforms.core'));
-export const getAjv = (
-  state: JsonFormsState
-): Ajv => extractAjv(get(state, 'jsonforms.core'));
-export const getDefaultData = (
-  state: JsonFormsState
-): JsonFormsDefaultDataRegistryEntry[] =>
-  extractDefaultData(get(state, 'jsonforms.defaultData'));
-export const getRenderers = (
-  state: JsonFormsState
-): JsonFormsRendererRegistryEntry[] => get(state, 'jsonforms.renderers');
-export const getCells = (
-  state: JsonFormsState
-): JsonFormsCellRendererRegistryEntry[] => get(state, 'jsonforms.cells');
-export const getUISchemas = (
-  state: JsonFormsState
-): JsonFormsUISchemaRegistryEntry[] => get(state, 'jsonforms.uischemas');
-
-/**
- * Finds a registered UI schema to use, if any.
- * @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 control may be checked for embedded inline uischema options
- */
-export const findUISchema = (
-  uischemas: JsonFormsUISchemaRegistryEntry[],
-  schema: JsonSchema,
-  schemaPath: string,
-  path: string,
-  fallbackLayoutType = 'VerticalLayout',
-  control?: ControlElement,
-  rootSchema?: JsonSchema
-): UISchemaElement => {
-  // handle options
-  if (control && control.options && control.options.detail) {
-    if (typeof control.options.detail === 'string') {
-      if (control.options.detail.toUpperCase() === 'GENERATE') {
-        // force generation of uischema
-        return Generate.uiSchema(schema, fallbackLayoutType);
-      }
-    } else if (typeof control.options.detail === 'object') {
-      // check if detail is a valid uischema
-      if (
-        control.options.detail.type &&
-        typeof control.options.detail.type === 'string'
-      ) {
-        return control.options.detail as UISchemaElement;
-      }
-    }
-  }
-  // default
-  const uiSchema = findMatchingUISchema(uischemas)(schema, schemaPath, path);
-  if (uiSchema === undefined) {
-    return Generate.uiSchema(schema, fallbackLayoutType, '#', rootSchema);
-  }
-  return uiSchema;
-};
-
-export const getErrorAt = (instancePath: string, schema: JsonSchema) => (
-  state: JsonFormsState
-) => {
-  return errorAt(instancePath, schema)(state.jsonforms.core);
-};
-
-export { errorsAt };
-
-export const getSubErrorsAt = (instancePath: string, schema: JsonSchema) => (
-  state: JsonFormsState
-) => subErrorsAt(instancePath, schema)(state.jsonforms.core);
-
-export const getConfig = (state: JsonFormsState) => state.jsonforms.config;
-
-export const getLocale = (state: JsonFormsState) =>
-  fetchLocale(get(state, 'jsonforms.i18n'));
-
-export const getLocalizedSchema = (locale: string) => (
-  state: JsonFormsState
-): JsonSchema => findLocalizedSchema(locale)(get(state, 'jsonforms.i18n'));
-
-export const getLocalizedUISchema = (locale: string) => (
-  state: JsonFormsState
-): UISchemaElement =>
-  findLocalizedUISchema(locale)(get(state, 'jsonforms.i18n'));
+export * from './cells';
+export * from './config';
+export * from './core';
+export * from './default-data';
+export * from './i18n';
+export * from './reducers';
+export * from './renderers';
+export * from './selectors';
+export * from './uischemas';