@jsonforms/core 2.5.2-alpha.0 → 3.0.0-alpha.2

package/src/util/cell.ts

@@ -22,29 +22,40 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+
 import isEmpty from 'lodash/isEmpty';
 import union from 'lodash/union';
-import { getConfig, getData, getErrorAt, getSchema, getAjv } from '../reducers';
 import {
-  AnyAction,
-  Dispatch,
+  getConfig,
+  getData,
+  getErrorAt,
+  getSchema,
+  getAjv,
+  JsonFormsCellRendererRegistryEntry,
+  getTranslator
+} from '../reducers';
+import { AnyAction, Dispatch } from './type';
+import {
   formatErrorMessage,
-  isEnabled,
-  isVisible,
-  OwnPropsOfControl,
-  OwnPropsOfEnum,
   Resolve,
-  StatePropsOfScopedRenderer
-} from '.';
+} from './util';
+import {
+  isInherentlyEnabled,
+  isVisible,
+} from './runtime';
 import {
   DispatchPropsOfControl,
   EnumOption,
   enumToEnumOptionMapper,
   mapDispatchToControlProps,
+  oneOfToEnumOptionMapper,
+  OwnPropsOfControl,
+  OwnPropsOfEnum,
+  StatePropsOfScopedRenderer,
 } from './renderer';
 import { JsonFormsState } from '../store';
-import { JsonFormsCellRendererRegistryEntry } from '../reducers/cells';
-import { JsonSchema } from '..';
+import { JsonSchema } from '../models';
+import { i18nJsonSchema } from '..';
 
 export { JsonFormsCellRendererRegistryEntry };
 
