@rjsf/utils 6.0.0-beta.1 → 6.0.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rjsf/utils",
-  "version": "6.0.0-beta.1",
+  "version": "6.0.0-beta.3",
   "main": "dist/index.js",
   "module": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -65,6 +65,7 @@
     "react": ">=18"
   },
   "dependencies": {
+    "fast-uri": "^3.0.6",
     "json-schema-merge-allof": "^0.8.1",
     "jsonpointer": "^5.0.1",
     "lodash": "^4.17.21",

package/src/constants.ts

@@ -25,6 +25,7 @@ export const READONLY_KEY = 'readonly';
 export const REQUIRED_KEY = 'required';
 export const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
 export const REF_KEY = '$ref';
+export const SCHEMA_KEY = '$schema';
 /** The path of the discriminator value returned by the schema endpoint.
  * The discriminator is the value in a `oneOf` that determines which option is selected.
  */
@@ -42,3 +43,7 @@ export const UI_FIELD_KEY = 'ui:field';
 export const UI_WIDGET_KEY = 'ui:widget';
 export const UI_OPTIONS_KEY = 'ui:options';
 export const UI_GLOBAL_OPTIONS_KEY = 'ui:globalOptions';
+
+/** The JSON Schema version strings
+ */
+export const JSON_SCHEMA_DRAFT_2020_12 = 'https://json-schema.org/draft/2020-12/schema';

package/src/findSchemaDefinition.ts

@@ -1,8 +1,33 @@
 import jsonpointer from 'jsonpointer';
 import omit from 'lodash/omit';
 
-import { REF_KEY } from './constants';
+import { ID_KEY, JSON_SCHEMA_DRAFT_2020_12, REF_KEY, SCHEMA_KEY } from './constants';
 import { GenericObjectType, RJSFSchema, StrictRJSFSchema } from './types';
+import isObject from 'lodash/isObject';
+import isEmpty from 'lodash/isEmpty';
+import UriResolver from 'fast-uri';
+
+/** Looks for the `$id` pointed by `ref` in the schema definitions embedded in
+ * a JSON Schema bundle
+ *
+ * @param schema - The schema wherein `ref` should be searched
+ * @param ref - The `$id` of the reference to search for
+ * @returns - The schema matching the reference, or `undefined` if no match is found
+ */
+function findEmbeddedSchemaRecursive<S extends StrictRJSFSchema = RJSFSchema>(schema: S, ref: string): S | undefined {
+  if (ID_KEY in schema && UriResolver.equal(schema[ID_KEY] as string, ref)) {
+    return schema;
+  }
+  for (const subSchema of Object.values(schema)) {
+    if (isObject(subSchema)) {
+      const result = findEmbeddedSchemaRecursive<S>(subSchema as S, ref);
+      if (result !== undefined) {
+        return result as S;
+      }
+    }
+  }
+  return undefined;
+}
 
 /** 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`.
@@ -26,6 +51,7 @@ export function splitKeyElementFromObject(key: string, object: GenericObjectType
  * @param $ref - The ref string for which the schema definition is desired
  * @param [rootSchema={}] - The root schema in which to search for the definition
  * @param recurseList - List of $refs already resolved to prevent recursion
+ * @param baseURI - The base URI to be used for resolving relative references
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference could be resolved
  */
@@ -33,16 +59,32 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
   $ref?: string,
   rootSchema: S = {} as S,
   recurseList: string[] = [],
+  baseURI: string | undefined = ID_KEY in rootSchema ? rootSchema[ID_KEY] : undefined,
 ): S {
   const ref = $ref || '';
-  let decodedRef;
+  let current: S | undefined = undefined;
   if (ref.startsWith('#')) {
     // Decode URI fragment representation.
-    decodedRef = decodeURIComponent(ref.substring(1));
-  } else {
-    throw new Error(`Could not find a definition for ${$ref}.`);
+    const decodedRef = decodeURIComponent(ref.substring(1));
+    if (baseURI === undefined || (ID_KEY in rootSchema && rootSchema[ID_KEY] === baseURI)) {
+      current = jsonpointer.get(rootSchema, decodedRef);
+    } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      current = findEmbeddedSchemaRecursive<S>(rootSchema, baseURI.replace(/\/$/, ''));
+      if (current !== undefined) {
+        current = jsonpointer.get(current, decodedRef);
+      }
+    }
+  } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+    const resolvedRef = baseURI ? UriResolver.resolve(baseURI, ref) : ref;
+    const [refId, ...refAnchor] = resolvedRef.replace(/#\/?$/, '').split('#');
+    current = findEmbeddedSchemaRecursive<S>(rootSchema, refId.replace(/\/$/, ''));
+    if (current !== undefined) {
+      baseURI = current[ID_KEY];
+      if (!isEmpty(refAnchor)) {
+        current = jsonpointer.get(current, decodeURIComponent(refAnchor.join('#')));
+      }
+    }
   }
