@rjsf/utils 6.3.0 → 6.4.0

package/lib/types.d.ts

@@ -813,6 +813,8 @@ export type UISchemaSubmitButtonOptions = {
         className?: string;
     };
 };
+/** Represents a primitive JSON Schema enum value */
+export type EnumValue = string | number | boolean;
 /** This type represents an element used to render an enum option */
 export type EnumOptionsType<S extends StrictRJSFSchema = RJSFSchema> = {
     /** The value for the enum option */
@@ -855,9 +857,15 @@ type UIOptionsBaseType<T = any, S extends StrictRJSFSchema = RJSFSchema, F exten
     /** The default value to use when an input for a field is empty */
     emptyValue?: any;
     /** Will disable any of the enum options specified in the array (by value) */
-    enumDisabled?: Array<string | number | boolean>;
-    /** Allows a user to provide a list of labels for enum values in the schema */
-    enumNames?: string[];
+    enumDisabled?: EnumValue[];
+    /** Allows a user to provide a list of labels for enum values in the schema.
+     * Can be an array (positional, matched by index) or a Record mapping enum values to labels (matched by value).
+     */
+    enumNames?: string[] | Record<string | number, string>;
+    /** Controls the display order of enum options, following the same pattern as `ui:order` for object properties.
+     * Supports a `'*'` wildcard to represent all remaining values in their original schema order.
+     */
+    enumOrder?: EnumValue[];
     /** Provides an optional field within a schema to be used as the oneOf/anyOf selector when there isn't a
      * discriminator
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rjsf/utils",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "main": "dist/index.js",
   "module": "lib/index.js",
   "typings": "lib/index.d.ts",

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 RJSF_REF_KEY = '__rjsf_ref';
 export const SCHEMA_KEY = '$schema';
 export const DEFAULT_ID_PREFIX = 'root';
 export const DEFAULT_ID_SEPARATOR = '_';

package/src/isRootSchema.ts

@@ -1,7 +1,8 @@
 import isEqual from 'lodash/isEqual';
+import omit from 'lodash/omit';
 
 import { FormContextType, Registry, RJSFSchema, StrictRJSFSchema } from './types';
-import { REF_KEY } from './constants';
+import { REF_KEY, RJSF_REF_KEY } from './constants';
 
 /** Helper to check whether a JSON schema object is the root schema. The schema is a root schema with root `properties`
  * key or a root `$ref` key. If the `schemaToCompare` has a root `oneOf` property, the function will
@@ -24,7 +25,7 @@ export default function isRootSchema<T = any, S extends StrictRJSFSchema = RJSFS
   }
   if (REF_KEY in rootSchema) {
     const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-    return isEqual(schemaToCompare, resolvedSchema);
+    return isEqual(schemaToCompare, omit(resolvedSchema, RJSF_REF_KEY));
   }
   return false;
 }

package/src/optionsList.ts

@@ -4,7 +4,28 @@ import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from './constants';
 import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema';
 import getUiOptions from './getUiOptions';
 import toConstant from './toConstant';
-import { RJSFSchema, EnumOptionsType, StrictRJSFSchema, FormContextType, UiSchema } from './types';
+import { RJSFSchema, EnumOptionsType, EnumValue, StrictRJSFSchema, FormContextType, UiSchema } from './types';
+
+/** Reorders `options` according to `order`, which may contain a `'*'` wildcard representing all
+ * remaining options in their original order. Options not listed in `order` (and not covered by
+ * a wildcard) are dropped.
+ */
+function applyEnumOrder<S extends StrictRJSFSchema = RJSFSchema>(
+  options: EnumOptionsType<S>[],
+  order: EnumValue[],
+): EnumOptionsType<S>[] {
+  const optionsByValue = new Map(options.map((opt) => [String(opt.value), opt]));
+  const orderedKeys = new Set(order.filter((v) => v !== '*').map(String));
+  const rest = options.filter((opt) => !orderedKeys.has(String(opt.value)));
+
+  return order.flatMap((entry) => {
+    if (entry === '*') {
+      return rest;
+    }
+    const opt = optionsByValue.get(String(entry));
+    return opt ? [opt] : [];
+  });
+}
 
 /** Gets the list of options from the `schema`. If the schema has an enum list, then those enum values are returned. The
  * label will be the same as the `value`.
@@ -24,15 +45,23 @@ export default function optionsList<T = any, S extends StrictRJSFSchema = RJSFSc
   uiSchema?: UiSchema<T, S, F>,
 ): EnumOptionsType<S>[] | undefined {
   if (schema.enum) {
-    let enumNames: string[] | undefined;
+    let enumNames: string[] | Record<string | number, string> | undefined;
+    let enumOrder: EnumValue[] | undefined;
     if (uiSchema) {
-      const { enumNames: uiEnumNames } = getUiOptions<T, S, F>(uiSchema);
+      const { enumNames: uiEnumNames, enumOrder: uiEnumOrder } = getUiOptions<T, S, F>(uiSchema);
       enumNames = uiEnumNames;
+      enumOrder = uiEnumOrder;
     }
-    return schema.enum.map((value, i) => {
-      const label = enumNames?.[i] || String(value);
+    let options = schema.enum.map((value, i) => {
+      const label = Array.isArray(enumNames)
+        ? enumNames[i] || String(value)
+        : enumNames?.[String(value)] || String(value);
       return { label, value };
     });
+    if (enumOrder) {
+      options = applyEnumOrder(options, enumOrder);
+    }
+    return options;
   }
   let altSchemas: S['anyOf'] | S['oneOf'] = undefined;
   let altUiSchemas: UiSchema<T, S, F> | undefined = undefined;

package/src/resolveUiSchema.ts

@@ -6,6 +6,7 @@ import {
   ONE_OF_KEY,
   PROPERTIES_KEY,
   REF_KEY,
+  RJSF_REF_KEY,
 } from './constants';
 import findSchemaDefinition from './findSchemaDefinition';
 import isObject from './isObject';
@@ -141,7 +142,7 @@ export default function resolveUiSchema<
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any,
 >(schema: S, localUiSchema: UiSchema<T, S, F> | undefined, registry: Registry<T, S, F>): UiSchema<T, S, F> {
-  const ref = schema[REF_KEY] as string | undefined;
+  const ref = ((schema as GenericObjectType)[RJSF_REF_KEY] ?? schema[REF_KEY]) as string | undefined;
   const definitionUiSchema = ref ? registry.uiSchemaDefinitions?.[ref] : undefined;
 
   if (!definitionUiSchema) {

package/src/schema/retrieveSchema.ts

@@ -22,6 +22,7 @@ import {
   PATTERN_PROPERTIES_KEY,
   PROPERTIES_KEY,
   REF_KEY,
+  RJSF_REF_KEY,
 } from '../constants';
 import findSchemaDefinition, { splitKeyElementFromObject } from '../findSchemaDefinition';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
@@ -371,7 +372,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
     recurseList.push($ref!);
     // Retrieve the referenced schema definition.
     const refSchema = findSchemaDefinition<S>($ref, rootSchema, baseURI);
-    resolvedSchema = { ...refSchema, ...localSchema };
+    resolvedSchema = { ...refSchema, ...localSchema, [RJSF_REF_KEY]: $ref };
     if (ID_KEY in resolvedSchema) {
       baseURI = resolvedSchema[ID_KEY];
     }

package/src/schema/toPathSchema.ts

@@ -1,4 +1,5 @@
 import get from 'lodash/get';
+import isObject from 'lodash/isObject';
 import set from 'lodash/set';
 
 import {
@@ -98,6 +99,23 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
 
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
     set(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+    const additionalSchema = (
+      isObject(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {}
+    ) as S;
+    const definedProperties = get(schema, PROPERTIES_KEY, {});
+    for (const key of Object.keys((formData ?? {}) as GenericObjectType)) {
+      if (!(key in definedProperties)) {
+        (pathSchema as PathSchema<GenericObjectType>)[key] = toPathSchemaInternal<T, S, F>(
+          validator,
+          additionalSchema,
+          `${name}.${key}`,
+          rootSchema,
+          get(formData, [key]),
+          _recurseList,
+          experimental_customMergeAllOf,
+        );
+      }
+    }
   }
 
   if (ITEMS_KEY in schema && Array.isArray(formData)) {

package/src/types.ts

@@ -1008,6 +1008,9 @@ export type UISchemaSubmitButtonOptions = {
   };
 };
 
+/** Represents a primitive JSON Schema enum value */
+export type EnumValue = string | number | boolean;
+
 /** This type represents an element used to render an enum option */
 export type EnumOptionsType<S extends StrictRJSFSchema = RJSFSchema> = {
   /** The value for the enum option */
@@ -1071,9 +1074,15 @@ type UIOptionsBaseType<T = any, S extends StrictRJSFSchema = RJSFSchema, F exten
     /** The default value to use when an input for a field is empty */
     emptyValue?: any;
     /** Will disable any of the enum options specified in the array (by value) */
-    enumDisabled?: Array<string | number | boolean>;
-    /** Allows a user to provide a list of labels for enum values in the schema */
-    enumNames?: string[];
+    enumDisabled?: EnumValue[];
+    /** Allows a user to provide a list of labels for enum values in the schema.
+     * Can be an array (positional, matched by index) or a Record mapping enum values to labels (matched by value).
+     */
+    enumNames?: string[] | Record<string | number, string>;
+    /** Controls the display order of enum options, following the same pattern as `ui:order` for object properties.
+     * Supports a `'*'` wildcard to represent all remaining values in their original schema order.
+     */
+    enumOrder?: EnumValue[];
     /** Provides an optional field within a schema to be used as the oneOf/anyOf selector when there isn't a
      * discriminator
      */