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

package/src/util/schema.ts

@@ -24,10 +24,11 @@
 */
 
 import find from 'lodash/find';
+import { JsonSchema } from '../models';
 
 export const getFirstPrimitiveProp = (schema: any) => {
   if (schema.properties) {
-    return find(Object.keys(schema.properties), propName => {
+    return find(Object.keys(schema.properties), (propName) => {
       const prop = schema.properties[propName];
       return (
         prop.type === 'string' ||
@@ -38,3 +39,11 @@ export const getFirstPrimitiveProp = (schema: any) => {
   }
   return undefined;
 };
+
+/**
+ * Tests whether the schema has an enum based on oneOf.
+ */
+export const isOneOfEnumSchema = (schema: JsonSchema) =>
+  schema?.hasOwnProperty('oneOf') &&
+  schema?.oneOf &&
+  (schema.oneOf as JsonSchema[]).every((s) => s.const !== undefined);

package/src/util/type.ts

@@ -62,7 +62,9 @@ export interface AnyAction extends Action {
  * @template A The type of things (actions or otherwise) which may be
  *   dispatched.
  */
-export type Dispatch<A extends Action = AnyAction> = <T extends A>(action: T) => T;
+export type Dispatch<A extends Action = AnyAction> = <T extends A>(
+  action: T
+) => T;
 
 // Copied from https://github.com/reduxjs/redux/blob/master/src/types/store.ts
 /**
@@ -171,7 +173,7 @@ export type Observable<T> = {
    * emission of values from the observable.
    */
   subscribe(observer: Observer<T>): { unsubscribe: Unsubscribe };
-  [Symbol.observable](): Observable<T>
+  [Symbol.observable](): Observable<T>;
 };
 
 // Copied from https://github.com/reduxjs/redux/blob/master/src/types/store.ts
@@ -180,7 +182,7 @@ export type Observable<T> = {
  * an argument to subscribe.
  */
 export type Observer<T> = {
-  next?(value: T): void
+  next?(value: T): void;
 };
 
 // Copied from https://github.com/reduxjs/redux/blob/master/src/types/reducers.ts

package/src/util/uischema.ts

@@ -28,14 +28,14 @@ import { isLayout, UISchemaElement } from '../models';
 
 export type IterateCallback = (uischema: UISchemaElement) => void;
 
-const setReadonlyPropertyValue = (value: boolean): IterateCallback => (
-  child: UISchemaElement
-): void => {
-  if (!child.options) {
-    child.options = {};
-  }
-  child.options.readonly = value;
-};
+const setReadonlyPropertyValue =
+  (value: boolean): IterateCallback =>
+  (child: UISchemaElement): void => {
+    if (!child.options) {
+      child.options = {};
+    }
+    child.options.readonly = value;
+  };
 export const setReadonly = (uischema: UISchemaElement): void => {
   iterateSchema(uischema, setReadonlyPropertyValue(true));
 };
@@ -50,7 +50,7 @@ export const iterateSchema = (
     return;
   }
   if (isLayout(uischema)) {
-    uischema.elements.forEach(child => iterateSchema(child, toApply));
+    uischema.elements.forEach((child) => iterateSchema(child, toApply));
     return;
   }
   toApply(uischema);

package/src/util/util.ts

@@ -41,87 +41,87 @@ import type Ajv from 'ajv';
  * @returns {string} the escaped string
  */
 export const convertToValidClassName = (s: string): string =>
-s.replace('#', 'root').replace(new RegExp('/', 'g'), '_');
+  s.replace('#', 'root').replace(new RegExp('/', 'g'), '_');
 
 export const formatErrorMessage = (errors: string[]) => {
- if (errors === undefined || errors === null) {
-   return '';
- }
+  if (errors === undefined || errors === null) {
+    return '';
+  }
 
- return errors.join('\n');
+  return errors.join('\n');
 };
 
 export const hasType = (jsonSchema: JsonSchema, expected: string): boolean => {
- return includes(deriveTypes(jsonSchema), expected);
+  return includes(deriveTypes(jsonSchema), expected);
 };
 
 /**
  * Derives the type of the jsonSchema element
  */
 export const deriveTypes = (jsonSchema: JsonSchema): string[] => {
- if (isEmpty(jsonSchema)) {
-   return [];
- }
- if (!isEmpty(jsonSchema.type) && typeof jsonSchema.type === 'string') {
-   return [jsonSchema.type];
- }
- if (isArray(jsonSchema.type)) {
-   return jsonSchema.type;
- }
- if (
-   !isEmpty(jsonSchema.properties) ||
-   !isEmpty(jsonSchema.additionalProperties)
- ) {
-   return ['object'];
- }
- if (!isEmpty(jsonSchema.items)) {
-   return ['array'];
- }
+  if (isEmpty(jsonSchema)) {
+    return [];
+  }
+  if (!isEmpty(jsonSchema.type) && typeof jsonSchema.type === 'string') {
+    return [jsonSchema.type];
+  }
+  if (isArray(jsonSchema.type)) {
+    return jsonSchema.type;
+  }
+  if (
+    !isEmpty(jsonSchema.properties) ||
+    !isEmpty(jsonSchema.additionalProperties)
+  ) {
+    return ['object'];
+  }
+  if (!isEmpty(jsonSchema.items)) {
+    return ['array'];
+  }
 
- if (!isEmpty(jsonSchema.allOf)) {
-   const allOfType = find(
-     jsonSchema.allOf,
-     (schema: JsonSchema) => deriveTypes(schema).length !== 0
-   );
+  if (!isEmpty(jsonSchema.allOf)) {
+    const allOfType = find(
+      jsonSchema.allOf,
+      (schema: JsonSchema) => deriveTypes(schema).length !== 0
+    );
 
-   if (allOfType) {
-     return deriveTypes(allOfType);
-   }
- }
- // ignore all remaining cases
- return [];
+    if (allOfType) {
+      return deriveTypes(allOfType);
+    }
+  }
+  // ignore all remaining cases
+  return [];
 };
 
 /**
  * Convenience wrapper around resolveData and resolveSchema.
  */
 export const Resolve: {
- schema(
-   schema: JsonSchema,
-   schemaPath: string,
-   rootSchema: JsonSchema
- ): JsonSchema;
- data(data: any, path: string): any;
+  schema(
+    schema: JsonSchema,
+    schemaPath: string,
+    rootSchema: JsonSchema
+  ): JsonSchema;
+  data(data: any, path: string): any;
 } = {
- schema: resolveSchema,
- data: resolveData
+  schema: resolveSchema,
+  data: resolveData,
 };
 
 // Paths --
 const fromScoped = (scopable: Scoped): string =>
- toDataPathSegments(scopable.scope).join('.');
+  toDataPathSegments(scopable.scope).join('.');
 
 export const Paths = {
- compose: composePaths,
- fromScoped
+  compose: composePaths,
+  fromScoped,
 };
 
 // Runtime --
 export const Runtime = {
- isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean {
-   return isEnabled(uischema, data, undefined, ajv);
- },
- isVisible(uischema: UISchemaElement, data: any, ajv: Ajv): boolean {
-   return isVisible(uischema, data, undefined, ajv);
- }
+  isEnabled(uischema: UISchemaElement, data: any, ajv: Ajv): boolean {
+    return isEnabled(uischema, data, undefined, ajv);
+  },
+  isVisible(uischema: UISchemaElement, data: any, ajv: Ajv): boolean {
+    return isVisible(uischema, data, undefined, ajv);
+  },
 };

package/src/util/validator.ts

@@ -31,7 +31,7 @@ export const createAjv = (options?: Options) => {
     allErrors: true,
     verbose: true,
     strict: false,
-    ...options
+    ...options,
   });
   addFormats(ajv);
   return ajv;