-  const current: S = jsonpointer.get(rootSchema, decodedRef);
   if (current === undefined) {
     throw new Error(`Could not find a definition for ${$ref}.`);
   }
@@ -58,7 +100,7 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
       throw new Error(`Definition for ${firstRef} contains a circular reference through ${circularPath}`);
     }
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
-    const subSchema = findSchemaDefinitionRecursive<S>(theRef, rootSchema, [...recurseList, ref]);
+    const subSchema = findSchemaDefinitionRecursive<S>(theRef, rootSchema, [...recurseList, ref], baseURI);
     if (Object.keys(remaining).length > 0) {
       return { ...remaining, ...subSchema };
     }
@@ -74,13 +116,15 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
  *
  * @param $ref - The ref string for which the schema definition is desired
  * @param [rootSchema={}] - The root schema in which to search for the definition
+ * @param [baseURI=rootSchema['$id']] - The base URI to be used for resolving relative references
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference could be resolved
  */
 export default function findSchemaDefinition<S extends StrictRJSFSchema = RJSFSchema>(
   $ref?: string,
   rootSchema: S = {} as S,
+  baseURI: string | undefined = ID_KEY in rootSchema ? rootSchema[ID_KEY] : undefined,
 ): S {
   const recurseList: string[] = [];
-  return findSchemaDefinitionRecursive($ref, rootSchema, recurseList);
+  return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }

package/src/schema/getDefaultFormState.ts

@@ -223,7 +223,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     // For object defaults, only override parent defaults that are defined in
     // schema.default.
     defaults = mergeObjects(defaults!, schema.default as GenericObjectType) as T;
-  } else if (DEFAULT_KEY in schema && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY]) {
+  } else if (DEFAULT_KEY in schema && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
     // If the schema has a default value, then we should use it as the default.
     // And if the schema does not have anyOf or oneOf, this is done because we need to merge the defaults with the formData.
     defaults = schema.default as unknown as T;
@@ -234,6 +234,12 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       updatedRecurseList = _recurseList.concat(refName!);
       schemaToCompute = findSchemaDefinition<S>(refName, rootSchema);
     }
