Packages/utils/schema

packages/utils/package.json

@@ -80,7 +80,7 @@
       "jest-expect-message"
     ],
     "testMatch": [
-      "**/test/**/*.test.[jt]s?(x)"
+      "**/test/**/*.test.ts?(x)"
     ],
     "coverageDirectory": "<rootDir>/coverage/",
     "collectCoverage": true,

packages/utils/src/constants.ts

@@ -1,9 +1,12 @@
 export const ADDITIONAL_PROPERTY_FLAG = '__additional_property';
 export const ADDITIONAL_PROPERTIES_NAME = 'additionalProperties';
 export const ALL_OF_NAME = 'allOf';
+export const ANY_OF_NAME = 'anyOf';
 export const CONST_NAME = 'const';
+export const DEFAULT_NAME = 'default';
 export const DEPENDENCIES_NAME = 'dependencies';
 export const ITEMS_NAME = 'items';
+export const ONE_OF_NAME = 'oneOf';
 export const PROPERTIES_NAME = 'properties';
 export const SUBMIT_BTN_OPTIONS_NAME = 'submitButtonOptions';
 export const REF_NAME = '$ref';

packages/utils/src/createSchemaUtils.ts

@@ -0,0 +1,69 @@
+import { RJSFSchema, SchemaUtilsType, UiSchema, ValidatorType } from './types';
+import {
+  getDefaultFormState,
+  getDisplayLabel,
+  getMatchingOption,
+  isFilesArray,
+  isMultiSelect,
+  isSelect,
+  retrieveSchema,
+  stubExistingAdditionalProperties,
+  toIdSchema,
+  toPathSchema,
+} from './schema';
+
+export class SchemaUtils<T = any> implements SchemaUtilsType<T> {
+  rootSchema: RJSFSchema;
+  validator: ValidatorType;
+
+  constructor(validator: ValidatorType, rootSchema: RJSFSchema) {
+    this.rootSchema = rootSchema;
+    this.validator = validator;
+  }
+
+  getDefaultFormState(schema: RJSFSchema, formData?: T, includeUndefinedValues = false): T | T[] | undefined {
+    return getDefaultFormState<T>(this.validator, schema, formData, this.rootSchema, includeUndefinedValues);
+  }
+
+  getDisplayLabel<F = any>(schema: RJSFSchema, uiSchema: UiSchema<T, F>) {
+    return getDisplayLabel<T, F>(this.validator, schema, uiSchema, this.rootSchema);
+  }
+
+  getMatchingOption(formData: T, options: RJSFSchema[]) {
+    return getMatchingOption<T>(this.validator, formData, options, this.rootSchema);
+  }
+
+  isFilesArray<F = any>(schema: RJSFSchema, uiSchema: UiSchema<T, F>) {
+    return isFilesArray<T, F>(this.validator, schema, uiSchema, this.rootSchema);
+  }
+
+  isMultiSelect(schema: RJSFSchema) {
+    return isMultiSelect<T>(this.validator, schema, this.rootSchema);
+  }
+
+  isSelect(schema: RJSFSchema) {
+    return isSelect<T>(this.validator, schema, this.rootSchema);
+  }
+
+  retrieveSchema(schema: RJSFSchema, rawFormData: T) {
+    return retrieveSchema<T>(this.validator, schema, this.rootSchema, rawFormData);
+  }
+
+  stubExistingAdditionalProperties(schema: RJSFSchema, formData: T) {
+    return stubExistingAdditionalProperties<T>(this.validator, schema, this.rootSchema, formData);
+  }
+
+  toIdSchema(schema: RJSFSchema, id: string, formData: T, idPrefix = 'root', idSeparator = '_') {
+    return toIdSchema<T>(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator);
+  }
+
+  toPathSchema(schema: RJSFSchema, name: string, formData: T) {
+    return toPathSchema<T>(this.validator, schema, name, this.rootSchema, formData);
+  }
+}
+
+export default function createSchemaUtils<T = any>(
+  validator: ValidatorType, rootSchema: RJSFSchema
+): SchemaUtilsType<T> {
+  return new SchemaUtils<T>(validator, rootSchema);
+}

packages/utils/src/findSchemaDefinition.ts

@@ -2,7 +2,21 @@ import jsonpointer from 'jsonpointer';
 import omit from 'lodash/omit';
 
 import { REF_NAME } from './constants';
