@earthranger/react-native-jsonforms-formatter 0.1.0 → 1.0.0

package/src/generateUISchema.ts

@@ -1,164 +0,0 @@
-// External Dependencies
-import { isEmpty } from 'lodash-es';
-
-// Internal Dependencies
-import {
-  DateTimeFormat,
-  ElementDisplay,
-  getFieldSetTitleKey,
-  isFieldSet,
-  isFieldSetTitleWithoutItems, isPropertyKey,
-  isSchemaFieldSet, PropertyFormat,
-} from './utils/utils';
-
-// Enums
-enum SchemaTypes {
-  Number = 'number',
-  String = 'string',
-  Array = 'array',
-}
-
-const getBaseUIObject = (key: string, title: string, options: any = {}) => (
-  {
-    type: 'Control',
-    scope: `#/properties/${key}`,
-    label: title,
-    ...options && { options },
-  });
-
-const getDateTimeControlFormat = (key: string, jsonSchema: any, fieldSetItem: any = undefined) => {
-  try {
-    const definitionObject = fieldSetItem
-      || jsonSchema.definition.find((object: any) => (object.key === key));
-
-    if (definitionObject.fieldHtmlClass === 'date-time-picker json-schema'
-      || (definitionObject && (definitionObject.type || '') === 'datetime')) {
-      if (jsonSchema.schema.properties[key].format === 'date') {
-        return DateTimeFormat.Date;
-      }
-      return DateTimeFormat.DateTime;
-    }
-    if (definitionObject.fieldHtmlClass === 'date-picker json-schema'
-      || jsonSchema.schema.properties[key].format === 'date') {
-      return DateTimeFormat.Date;
-    }
-  } catch {
-    return undefined;
-  }
-  return undefined;
-};
-
-export const generateUISchema = (schema: any) => {
-  const elements: Object[] = [];
-
-  if (isSchemaFieldSet(schema.definition)) {
-    elements.push(...getFieldSetsElements(schema));
-  } else {
-    Object.keys(schema.schema.properties).forEach((key: string) => {
-      const element = getUIElement(key, schema);
-      if (element) {
-        elements.push(element);
-      }
-    });
-  }
-  return {
-    type: 'Category',
-    elements,
-  };
-};
-
-const getFieldSetsElements = (schema: any) => {
-  const elements: Object[] = [];
-
-  schema.definition.forEach((item: any) => {
-    if (typeof item === 'string') {
-      elements.push(getBaseUIObject(item, schema.schema.properties[item].title || ''));
-    } else if (item instanceof Object) {
-      switch (true) {
-        case isFieldSetTitleWithoutItems(item):
-          elements.push(getBaseUIObject(
-            getFieldSetTitleKey(item.title),
-            item.title,
-            getElementOptions(PropertyFormat.FormLabel),
-          ));
-          break;
-        case isFieldSet(item):
-          if (item.title) {
-            elements.push(getBaseUIObject(
-              getFieldSetTitleKey(item.title),
-              item.title,
-              getElementOptions(PropertyFormat.FormLabel),
-            ));
-          }
-          item.items.forEach((value: any) => {
-            if (value instanceof Object) {
-              const element = getUIElement(value.key || '', schema, value);
-              if (element) {
-                elements.push(element);
-              }
-            } else if (typeof value === 'string') {
-              const element = getUIElement(value, schema);
-              if (element) {
-                elements.push(element);
-              }
-            }
-          });
-          break;
-        case isPropertyKey(item):
-          // eslint-disable-next-line no-case-declarations
-          const element = getUIElement(item.key, schema);
-          if (element) {
-            elements.push(element);
-          }
-          break;
-        default:
-          break;
-      }
-    }
-  });
-  return elements;
-};
-
-const getElementOptions = (format: string = '', display: string = '') => {
-  if (isEmpty(format)) {
-    return {};
-  }
-  const options = { format };
-  if (!isEmpty(display)) {
-    // @ts-ignore
-    options.display = display;
-  }
-  return options;
-};
-
-const getUIElement = (key: string, schema: any, fieldSetItem: any = undefined) => {
-  let options = {};
-  switch (schema.schema.properties[key].type as SchemaTypes) {
-    case SchemaTypes.Number:
-      return getBaseUIObject(key, schema.schema.properties[key].title || '');
-
-    case SchemaTypes.String:
-      // eslint-disable-next-line no-case-declarations
-      const dateTimeFormat = getDateTimeControlFormat(key, schema, fieldSetItem);
-      if (!isEmpty(dateTimeFormat)) {
-        options = getElementOptions(PropertyFormat.DateTime, dateTimeFormat);
-      } else if (schema.schema.properties[key].display
-        && schema.schema.properties[key].display === ElementDisplay.Header) {
-        options = getElementOptions(PropertyFormat.FormLabel);
-      }
-      return getBaseUIObject(key, schema.schema.properties[key].title || '', options);
-
-    case SchemaTypes.Array:
-      if (schema.schema.properties[key].items.enum
-        && schema.schema.properties[key].items.enumNames) {
-        options = getElementOptions(PropertyFormat.MultiSelect);
-      } else if (schema.schema.properties[key].items) {
-        options = getElementOptions(PropertyFormat.RepeatableField);
-      }
-      return getBaseUIObject(key, schema.schema.properties[key].title || '', options);
-    default:
-      break;
-  }
-
-  return undefined;
-};