+
+    // If the referenced schema exists and parentDefaults is not set
+    // Then set the defaults from the current schema for the referenced schema
+    if (schemaToCompute && !defaults) {
+      defaults = schema.default as T | undefined;
+    }
   } else if (DEPENDENCIES_KEY in schema) {
     // Get the default if set from properties to ensure the dependencies conditions are resolved based on it
     const defaultFormData: T = {

package/src/schema/retrieveSchema.ts

@@ -13,6 +13,7 @@ import {
   ALL_OF_KEY,
   ANY_OF_KEY,
   DEPENDENCIES_KEY,
+  ID_KEY,
   IF_KEY,
   ITEMS_KEY,
   ONE_OF_KEY,
@@ -333,12 +334,14 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
  * @param schema - The schema for which resolving all references is desired
  * @param rootSchema - The root schema that will be forwarded to all the APIs
  * @param recurseList - List of $refs already resolved to prevent recursion
+ * @param baseURI - The base URI to be used for resolving relative references
  * @returns - given schema will all references resolved or the original schema if no internal `$refs` were resolved
  */
 export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   schema: S,
   rootSchema: S,
   recurseList: string[],
+  baseURI?: string,
 ): S {
   if (!isObject(schema)) {
     return schema;
@@ -353,8 +356,11 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
     }
     recurseList.push($ref!);
     // Retrieve the referenced schema definition.
-    const refSchema = findSchemaDefinition<S>($ref, rootSchema);
+    const refSchema = findSchemaDefinition<S>($ref, rootSchema, baseURI);
     resolvedSchema = { ...refSchema, ...localSchema };
+    if (ID_KEY in resolvedSchema) {
+      baseURI = resolvedSchema[ID_KEY];
+    }
   }
 
   if (PROPERTIES_KEY in resolvedSchema) {
@@ -363,7 +369,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
       resolvedSchema[PROPERTIES_KEY]!,
       (result, value, key: string) => {
         const childList: string[] = [...recurseList];
-        result[key] = resolveAllReferences(value as S, rootSchema, childList);
+        result[key] = resolveAllReferences(value as S, rootSchema, childList, baseURI);
         childrenLists.push(childList);
       },
       {} as RJSFSchema,
@@ -379,7 +385,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   ) {
     resolvedSchema = {
       ...resolvedSchema,
-      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList),
+      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList, baseURI),
     };
   }
 
@@ -550,6 +556,9 @@ export function retrieveSchemaInternal<
           ? experimental_customMergeAllOf(resolvedSchema)
           : (mergeAllOf(resolvedSchema, {
               deep: false,
+              resolvers: {
+                $defs: mergeAllOf.options.resolvers.definitions,
+              },
             } as Options) as S);
         if (withContainsSchemas.length) {
           resolvedSchema.allOf = withContainsSchemas;

package/src/types.ts

@@ -245,7 +245,7 @@ export type FormValidation<T = any> = FieldValidation & {
 export type RJSFBaseProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
   /** The schema object for the field being described */
   schema: S;
-  /** The uiSchema object for this description field */
+  /** The uiSchema object for this base component */
   uiSchema?: UiSchema<T, S, F>;
   /** The `registry` object */
   registry: Registry<T, S, F>;
@@ -387,6 +387,9 @@ export type GlobalUISchemaOptions = {
    * This option allows you to change the separator between the original key name and the integer. Default is "-"
    */
   duplicateKeySuffixSeparator?: string;
+  /** Enables the displaying of description text that contains markdown
+   */
+  enableMarkdownInDescription?: boolean;
 };
 
 /** The object containing the registered core, theme and custom fields and widgets as well as the root schema, form
@@ -422,11 +425,8 @@ export interface Registry<T = any, S extends StrictRJSFSchema = RJSFSchema, F ex
 /** The properties that are passed to a Field implementation */
 export interface FieldProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>
   extends GenericObjectType,
+    RJSFBaseProps<T, S, F>,
     Pick<HTMLAttributes<HTMLElement>, Exclude<keyof HTMLAttributes<HTMLElement>, 'onBlur' | 'onFocus' | 'onChange'>> {
-  /** The JSON subschema object for this field */
-  schema: S;
-  /** The uiSchema for this field */
-  uiSchema?: UiSchema<T, S, F>;
   /** The tree of unique ids for every child field */
   idSchema: IdSchema<T>;
   /** The data for this field */
@@ -463,8 +463,6 @@ export interface FieldProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F
   idSeparator?: string;
   /** An array of strings listing all generated error messages from encountered errors for this field */
   rawErrors?: string[];
-  /** The `registry` object */
-  registry: Registry<T, S, F>;
 }
 
 /** The definition of a React-based Field component */
@@ -726,7 +724,7 @@ export type ObjectFieldTemplateProps<
   /** A string value containing the title for the object */
   title: string;
   /** A string value containing the description for the object */
-  description?: string;
+  description?: string | ReactElement;
   /** A boolean value stating if the object is disabled */
   disabled?: boolean;
   /** An array of objects representing the properties in the object */