-import { RJSFSchema } from './types';
+import { GenericObjectType, RJSFSchema } from './types';
+
+/** Splits out the value at the `key` in `object` from the `object`, returning an array that contains in the first
+ * location, the `object` minus the `key: value` and in the second location the `value`.
+ *
+ * @param key - The key from the object to extract
+ * @param object - The object from which to extract the element
+ * @returns - An array with the first value being the object minus the `key` element and the second element being the
+ *      value from `object[key]`
+ */
+export function splitKeyElementFromObject(key: string, object: GenericObjectType) {
+  const value = object[key];
+  const remaining = omit(object, [key]);
+  return [remaining, value];
+}
 
 /** Given the name of a `$ref` from within a schema, using the `rootSchema`, look up and return the sub-schema using the
  * path provided by that reference. If `#` is not the first character of the reference, or the path does not exist in
@@ -25,9 +39,10 @@ export default function findSchemaDefinition($ref?: string, rootSchema: RJSFSche
     throw new Error(`Could not find a definition for ${$ref}.`);
   }
   if (current[REF_NAME]) {
-    const subSchema = findSchemaDefinition(current[REF_NAME]!, rootSchema);
-    if (Object.keys(current).length > 1) {
-      return { ...omit(current, [REF_NAME]), ...subSchema };
+    const [remaining, theRef] = splitKeyElementFromObject(REF_NAME, current);
+    const subSchema = findSchemaDefinition(theRef, rootSchema);
+    if (Object.keys(remaining).length > 0) {
+      return { ...remaining, ...subSchema };
     }
     return subSchema;
   }

packages/utils/src/index.ts

@@ -1,6 +1,7 @@
 import allowAdditionalItems from './allowAdditionalItems';
 import asNumber from './asNumber';
 import canExpand from './canExpand';
+import createSchemaUtils from './createSchemaUtils';
 import dataURItoBlob from './dataURItoBlob';
 import deepEquals from './deepEquals';
 import findSchemaDefinition from './findSchemaDefinition';
@@ -29,92 +30,16 @@ import toConstant from './toConstant';
 import toDateString from './toDateString';
 import utcToLocal from './utcToLocal';
 
-import {
-  ArrayFieldTemplateItemType,
-  ArrayFieldTemplateProps,
-  CustomValidator,
-  DateObject,
-  DescriptionFieldProps,
-  ErrorListProps,
-  ErrorSchema,
-  ErrorTransformer,
-  Field,
-  FieldError,
-  FieldErrors,
-  FieldId,
-  FieldPath,
-  FieldProps,
-  FieldTemplateProps,
-  FieldValidation,
-  FormValidation,
-  GenericObjectType,
-  IChangeEvent,
-  IdSchema,
-  ObjectFieldTemplatePropertyType,
-  ObjectFieldTemplateProps,
-  PathSchema,
-  RangeSpecType,
-  Registry,
-  RegistryFieldsType,
-  RegistryWidgetsType,
-  RJSFSchema,
-  RJSFValidationError,
-  TitleFieldProps,
-  UiSchema,
-  UIOptionsType,
-  UISchemaSubmitButtonOptions,
-  ValidationData,
-  ValidatorType,
-  Widget,
-  WidgetProps,
-} from './types';
-
-export type {
-  ArrayFieldTemplateItemType,
-  ArrayFieldTemplateProps,
-  CustomValidator,
-  DateObject,
-  DescriptionFieldProps,
-  ErrorListProps,
-  ErrorSchema,
-  ErrorTransformer,
-  Field,
-  FieldError,
-  FieldErrors,
-  FieldId,
-  FieldPath,
-  FieldProps,
-  FieldTemplateProps,
-  FieldValidation,
-  FormValidation,
-  GenericObjectType,
-  IChangeEvent,
-  IdSchema,
-  ObjectFieldTemplatePropertyType,
-  ObjectFieldTemplateProps,
-  PathSchema,
-  RangeSpecType,
-  Registry,
-  RegistryFieldsType,
-  RegistryWidgetsType,
-  RJSFSchema,
-  RJSFValidationError,
-  TitleFieldProps,
-  UiSchema,
-  UIOptionsType,
-  UISchemaSubmitButtonOptions,
-  ValidationData,
-  ValidatorType,
-  Widget,
-  WidgetProps,
-};
+export * from './types';
 
 export * from './constants';
+export * from './schema';
 
 export {
   allowAdditionalItems,
   asNumber,
   canExpand,
+  createSchemaUtils,
   dataURItoBlob,
   deepEquals,
   findSchemaDefinition,