@jsonforms/core 3.4.0-alpha.0 → 3.4.0-alpha.1

package/src/util/errors.ts

@@ -0,0 +1,142 @@
+/*
+  The MIT License
+  
+  Copyright (c) 2017-2019 EclipseSource Munich
+  https://github.com/eclipsesource/jsonforms
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+import { ErrorObject } from 'ajv';
+import { decode } from './path';
+import { JsonSchema } from '../models';
+import { isOneOfEnumSchema } from './schema';
+import filter from 'lodash/filter';
+import isEqual from 'lodash/isEqual';
+
+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) => {
+  // Up until AJV v7 the path property was called 'dataPath'
+  // With AJV v8 the property was renamed to 'instancePath'
+  let controlPath = (error as any).dataPath || 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(/^./, '');
+
+  // decode JSON Pointer escape sequences
+  controlPath = decode(controlPath);
+  return controlPath;
+};
+
+export const errorsAt =
+  (
+    instancePath: string,
+    schema: JsonSchema,
+    matchPath: (path: string) => boolean
+  ) =>
+  (errors: ErrorObject[]): ErrorObject[] => {
+    // Get data paths of oneOf and anyOf errors to later determine whether an error occurred inside a subschema of oneOf or anyOf.
+    const combinatorPaths = filter(
+      errors,
+      (error) => error.keyword === 'oneOf' || error.keyword === 'anyOf'
+    ).map((error) => getControlPath(error));
+
+    return filter(errors, (error) => {
+      // Filter errors that match any keyword that we don't want to show in the UI
+      // but keep the errors for oneOf enums
+      if (
+        filteredErrorKeywords.indexOf(error.keyword) !== -1 &&
+        !isOneOfEnumSchema(error.parentSchema)
+      ) {
+        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.
+      // In the primitive case the error's data path is the same for all subschemas:
+      // It directly points to the property defining the anyOf/oneOf.
+      // The same holds true for errors on the array level (e.g. min item amount).
+      // In contrast, this comparison must not be done for errors whose parent schema defines an object or a oneOf enum,
+      // because the parent schema can never match the property schema (e.g. for 'required' checks).
+      const parentSchema: JsonSchema | undefined = error.parentSchema;
+      if (
+        result &&
+        !isObjectSchema(parentSchema) &&
+        !isOneOfEnumSchema(parentSchema) &&
+        combinatorPaths.findIndex((p) => instancePath.startsWith(p)) !== -1
+      ) {
+        result = result && isEqual(parentSchema, schema);
+      }
+      return result;
+    });
+  };
+
+/**
+ * @returns true if the schema describes an object.
+ */
+const isObjectSchema = (schema?: JsonSchema): boolean => {
+  return schema?.type === 'object' || !!schema?.properties;
+};
+
+/**
+ * The error-type of an AJV error is defined by its `keyword` property.
+ * Certain errors are filtered because they don't fit to any rendered control.
+ * All of them have in common that we don't want to show them in the UI
+ * because controls will show the actual reason why they don't match their correponding sub schema.
+ * - additionalProperties: Indicates that a property is present that is not defined in the schema.
+ *      Jsonforms only allows to edit defined properties. These errors occur if an oneOf doesn't match.
+ * - allOf: Indicates that not all of the allOf definitions match as a whole.
+ * - anyOf: Indicates that an anyOf definition itself is not valid because none of its subschemas matches.
+ * - oneOf: Indicates that an oneOf definition itself is not valid because not exactly one of its subschemas matches.
+ */
+const filteredErrorKeywords = [
+  'additionalProperties',
+  'allOf',
+  'anyOf',
+  'oneOf',
+];
+
+export const formatErrorMessage = (errors: string[]) => {
+  if (errors === undefined || errors === null) {
+    return '';
+  }
+
+  return errors.join('\n');
+};

package/src/{Helpers.ts → util/helpers.ts}

@@ -23,8 +23,9 @@
   THE SOFTWARE.
 */
 