package/src/utils/utils.ts

@@ -1,83 +0,0 @@
-/* eslint-disable import/no-named-as-default */
-// External Dependencies
-import { isEmpty } from 'lodash-es';
-
-export enum DateTimeFormat {
-  DateTime = 'date-time',
-  Date = 'date',
-}
-
-export enum PropertyFormat {
-  DateTime = 'date-time',
-  MultiSelect = 'multiselect',
-  RepeatableField = 'repeatable-field',
-  FormLabel = 'form-label',
-}
-
-export enum ElementDisplay {
-  Header = 'header',
-}
-
-export const FIELD_SET = 'fieldset';
-export const HELP_VALUE = 'helpvalue';
-
-export const REQUIRED_PROPERTY = 'required';
-export const CHECKBOXES = 'checkboxes';
-export const INACTIVE_ENUM = 'inactive_enum';
-export const DISABLED_ENUM = 'inactive_titleMap';
-export const STRING_TYPE = 'string';
-export const ARRAY_TYPE = 'array';
-
-export const isObject = (item: any) => item instanceof Object;
-
-export const isString = (item: any) => typeof item === STRING_TYPE;
-export const isSchemaFieldSet = (definition: any[]) => {
-  if (definition.length === 0) {
-    return false;
-  }
-  const fieldSet = definition.find((item: any) => isObject(item)
-    && item && (item.type || '') === FIELD_SET);
-  return fieldSet !== undefined;
-};
-
-export const isFieldSetTitle = (item: any) => isObject(item) && item.type === FIELD_SET
-  && !isEmpty(item.title);
-
-export const isFieldSetTitleWithoutItems = (item: any) => isObject(item) && item.type === FIELD_SET
-  && item.items.length === 0 && !isEmpty(item.title);
-
-export const isFieldSet = (item: any) => isObject(item) && item.type === FIELD_SET && item.items.length > 0;
-
-export const isCheckbox = (item: any) => isObject(item) && item.type === CHECKBOXES;
-
-export const isPropertyKey = (item: any) => !isEmpty(item.key);
-
-export const getFieldSetTitleKey = (title: string) => {
-  const key = title.toLowerCase().replace(/[\s\\/\\%]/gi, '_');
-  return `fieldset__title_${key}`;
-};
-
-export const getSchemaValidations = (stringSchema: string) => ({
-  hasCheckboxes: hasCheckboxes(stringSchema),
-  hasInactiveChoices: hasInactiveChoices(stringSchema),
-  hasDisabledChoices: hasDisabledChoices(stringSchema),
-});
-
-export const isArrayProperty = (property: any) => property.type === ARRAY_TYPE && !property.items?.enum
-&& !property.items?.enumNames;
-
-export const isRequiredProperty = (property: any) => property.required === 'true' || property.required > 0;
-
-const hasCheckboxes = (stringSchema: string) => stringSchema.includes(CHECKBOXES);
-
-const hasInactiveChoices = (stringSchema: string) => stringSchema.includes(INACTIVE_ENUM);
-
-const hasDisabledChoices = (stringSchema: string) => stringSchema.includes(DISABLED_ENUM);
-
-export const isInactiveChoice = (item: any) => item.type === STRING_TYPE
- && item.enum?.length > 0 && item.inactive_enum?.length > 0;
-
-export const isDisabledChoice = (item: any) => isObject(item) && item.type === CHECKBOXES && item.inactive_titleMap?.length > 0
-  && item.titleMap?.length > 0;
-
-export const hasEnumDuplicatedItems = (options: string[]) => (new Set(options).size !== options.length);

