@jsonforms/core 3.0.0-alpha.0 → 3.0.0-beta.0

package/src/testers/index.ts

@@ -22,520 +22,5 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
-import isEmpty from 'lodash/isEmpty';
-import get from 'lodash/get';
-import endsWith from 'lodash/endsWith';
-import last from 'lodash/last';
-import isArray from 'lodash/isArray';
-import reduce from 'lodash/reduce';
-import toPairs from 'lodash/toPairs';
-import includes from 'lodash/includes';
-import { JsonSchema } from '../models/jsonSchema';
-import {
-  Categorization,
-  ControlElement,
-  UISchemaElement
-} from '../models/uischema';
-import { resolveSchema } from '../util/resolvers';
-import { deriveTypes, hasType } from '../util';
 
-/**
- * Constant that indicates that a tester is not capable of handling
- * a combination of schema/data.
- * @type {number}
- */
-export const NOT_APPLICABLE = -1;
-/**
- * A tester is a function that receives an UI schema and a JSON schema and returns a boolean.
- */
-export type Tester = (uischema: UISchemaElement, schema: JsonSchema) => boolean;
-
-/**
- * A ranked tester associates a tester with a number.
- */
-export type RankedTester = (
-  uischema: UISchemaElement,
-  schema: JsonSchema
-) => number;
-
-export const isControl = (uischema: any): uischema is ControlElement =>
-  !isEmpty(uischema) && uischema.scope !== undefined;
-
-/**
- * Only applicable for Controls.
- *
- * This function checks whether the given UI schema is of type Control
- * and if so, resolves the sub-schema referenced by the control and applies
- * the given predicate
- *
- * @param {(JsonSchema) => boolean} predicate the predicate that should be
- *        applied to the resolved sub-schema
- */
-export const schemaMatches = (
-  predicate: (schema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema): boolean => {
-  if (isEmpty(uischema) || !isControl(uischema)) {
-    return false;
-  }
-  if (isEmpty(schema)) {
-    return false;
-  }
-  const schemaPath = uischema.scope;
-  if (isEmpty(schemaPath)) {
-    return false;
-  }
-  let currentDataSchema = schema;
-  if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath);
-  }
-  if (currentDataSchema === undefined) {
-    return false;
-  }
-
-  return predicate(currentDataSchema);
-};
-
-export const schemaSubPathMatches = (
-  subPath: string,
-  predicate: (schema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema): boolean => {
-  if (isEmpty(uischema) || !isControl(uischema)) {
-    return false;
-  }
-  const schemaPath = uischema.scope;
-  let currentDataSchema: JsonSchema = schema;
-  if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath);
-  }
-  currentDataSchema = get(currentDataSchema, subPath);
-
-  if (currentDataSchema === undefined) {
-    return false;
-  }
-
-  return predicate(currentDataSchema);
-};
-
-/**
- * Only applicable for Controls.
- *
- * This function checks whether the given UI schema is of type Control
- * and if so, resolves the sub-schema referenced by the control and checks
- * whether the type of the sub-schema matches the expected one.
- *
- * @param {string} expectedType the expected type of the resolved sub-schema
- */
-export const schemaTypeIs = (expectedType: string): Tester =>
-  schemaMatches(schema => !isEmpty(schema) && hasType(schema, expectedType));
-
-/**
- * Only applicable for Controls.
- *
- * This function checks whether the given UI schema is of type Control
- * and if so, resolves the sub-schema referenced by the control and checks
- * whether the format of the sub-schema matches the expected one.
- *
- * @param {string} expectedFormat the expected format of the resolved sub-schema
- */
-export const formatIs = (expectedFormat: string): Tester =>
-  schemaMatches(
-    schema =>
-      !isEmpty(schema) &&
-      schema.format === expectedFormat &&
-      schema.type === 'string'
-  );
-
-/**
- * Checks whether the given UI schema has the expected type.
- *
- * @param {string} expected the expected UI schema type
- */
-export const uiTypeIs = (expected: string): Tester => (
-  uischema: UISchemaElement
-): boolean => !isEmpty(uischema) && uischema.type === expected;
-
-/**
- * Checks whether the given UI schema has an option with the given
- * name and whether it has the expected value. If no options property
- * is set, returns false.
- *
- * @param {string} optionName the name of the option to check
- * @param {any} optionValue the expected value of the option
- */
-export const optionIs = (optionName: string, optionValue: any): Tester => (
-  uischema: UISchemaElement
-): boolean => {
-  if (isEmpty(uischema)) {
-    return false;
-  }
-
-  const options = uischema.options;
-  return !isEmpty(options) && options[optionName] === optionValue;
-};
-
-/**
- * Only applicable for Controls.
- *
- * Checks whether the scope of a control ends with the expected string.
- *
- * @param {string} expected the expected ending of the reference
- */
-export const scopeEndsWith = (expected: string): Tester => (
-  uischema: UISchemaElement
-): boolean => {
-  if (isEmpty(expected) || !isControl(uischema)) {
-    return false;
-  }
-
-  return endsWith(uischema.scope, expected);
-};
-
-/**
- * Only applicable for Controls.
- *
- * Checks whether the last segment of the scope matches the expected string.
- *
- * @param {string} expected the expected ending of the reference
- */
-export const scopeEndIs = (expected: string): Tester => (
-  uischema: UISchemaElement
-): boolean => {
-  if (isEmpty(expected) || !isControl(uischema)) {
-    return false;
-  }
-  const schemaPath = uischema.scope;
-
-  return !isEmpty(schemaPath) && last(schemaPath.split('/')) === expected;
-};
-
-/**
- * A tester that allow composing other testers by && them.
- *
- * @param {Array<Tester>} testers the testers to be composed
- */
-export const and = (...testers: Tester[]): Tester => (
-  uischema: UISchemaElement,
-  schema: JsonSchema
-) => testers.reduce((acc, tester) => acc && tester(uischema, schema), true);
-
-/**
- * A tester that allow composing other testers by || them.
- *
- * @param {Array<Tester>} testers the testers to be composed
- */
-export const or = (...testers: Tester[]): Tester => (
-  uischema: UISchemaElement,
-  schema: JsonSchema
-) => testers.reduce((acc, tester) => acc || tester(uischema, schema), false);
-/**
- * Create a ranked tester that will associate a number with a given tester, if the
- * latter returns true.
- *
- * @param {number} rank the rank to be returned in case the tester returns true
- * @param {Tester} tester a tester
- */
-export const rankWith = (rank: number, tester: Tester) => (
-  uischema: UISchemaElement,
-  schema: JsonSchema
-): number => {
-  if (tester(uischema, schema)) {
-    return rank;
-  }
-
-  return NOT_APPLICABLE;
-};
-
-export const withIncreasedRank = (by: number, rankedTester: RankedTester) => (
-  uischema: UISchemaElement,
-  schema: JsonSchema
-): number => {
-  const rank = rankedTester(uischema, schema);
-  if (rank === NOT_APPLICABLE) {
-    return NOT_APPLICABLE;
-  }
-
-  return rank + by;
-};
-
-/**
- * Default tester for boolean.
- * @type {RankedTester}
- */
-export const isBooleanControl = and(
-  uiTypeIs('Control'),
-  schemaTypeIs('boolean')
-);
-
-// TODO: rather check for properties property
-export const isObjectControl = and(uiTypeIs('Control'), schemaTypeIs('object'));
-
-export const isAllOfControl = and(
-  uiTypeIs('Control'),
-  schemaMatches(schema => schema.hasOwnProperty('allOf'))
-);
-
-export const isAnyOfControl = and(
-  uiTypeIs('Control'),
-  schemaMatches(schema => schema.hasOwnProperty('anyOf'))
-);
-
-export const isOneOfControl = and(
-  uiTypeIs('Control'),
-  schemaMatches(schema => schema.hasOwnProperty('oneOf'))
-);
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * has a 'date' format.
- * @type {Tester}
- */
-export const isDateControl = and(uiTypeIs('Control'), formatIs('date'));
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * has an enum.
- * @type {Tester}
- */
-export const isEnumControl = and(
-  uiTypeIs('Control'),
-  or(
-    schemaMatches(schema => schema.hasOwnProperty('enum')),
-    schemaMatches(schema => schema.hasOwnProperty('const'))
-  )
-);
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * has an enum based on oneOf.
- * @type {Tester}
- */
-export const isOneOfEnumControl = and(
-  uiTypeIs('Control'),
-  schemaMatches(schema =>
-    schema.hasOwnProperty('oneOf') &&
-    (schema.oneOf as JsonSchema[]).every(s => s.const !== undefined)
-  )
-);
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * is of type integer
- * @type {Tester}
- */
-export const isIntegerControl = and(
-  uiTypeIs('Control'),
-  schemaTypeIs('integer')
-);
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * is of type number
- * @type {Tester}
- */
-export const isNumberControl = and(uiTypeIs('Control'), schemaTypeIs('number'));
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * is of type string
- * @type {Tester}
- */
-export const isStringControl = and(uiTypeIs('Control'), schemaTypeIs('string'));
-
-/**
- * Tests whether the given UI schema is of type Control and if is has
- * a 'multi' option.
- * @type {Tester}
- */
-export const isMultiLineControl = and(
-  uiTypeIs('Control'),
-  optionIs('multi', true)
-);
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * has a 'time' format.
- * @type {Tester}
- */
-export const isTimeControl = and(uiTypeIs('Control'), formatIs('time'));
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * has a 'date-time' format.
- * @type {Tester}
- */
-export const isDateTimeControl = and(
-  uiTypeIs('Control'),
-  formatIs('date-time')
-);
-
-/**
- * Tests whether the given schema is an array of objects.
- * @type {Tester}
- */
-export const isObjectArray = and(
-  schemaMatches(
-    schema => hasType(schema, 'array') && !Array.isArray(schema.items) // we don't care about tuples
-  ),
-  schemaSubPathMatches('items', schema => hasType(schema, 'object'))
-);
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * is an array of objects.
- * @type {Tester}
- */
-export const isObjectArrayControl = and(uiTypeIs('Control'), isObjectArray);
-
-const traverse = (
-  any: JsonSchema | JsonSchema[],
-  pred: (obj: JsonSchema) => boolean
-): boolean => {
-  if (isArray(any)) {
-    return reduce(any, (acc, el) => acc || traverse(el, pred), false);
-  }
-
-  if (pred(any)) {
-    return true;
-  }
-  if (any.items) {
-    return traverse(any.items, pred);
-  }
-  if (any.properties) {
-    return reduce(
-      toPairs(any.properties),
-      (acc, [_key, val]) => acc || traverse(val, pred),
-      false
-    );
-  }
-
-  return false;
-};
-
-export const isObjectArrayWithNesting = (
-  uischema: UISchemaElement,
-  schema: JsonSchema
-): boolean => {
-  if (!uiTypeIs('Control')(uischema, schema)) {
-    return false;
-  }
-  const schemaPath = (uischema as ControlElement).scope;
-  const resolvedSchema = resolveSchema(schema, schemaPath);
-  const wantedNestingByType: { [key: string]: number } = {
-    object: 2,
-    array: 1
-  };
-  if (resolvedSchema !== undefined && resolvedSchema.items !== undefined) {
-    // check if nested arrays
-    if (
-      traverse(resolvedSchema.items, val => {
-        if (val === schema) {
-          return false;
-        }
-        // we don't support multiple types
-        if (typeof val.type !== 'string') {
-          return true;
-        }
-        const typeCount = wantedNestingByType[val.type];
-        if (typeCount === undefined) {
-          return false;
-        }
-        wantedNestingByType[val.type] = typeCount - 1;
-        return wantedNestingByType[val.type] === 0;
-      })
-    ) {
-      return true;
-    }
-    // check if uischema options detail is set
-    if (uischema.options && uischema.options.detail) {
-      if (typeof uischema.options.detail === 'string') {
-        return uischema.options.detail.toUpperCase() !== 'DEFAULT';
-      } else if (
-        typeof uischema.options.detail === 'object' &&
-        uischema.options.detail.type
-      ) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-
-/**
- * Synonym for isObjectArrayControl
- */
-export const isArrayObjectControl = isObjectArrayControl;
-
-/**
- * Tests whether the given UI schema is of type Control and if the schema
- * is an array of a primitive type.
- * @type {Tester}
- */
-export const isPrimitiveArrayControl = and(
-  uiTypeIs('Control'),
-  schemaMatches(
-    schema => deriveTypes(schema).length !== 0 && !Array.isArray(schema.items) // we don't care about tuples
-  ),
-  schemaSubPathMatches('items', schema => {
-    const types = deriveTypes(schema);
-    return (
-      types.length === 1 &&
-      includes(['integer', 'number', 'boolean', 'string'], types[0])
-    );
-  })
-);
-
-/**
- * Tests whether a given UI schema is of type Control,
- * if the schema is of type number or integer and
- * whether the schema defines a numerical range with a default value.
- * @type {Tester}
- */
-export const isRangeControl = and(
-  uiTypeIs('Control'),
-  or(schemaTypeIs('number'), schemaTypeIs('integer')),
-  schemaMatches(
-    schema =>
-      schema.hasOwnProperty('maximum') &&
-      schema.hasOwnProperty('minimum') &&
-      schema.hasOwnProperty('default')
-  ),
-  optionIs('slider', true)
-);
-
-/**
- * Tests whether the given UI schema is of type Control, if the schema
- * is of type string and has option format
- * @type {Tester}
- */
-export const isNumberFormatControl = and(
-  uiTypeIs('Control'),
-  schemaTypeIs('integer'),
-  optionIs('format', true)
-);
-
-export const isCategorization = (
-  category: UISchemaElement
-): category is Categorization => category.type === 'Categorization';
-
-export const isCategory = (uischema: UISchemaElement): boolean =>
-  uischema.type === 'Category';
-
-export const hasCategory = (categorization: Categorization): boolean => {
-  if (isEmpty(categorization.elements)) {
-    return false;
-  }
-  // all children of the categorization have to be categories
-  return categorization.elements
-    .map(elem =>
-      isCategorization(elem) ? hasCategory(elem) : isCategory(elem)
-    )
-    .reduce((prev, curr) => prev && curr, true);
-};
-
-export const categorizationHasCategory = (uischema: UISchemaElement) =>
-  hasCategory(uischema as Categorization);
-
-export const not = (tester: Tester): Tester => (
-  uischema: UISchemaElement,
-  schema: JsonSchema
-) => !tester(uischema, schema);
+export * from './testers';