-import { convertToValidClassName, createLabelDescriptionFrom } from './util';
-import type { ControlElement, JsonSchema, LabelDescription } from './models';
+import type { ControlElement, JsonSchema, LabelDescription } from '../models';
+import { createLabelDescriptionFrom } from './label';
+import { convertToValidClassName } from './util';
 
 export const Helpers: {
   createLabelDescriptionFrom(

package/src/util/index.ts

@@ -23,19 +23,16 @@
   THE SOFTWARE.
 */
 
-export * from './array';
-export * from './cell';
-export * from './combinators';
 export * from './Formatted';
 export * from './ids';
 export * from './label';
 export * from './path';
-export * from './renderer';
 export * from './resolvers';
 export * from './runtime';
 export * from './schema';
-export * from './type';
 export * from './uischema';
 export * from './util';
 export * from './validator';
 export * from './defaultDateFormat';
+export * from './errors';
+export * from './helpers';

package/src/util/label.ts

@@ -25,28 +25,8 @@
 
 import startCase from 'lodash/startCase';
 
-import {
-  ControlElement,
-  JsonSchema,
-  LabelDescription,
-  UISchemaElement,
-} from '../models';
+import { ControlElement, JsonSchema, LabelDescription } from '../models';
 import { decode } from './path';
-import { getI18nKeyPrefix, Translator } from '../i18n';
-import { Resolve } from './util';
-import {
-  getFirstPrimitiveProp,
-  isEnumSchema,
-  isOneOfEnumSchema,
-} from './schema';
-import get from 'lodash/get';
-import { findUiControl, getPropPath } from './uischema';
-import {
-  EnumOption,
-  enumToEnumOptionMapper,
-  oneOfToEnumOptionMapper,
-} from './renderer';
-import isEqual from 'lodash/isEqual';
 
 const deriveLabel = (
   controlElement: ControlElement,
@@ -101,80 +81,3 @@ const labelDescription = (text: string, show: boolean): LabelDescription => ({
   text: text,
   show: show,
 });
-
-/**
- * Compute the child label title for array based controls
- * @param data the data of the control
- * @param childPath the child path
- * @param childLabelProp the dotted path to the value used as child label
- * @param {JsonSchema} schema the json schema for this control
- * @param {JsonSchema} rootSchema the root json schema
- * @param {Translator} translateFct the translator fonction
- * @param {UISchemaElement} uiSchema the uiSchema of the control
- */
-export const computeChildLabel = (
-  data: any,
-  childPath: string,
-  childLabelProp: string,
-  schema: JsonSchema,
-  rootSchema: JsonSchema,
-  translateFct: Translator,
-  uiSchema: UISchemaElement
-): string => {
-  const childData = Resolve.data(data, childPath);
-
-  if (!childLabelProp) {
-    childLabelProp = getFirstPrimitiveProp(schema);
-  }
-
-  // return early in case there is no prop we can query
-  if (!childLabelProp) {
-    return '';
-  }
-
-  const currentValue = get(childData, childLabelProp);
-
-  // in case there is no value, then we can't map it to an enum or oneOf
-  if (currentValue === undefined) {
-    return '';
-  }
-
-  // check whether the value is part of a oneOf or enum and needs to be translated
-  const childSchema = Resolve.schema(
-    schema,
-    '#' + getPropPath(childLabelProp),
-    rootSchema
-  );
-
-  let enumOption: EnumOption = undefined;
-  if (isEnumSchema(childSchema)) {
-    enumOption = enumToEnumOptionMapper(
-      currentValue,
-      translateFct,
-      getI18nKeyPrefix(
-        childSchema,
-        findUiControl(uiSchema, childLabelProp),
-        childPath + '.' + childLabelProp
-      )
-    );
-  } else if (isOneOfEnumSchema(childSchema)) {
-    const oneOfArray = childSchema.oneOf as JsonSchema[];
-    const oneOfSchema = oneOfArray.find((e: JsonSchema) =>
-      isEqual(e.const, currentValue)
-    );
-
-    if (oneOfSchema) {
-      enumOption = oneOfToEnumOptionMapper(
-        oneOfSchema,
-        translateFct,
-        getI18nKeyPrefix(
-          oneOfSchema,
-          undefined,
-          childPath + '.' + childLabelProp
-        )
-      );
-    }
-  }
-
-  return enumOption ? enumOption.label : currentValue;
-};

package/src/util/path.ts

@@ -25,7 +25,6 @@
 
 import isEmpty from 'lodash/isEmpty';
 import range from 'lodash/range';
-import { isScoped, Scopable } from '../models';
 
 export const compose = (path1: string, path2: string) => {
   let p1 = path1;
@@ -85,20 +84,6 @@ export const toDataPath = (schemaPath: string): string => {
   return toDataPathSegments(schemaPath).join('.');
 };
 
-export const composeWithUi = (scopableUi: Scopable, path: string): string => {
-  if (!isScoped(scopableUi)) {
-    return path ?? '';
-  }
-
-  const segments = toDataPathSegments(scopableUi.scope);
-
-  if (isEmpty(segments)) {
-    return path ?? '';
-  }
-
-  return compose(path, segments.join('.'));
-};
-
 /**
  * Encodes the given segment to be used as part of a JSON Pointer
  *
@@ -111,3 +96,15 @@ export const encode = (segment: string) =>
  */
 export const decode = (pointerSegment: string) =>
   pointerSegment?.replace(/~1/g, '/').replace(/~0/, '~');
+
+/**
+ * Transform a dotted path to a uiSchema properties path
+ * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
+ * @return the uiSchema properties path (i.e. /properties/articles/properties/comment/properties/author)
+ */
+export const getPropPath = (path: string): string => {
+  return `/properties/${path
+    .split('.')
+    .map((p) => encode(p))
+    .join('/properties/')}`;
+};

package/src/util/runtime.ts

@@ -27,7 +27,6 @@ import has from 'lodash/has';
 import {
   AndCondition,
   Condition,
-  JsonSchema,
   LeafCondition,
   OrCondition,
   RuleEffect,
@@ -36,10 +35,8 @@ import {
   UISchemaElement,
 } from '../models';
 import { resolveData } from './resolvers';
-import { composeWithUi } from './path';
 import type Ajv from 'ajv';
-import { getAjv } from '../reducers';
-import type { JsonFormsState } from '../store';
+import { composeWithUi } from './uischema';
 
 const isOrCondition = (condition: Condition): condition is OrCondition =>
   condition.type === 'OR';
@@ -184,43 +181,3 @@ export const isEnabled = (
 
   return true;
 };
-
-/**
- * Indicates whether the given `uischema` element shall be enabled or disabled.
- * Checks the global readonly flag, uischema rule, uischema options (including the config),
- * the schema and the enablement indicator of the parent.
- */
-export const isInherentlyEnabled = (
-  state: JsonFormsState,
-  ownProps: any,
-  uischema: UISchemaElement,
-  schema: (JsonSchema & { readOnly?: boolean }) | undefined,
-  rootData: any,
-  config: any
-) => {
-  if (state?.jsonforms?.readonly) {
-    return false;
-  }
-  if (uischema && hasEnableRule(uischema)) {
-    return isEnabled(uischema, rootData, ownProps?.path, getAjv(state));
-  }
-  if (typeof uischema?.options?.readonly === 'boolean') {
-    return !uischema.options.readonly;
-  }
-  if (typeof uischema?.options?.readOnly === 'boolean') {
-    return !uischema.options.readOnly;
-  }
-  if (typeof config?.readonly === 'boolean') {
-    return !config.readonly;
-  }
-  if (typeof config?.readOnly === 'boolean') {
-    return !config.readOnly;
-  }
-  if (schema?.readOnly === true) {
-    return false;
-  }
-  if (typeof ownProps?.enabled === 'boolean') {
-    return ownProps.enabled;
-  }
-  return true;
-};

package/src/util/schema.ts

@@ -24,7 +24,7 @@
 */
 
 import find from 'lodash/find';
-import { JsonSchema } from '../models';
+import type { JsonSchema } from '../models';
 
 export const getFirstPrimitiveProp = (schema: any) => {
   if (schema.properties) {

package/src/util/uischema.ts

@@ -25,12 +25,17 @@
 
 import isEmpty from 'lodash/isEmpty';
 import {
-  isControlElement,
-  isLayout,
-  isScoped,
+  ControlElement,
+  GroupLayout,
+  Internationalizable,
+  Labelable,
+  Labeled,
+  Layout,
+  Scopable,
+  Scoped,
   UISchemaElement,
 } from '../models';
-import { encode } from './path';
+import { compose, getPropPath, toDataPathSegments } from './path';
 
 export type IterateCallback = (uischema: UISchemaElement) => void;
 
@@ -62,18 +67,6 @@ export const iterateSchema = (
   toApply(uischema);
 };
 
-/**
- * Transform a dotted path to a uiSchema properties path
- * @param path a dotted prop path to a schema value (i.e. articles.comment.author)
- * @return the uiSchema properties path (i.e. /properties/articles/properties/comment/properties/author)
- */
-export const getPropPath = (path: string): string => {
-  return `/properties/${path
-    .split('.')
-    .map((p) => encode(p))
-    .join('/properties/')}`;
-};
-
 /**
  * Find a control in a uiSchema, based on the dotted path of the schema value
  * @param {UISchemaElement} uiSchema the uiSchema to search from
@@ -101,3 +94,46 @@ export const findUiControl = (
 
   return undefined;
 };
+
+export const composeWithUi = (scopableUi: Scopable, path: string): string => {
+  if (!isScoped(scopableUi)) {
+    return path ?? '';
+  }
+
+  const segments = toDataPathSegments(scopableUi.scope);
+
+  if (isEmpty(segments)) {
+    return path ?? '';
+  }
+
+  return compose(path, segments.join('.'));
+};
+
+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 Labelable =>
+  !!obj && typeof obj === 'object';
+
+export const isLabeled = <T = never>(obj: unknown): obj is Labeled<T> =>
+  isLabelable(obj) && ['string', 'boolean'].includes(typeof obj.label);
+
+export const isControlElement = (
+  uiSchema: UISchemaElement
+): uiSchema is ControlElement => uiSchema.type === 'Control';

package/src/util/util.ts

@@ -27,11 +27,11 @@ import isEmpty from 'lodash/isEmpty';
 import isArray from 'lodash/isArray';
 import includes from 'lodash/includes';
 import find from 'lodash/find';
-import type { JsonSchema, Scoped, UISchemaElement } from '..';
 import { resolveData, resolveSchema } from './resolvers';
 import { composePaths, toDataPathSegments } from './path';
 import { isEnabled, isVisible } from './runtime';
 import type Ajv from 'ajv';
+import type { JsonSchema, Scoped, UISchemaElement } from '../models';
 
 /**
  * Returns the string representation of the given date. The format of the output string can be specified:
@@ -86,14 +86,6 @@ export const convertDateToString = (
 export const convertToValidClassName = (s: string): string =>
   s.replace('#', 'root').replace(new RegExp('/', 'g'), '_');
 
-export const formatErrorMessage = (errors: string[]) => {
-  if (errors === undefined || errors === null) {
-    return '';
-  }
-
-  return errors.join('\n');
-};
-
 export const hasType = (jsonSchema: JsonSchema, expected: string): boolean => {
   return includes(deriveTypes(jsonSchema), expected);
 };

package/src/util/validator.ts

@@ -24,7 +24,7 @@
 */
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
-import type { Options } from 'ajv';
+import type { ErrorObject, Options, ValidateFunction } from 'ajv';
 
 export const createAjv = (options?: Options) => {
   const ajv = new Ajv({
@@ -37,3 +37,17 @@ export const createAjv = (options?: Options) => {
   addFormats(ajv);
   return ajv;
 };
+
+export const validate = (
+  validator: ValidateFunction | undefined,
+  data: any
+): ErrorObject[] => {
+  if (validator === undefined) {
+    return [];
+  }
+  const valid = validator(data);
+  if (valid) {
+    return [];
+  }
+  return validator.errors;
+};

package/lib/reducers/selectors.d.ts

@@ -1,15 +0,0 @@
-import type Ajv from 'ajv';
-import type { JsonFormsState } from '../store';
-import type { JsonSchema, UISchemaElement } from '../models';
-import { JsonFormsDefaultDataRegistryEntry } from './default-data';
-import type { JsonFormsRendererRegistryEntry } from './renderers';
-import type { JsonFormsCellRendererRegistryEntry } from './cells';
-import type { JsonFormsUISchemaRegistryEntry } from './uischemas';
-export declare const getData: (state: JsonFormsState) => any;
-export declare const getSchema: (state: JsonFormsState) => JsonSchema;
-export declare const getUiSchema: (state: JsonFormsState) => UISchemaElement;
-export declare const getAjv: (state: JsonFormsState) => Ajv;
-export declare const getDefaultData: (state: JsonFormsState) => JsonFormsDefaultDataRegistryEntry[];
-export declare const getRenderers: (state: JsonFormsState) => JsonFormsRendererRegistryEntry[];
-export declare const getCells: (state: JsonFormsState) => JsonFormsCellRendererRegistryEntry[];
-export declare const getUISchemas: (state: JsonFormsState) => JsonFormsUISchemaRegistryEntry[];

package/lib/util/array.d.ts

@@ -1,3 +0,0 @@
-declare const moveUp: (array: any[], toMove: number) => void;
-declare const moveDown: (array: any[], toMove: number) => void;
-export { moveUp, moveDown };

package/src/reducers/selectors.ts

@@ -1,64 +0,0 @@
-/*
-  The MIT License
-  
-  Copyright (c) 2017-2019 EclipseSource Munich
-  https://github.com/eclipsesource/jsonforms
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-  
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
-*/
-
-import get from 'lodash/get';
-import type Ajv from 'ajv';
-import type { JsonFormsState } from '../store';
-import type { JsonSchema, UISchemaElement } from '../models';
-import {
-  extractAjv,
-  extractData,
-  extractSchema,
-  extractUiSchema,
-} from './core';
-import {
-  extractDefaultData,
-  JsonFormsDefaultDataRegistryEntry,
-} from './default-data';
-import type { JsonFormsRendererRegistryEntry } from './renderers';
-import type { JsonFormsCellRendererRegistryEntry } from './cells';
-import type { JsonFormsUISchemaRegistryEntry } from './uischemas';
-
-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 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');