package/src/validateJsonSchema.ts

@@ -1,275 +0,0 @@
-// Internal Dependencies
-import {
-  ElementDisplay,
-  getFieldSetTitleKey,
-  getSchemaValidations,
-  hasEnumDuplicatedItems,
-  HELP_VALUE,
-  isArrayProperty,
-  isCheckbox,
-  isDisabledChoice,
-  isFieldSet,
-  isFieldSetTitle,
-  isInactiveChoice,
-  isObject,
-  isPropertyKey,
-  isRequiredProperty,
-  isSchemaFieldSet,
-  isString,
-  REQUIRED_PROPERTY,
-} from './utils/utils';
-
-const specialCharactersInKey = /[^\w\n\s_"](?=[^:\n\s{}[]]*:[\t\n\s]*(\{|\[)+)/g;
-const emptyEnumRegex = '\\"enum\\"\\n*\\s*\\:\\n*\\s*\\[\\n*\\s*\\]';
-const emptyEnumValue = '"enum": ["0"]';
-const emptyEnumNamesRegex = '\\"enumNames\\"\\n*\\s*\\:\\n*\\s*\\{\\n*\\s*\\}';
-const emptyEnumNamesValue = '"enumNames": {"0":"No Options"}';
-const emptyTitleMapRegex = '\\"titleMap\\"\\n*\\s*\\:\\n*\\s*\\[\\n*\\s*\\]';
-const emptyTitleMapValue = '"titleMap": [{"value":"no_option", "name":"No Option"}]';
-const minParamRegex = /"minimum"(?:[^\\"]|\\\\|\\")*"\d+\.*\d*"/g;
-const maxParamRegex = /"maximum"(?:[^\\"]|\\\\|\\")*"\d+\.*\d*"/g;
-const doubleSingleQuotesRegex = /"(?=[^"]*(?:"[^"]*)?$)/g;
-
-const getSchemaForCheckbox = (
-  definition: any,
-  title: string,
-  required: boolean,
-  defaultValue: string,
-) => ({
-  type: 'array',
-  uniqueItems: true,
-  isHidden: false,
-  ...required && { required },
-  title: title || definition.title,
-  items: {
-    enum: definition.titleMap.map((item: any) => item.value),
-    enumNames: definition.titleMap.map((item: any) => item.name),
-  },
-  ...defaultValue && { default: defaultValue },
-});
-
-const getTitleProperty = (title: string) => ({
-  type: 'string',
-  readOnly: true,
-  isHidden: false,
-  display: ElementDisplay.Header,
-  title,
-});
-
-const getPropertyVisibility = (property: any) => property?.isHidden || false;
-
-const cleanUpRequiredProperty = (schema: any) => {
-  const requiredProperties = [];
-
-  // Iterate over the properties to get clean enum data
-  for (const key of Object.keys(schema.properties)) {
-    const property = schema.properties[key];
-    if (isRequiredProperty(property)) {
-      requiredProperties.push(key);
-      delete schema.properties[key].required;
-    }
-    if (isArrayProperty(property)) {
-      cleanUpRequiredProperty(property.items);
-    }
-  }
-
-  if (requiredProperties.length > 0) {
-    // eslint-disable-next-line no-param-reassign
-    schema.required = requiredProperties;
-  }
-
-  return schema;
-};
-
-const formatDefinitionInSchema = (schema: any) => {
-  if (schema.schema.definition) {
-    const { definition } = schema.schema;
-    delete schema.schema.definition;
-    schema.definition = definition;
-    return schema;
-  }
-  return schema;
-};
-
-const formatSchemaRepeatableFieldLayout = (schema: any) => {
-  const properties: any = {};
-  let headerCount = 0;
-
-  // eslint-disable-next-line no-restricted-syntax
-  for (const item of schema.definition) {
-    if (isString(item)) {
-      properties[item] = schema.schema.properties[item];
-      delete schema.schema.properties[item];
-    } else if (isObject(item)) {
-      if (item.helpvalue) {
-        const property = `help_value_${headerCount}`;
-        headerCount += 1;
-        properties[property] = getTitleProperty((item.helpvalue || '').replace(/(<.+?>)/g, ''));
-      } else if (item.key) {
-        properties[item.key] = schema.schema.properties[item.key];
-        delete schema.schema.properties[item.key];
-      }
-    }
-  }
-
-  schema.schema.properties = Object.assign(properties, schema.schema.properties);
-};
-
-// eslint-disable-next-line max-len
-const cleanUpInactiveEnumChoice = (property: any) => property.enum.filter((choice: any) => !property.inactive_enum.includes(choice));
-
-// eslint-disable-next-line max-len
-const cleanUpDisabledEnumChoice = (definitionItem: any) => definitionItem.titleMap.filter((item: any) => !definitionItem.inactive_titleMap.includes(item.value));
-
-const validateJSON = (stringSchema: string) => {
-  if (stringSchema.match(specialCharactersInKey) !== null) {
-    throw Error('Special characters not supported in JSON Schema');
-  }
-  // Invalid double quotes
-  stringSchema = stringSchema.replace(/([“”])/g, '"');
-  // Empty enum choices
-  stringSchema = stringSchema.replace(new RegExp(emptyEnumRegex, 'g'), emptyEnumValue);
-  // Empty enumNames choices
-  stringSchema = stringSchema.replace(new RegExp(emptyEnumNamesRegex, 'g'), emptyEnumNamesValue);
-  // Empty titleMap choices
-  stringSchema = stringSchema.replace(new RegExp(emptyTitleMapRegex, 'g'), emptyTitleMapValue);
-  // Numeric ranges
-  stringSchema = stringSchema.replace(minParamRegex, (match: string) => match.replace(doubleSingleQuotesRegex, ''));
-  stringSchema = stringSchema.replace(maxParamRegex, (match: string) => match.replace(doubleSingleQuotesRegex, ''));
-
-  return stringSchema;
-};
-
-const cleanUpJTD = (validations: any, schema: any) => {
-  if (isSchemaFieldSet(schema.definition)) {
-    validateFieldSetDefinition(validations, schema);
-  } else if (schema.definition?.length > 0) {
-    for (const item of schema.definition) {
-      validateDefinition(validations, item, schema);
-    }
-  }
-};
-
-const validateFieldSetDefinition = (validations: any, schema: any) => {
-  for (const item of schema.definition) {
-    switch (true) {
-      case isString(item):
-        break;
-      // Create field set header
-      case isFieldSetTitle(item):
-        {
-          const key = getFieldSetTitleKey(item.title);
-          schema.schema.properties[key] = getTitleProperty(item.title);
-        }
-        break;
-      // Format field-set sub-items
-      case isFieldSet(item):
-        // eslint-disable-next-line no-restricted-syntax
-        for (const subItem of item.items) {
-          validateDefinition(validations, subItem, schema, item);
-        }
-        break;
-      default:
-        break;
-    }
-  }
-};
-
-const validateDefinition = (validations: any, item: any, schema: any, parentItem?: any) => {
-  const { hasCheckboxes, hasDisabledChoices } = validations;
-  // Set property visibility
-  if (isString(item) && schema.schema.properties[item]) {
-    schema.schema.properties[item].isHidden = getPropertyVisibility(schema.schema.properties[item]);
-  } else {
-    // Set property visibility
-    if ((isObject(item) || isPropertyKey(item))
-        && item.key
-        && schema.schema.properties[item.key]
-    ) {
-      // eslint-disable-next-line max-len
-      schema.schema.properties[item.key].isHidden = getPropertyVisibility(schema.schema.properties[item.key]);
-    }
-
-    // Clean up disabled choices
-    if (hasDisabledChoices && isDisabledChoice(item)) {
-      if (parentItem) {
-        const parentIndex = schema.definition.indexOf(parentItem);
-        const childIndex = schema.definition[parentIndex].items.indexOf(item);
-        schema.definition[parentIndex].items[childIndex].titleMap = cleanUpDisabledEnumChoice(item);
-      } else {
-        // eslint-disable-next-line max-len
-        schema.definition[schema.definition.indexOf(item)].titleMap = cleanUpDisabledEnumChoice(item);
-      }
-    }
-
-    // Generate checkbox data in schema
-    if (hasCheckboxes && isCheckbox(item)) {
-      schema.schema.properties[item.key] = getSchemaForCheckbox(
-        item,
-        schema.schema.properties[item.key].title || '',
-        schema.schema.properties[item.key].required || false,
-        schema.schema.properties[item.key].default || false,
-      );
-    }
-  }
-};
-
-const validateSchema = (validations: any, schema: any) => {
-  const { hasInactiveChoices, hasEnums } = validations;
-  if (hasInactiveChoices) {
-    for (const key of Object.keys(schema.schema.properties)) {
-      const property = schema.schema.properties[key];
-      // Clean up inactive choices
-      if (isInactiveChoice(property)) {
-        schema.schema.properties[key].enum = cleanUpInactiveEnumChoice(property);
-
-        if (schema.schema.properties[key].enum.length === 0) {
-          schema.schema.properties[key].enum = ['0'];
-          schema.schema.properties[key].enumNames = { 0: 'No Options' };
-        }
-      }
-    }
-  }
-
-  if (hasEnums) {
-    for (const key of Object.keys(schema.schema.properties)) {
-      // Detect duplicated enum items
-      if (
-        schema.schema.properties[key].enum?.length > 0
-        && hasEnumDuplicatedItems(schema.schema.properties[key].enum)
-      ) {
-        throw new Error('Duplicated items');
-      }
-    }
-  }
-};
-
-export const validateJSONSchema = (stringSchema: string) => {
-  // Validate/Remove JSON issues
-  stringSchema = validateJSON(stringSchema);
-
-  const schema = JSON.parse(stringSchema);
-
-  // $schema and id make JSON forms crash
-  delete schema.schema.$schema;
-  delete schema.schema.id;
-
-  // Definition array should be at the same level as a schema object
-  formatDefinitionInSchema(schema);
-
-  const schemaValidations = getSchemaValidations(stringSchema);
-
-  validateSchema(schemaValidations, schema);
-
-  // JSON forms library does not support JSON Type Definition JTD
-  cleanUpJTD(schemaValidations, schema);
-
-  if (stringSchema.includes(HELP_VALUE)) {
-    formatSchemaRepeatableFieldLayout(schema);
-  }
-
-  if (stringSchema.includes(REQUIRED_PROPERTY)) {
-    schema.schema = cleanUpRequiredProperty(schema.schema);
-  }
-  return schema;
-};

package/tsconfig.json

@@ -1,32 +0,0 @@
-{
-  "compilerOptions": {
-    /* Basic Options */
-    "target": "ES2021",
-    "module": "ESNext",
-    "lib": ["es2017"],
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "dist",
-    "rootDir": "src/",
-    "noEmit": true,
-    "isolatedModules": true,
-
-    /* Strict Type-Checking Options */
-    "strict": true,
-
-    /* Module Resolution Options */
-    "moduleResolution": "node",
-    "types": ["node", "jest"],
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true
-  },
-  "include": [
-    "src/"
-  ],
-  "exclude": [
-    "node_modules", "babel.config.cjs", "metro.config.js", "jest.config.js"
-  ]
-}