@@ -109,16 +120,38 @@ export const mapStateToCellProps = (
     ownProps.visible !== undefined
       ? ownProps.visible
       : isVisible(uischema, rootData, undefined, getAjv(state));
-  const readonly = state.jsonforms.readonly;
-  const enabled =
-    !readonly && (ownProps.enabled !== undefined
-      ? ownProps.enabled
-      : isEnabled(uischema, rootData, undefined, getAjv(state)));
+
+  const rootSchema = getSchema(state);
+  const config = getConfig(state);
+
+  /* When determining the enabled state of cells we take a shortcut: At the
+   * moment it's only possible to configure enablement and disablement at the
+   * control level. Therefore the renderer using the cell, for example a 
+   * table renderer, determines whether a cell is enabled and should hand
+   * over the prop themselves. If that prop was given, we prefer it over
+   * anything else to save evaluation effort (except for the global readonly
+   * flag). For example it would be quite expensive to evaluate the same ui schema
+   * rule again and again for each cell of a table. */
+  let enabled;
+  if (state.jsonforms.readonly === true) {
+    enabled = false;
+  } else if (typeof ownProps.enabled === 'boolean') {
+    enabled = ownProps.enabled;
+  } else {
+    enabled = isInherentlyEnabled(
+      state,
+      ownProps,
+      uischema,
+      schema || rootSchema,
+      rootData,
+      config
+    );
+  }
+
   const errors = formatErrorMessage(
     union(getErrorAt(path, schema)(state).map(error => error.message))
   );
   const isValid = isEmpty(errors);
-  const rootSchema = getSchema(state);
 
   return {
     data: Resolve.data(rootData, path),
@@ -165,14 +198,53 @@ export const defaultMapStateToEnumCellProps = (
   const props: StatePropsOfCell = mapStateToCellProps(state, ownProps);
   const options: EnumOption[] =
     ownProps.options ||
-    props.schema.enum?.map(enumToEnumOptionMapper) ||
-    props.schema.const && [enumToEnumOptionMapper(props.schema.const)];
+    props.schema.enum?.map(e =>
+      enumToEnumOptionMapper(
+        e,
+        getTranslator()(state),
+        props.uischema?.options?.i18n ?? (props.schema as i18nJsonSchema).i18n
+      )
+    ) ||
+    (props.schema.const && [
+      enumToEnumOptionMapper(
+        props.schema.const,
+        getTranslator()(state),
+        props.uischema?.options?.i18n ?? (props.schema as i18nJsonSchema).i18n
+      )
+    ]);
+  return {
+    ...props,
+    options
+  };
+};
+
+/**
+ * mapStateToOneOfEnumCellProps for one of enum cell. Options is used for populating dropdown list from oneOf
+ * @param state
+ * @param ownProps
+ * @returns {StatePropsOfEnumCell}
+ */
+export const mapStateToOneOfEnumCellProps = (
+  state: JsonFormsState,
+  ownProps: OwnPropsOfEnumCell
+): StatePropsOfEnumCell => {
+  const props: StatePropsOfCell = mapStateToCellProps(state, ownProps);
+  const options: EnumOption[] =
+    ownProps.options ||
+    (props.schema.oneOf as JsonSchema[])?.map(oneOfSubSchema =>
+      oneOfToEnumOptionMapper(
+        oneOfSubSchema,
+        getTranslator()(state),
+        props.uischema?.options?.i18n
+      )
+    );
   return {
     ...props,
     options
   };
 };
 
+
 /**
  * Synonym for mapDispatchToControlProps.
  *

package/src/util/combinators.ts

@@ -23,11 +23,9 @@
   THE SOFTWARE.
 */
 
-import { JsonSchema } from '../models/jsonSchema';
-import { ControlElement, UISchemaElement } from '../models/uischema';
+import { ControlElement, JsonSchema, UISchemaElement } from '../models';
 import { resolveSchema } from './resolvers';
-import { findUISchema } from '../reducers';
-import { JsonFormsUISchemaRegistryEntry } from '../reducers/uischemas';
+import { findUISchema, JsonFormsUISchemaRegistryEntry } from '../reducers';
 
 export interface CombinatorSubSchemaRenderInfo {
   schema: JsonSchema;

package/src/util/ids.ts

@@ -22,6 +22,7 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+
 const usedIds: Set<string> = new Set<string>();
 
 const makeId = (idBase: string, iteration: number) =>

package/src/util/index.ts

@@ -22,134 +22,19 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
-import isEmpty from 'lodash/isEmpty';
-import isArray from 'lodash/isArray';
-import includes from 'lodash/includes';
-import find from 'lodash/find';
-import { JsonSchema, Scopable, UISchemaElement } from '../';
-import { resolveData, resolveSchema } from './resolvers';
-import {
-  compose as composePaths,
-  composeWithUi,
-  toDataPath,
-  toDataPathSegments
-} from './path';
-import { isEnabled, isVisible } from './runtime';
-import { Ajv } from 'ajv';
 
-export { createCleanLabel, createLabelDescriptionFrom } from './label';
-
-/**
- * Escape the given string such that it can be used as a class name,
- * i.e. hashes and slashes will be replaced.
- *
- * @param {string} s the string that should be converted to a valid class name
- * @returns {string} the escaped string
- */
-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');
-};
-
-const hasType = (jsonSchema: JsonSchema, expected: string): boolean => {
-  return includes(deriveTypes(jsonSchema), expected);
-};
-
-/**
- * Derives the type of the jsonSchema element
- */
-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.allOf)) {
-    const allOfType = find(
-      jsonSchema.allOf,
-      (schema: JsonSchema) => deriveTypes(schema).length !== 0
-    );
-
-    if (allOfType) {
-      return deriveTypes(allOfType);
-    }
-  }
-  // ignore all remaining cases
-  return [];
-};
-
-/**
- * Convenience wrapper around resolveData and resolveSchema.
- */
-const Resolve: {
-  schema(
-    schema: JsonSchema,
-    schemaPath: string,
-    rootSchema?: JsonSchema
-  ): JsonSchema;
-  data(data: any, path: string): any;
-} = {
-  schema: resolveSchema,
-  data: resolveData
-};
-export {
-  resolveData,
-  resolveSchema,
-  findRefs,
-  SchemaRef,
-  SchemaRefs
-} from './resolvers';
-export { Resolve };
-
-// Paths --
-const fromScopable = (scopable: Scopable) =>
-  toDataPathSegments(scopable.scope).join('.');
-
-const Paths = {
-  compose: composePaths,
-  fromScopable
-};
-export { composePaths, composeWithUi, Paths, toDataPath };
-
-// Runtime --
-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);
-  }
-};
-export { isEnabled, isVisible, Runtime, deriveTypes, hasType };
-
-export * from './renderer';
+export * from './array';
 export * from './cell';
-export * from './runtime';
+export * from './combinators';
 export * from './Formatted';
 export * from './ids';
-export * from './validator';
-export * from './combinators';
-export * from './uischema';
-export * from './array';
-export * from './type';
+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';

package/src/util/label.ts

@@ -22,10 +22,10 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+
 import startCase from 'lodash/startCase';
 
-import { ControlElement, LabelDescription } from '../models/uischema';
-import { JsonSchema } from '../models/jsonSchema';
+import { ControlElement, JsonSchema, LabelDescription } from '../models';
 
 const deriveLabel = (
   controlElement: ControlElement,

package/src/util/path.ts

@@ -22,9 +22,10 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+
 import isEmpty from 'lodash/isEmpty';
 import range from 'lodash/range';
-import { Scopable } from '../';
+import { Scopable } from '../models';
 
 export const compose = (path1: string, path2: string) => {
   let p1 = path1;
@@ -41,6 +42,8 @@ export const compose = (path1: string, path2: string) => {
   }
 };
 
+export { compose as composePaths };
+
 /**
  * Convert a schema path (i.e. JSON pointer) to an array by splitting
  * at the '/' character and removing all schema-specific keywords.