@rjsf/utils 6.6.1 → 6.7.0

package/src/parseDateString.ts

@@ -1,4 +1,4 @@
-import { DateObject } from './types';
+import type { DateObject } from './types';
 
 /** Parses the `dateString` into a `DateObject`, including the time information when `includeTime` is true
  *
@@ -20,7 +20,7 @@ export default function parseDateString(dateString?: string, includeTime = true)
   }
   const date = new Date(dateString);
   if (Number.isNaN(date.getTime())) {
-    throw new Error('Unable to parse date ' + dateString);
+    throw new Error(`Unable to parse date ${dateString}`);
   }
   return {
     year: date.getUTCFullYear(),

package/src/parser/ParserValidator.ts

@@ -3,7 +3,7 @@ import get from 'lodash/get';
 import { ID_KEY } from '../constants';
 import deepEquals from '../deepEquals';
 import hashForSchema from '../hashForSchema';
-import {
+import type {
   CustomValidator,
   ErrorSchema,
   ErrorTransformer,
@@ -18,9 +18,7 @@ import {
 
 /** The type of the map of schema hash to schema
  */
-export type SchemaMap<S extends StrictRJSFSchema = RJSFSchema> = {
-  [hash: string]: S;
-};
+export type SchemaMap<S extends StrictRJSFSchema = RJSFSchema> = Record<string, S>;
 
 /** An implementation of the `ValidatorType` interface that is designed for use in capturing schemas used by the
  * `isValid()` function. The rest of the implementation of the interface throws errors when it is attempted to be used.
@@ -70,7 +68,9 @@ export default class ParserValidator<
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
     } else if (!deepEquals(existing, identifiedSchema)) {
+      // oxlint-disable-next-line no-console
       console.error('existing schema:', JSON.stringify(existing, null, 2));
+      // oxlint-disable-next-line no-console
       console.error('new schema:', JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
         `Two different schemas exist with the same key ${key}! What a bad coincidence. If possible, try adding an $id to one of the schemas`,

package/src/parser/index.ts

@@ -1,4 +1,4 @@
-import { SchemaMap } from './ParserValidator';
+import type { SchemaMap } from './ParserValidator';
 import schemaParser from './schemaParser';
 
 export type { SchemaMap };

package/src/parser/schemaParser.ts

@@ -3,8 +3,9 @@ import forEach from 'lodash/forEach';
 import { ITEMS_KEY, PROPERTIES_KEY } from '../constants';
 import deepEquals from '../deepEquals';
 import { resolveAnyOrOneOfSchemas, retrieveSchemaInternal } from '../schema/retrieveSchema';
-import { FormContextType, RJSFSchema, StrictRJSFSchema } from '../types';
-import ParserValidator, { SchemaMap } from './ParserValidator';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema } from '../types';
+import type { SchemaMap } from './ParserValidator';
+import ParserValidator from './ParserValidator';
 
 /** Recursive function used to parse the given `schema` belonging to the `rootSchema`. The `validator` is used to
  * capture the sub-schemas that the `isValid()` function is called with. For each schema returned by the
@@ -23,20 +24,20 @@ function parseSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends
   schema: S,
 ) {
   const schemas = retrieveSchemaInternal<T, S, F>(validator, schema, rootSchema, undefined, true);
-  schemas.forEach((schema) => {
-    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema));
+  schemas.forEach((localSchema) => {
+    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, localSchema));
     if (sameSchemaIndex === -1) {
-      recurseList.push(schema);
-      const allOptions = resolveAnyOrOneOfSchemas<T, S, F>(validator, schema, rootSchema, true);
+      recurseList.push(localSchema);
+      const allOptions = resolveAnyOrOneOfSchemas<T, S, F>(validator, localSchema, rootSchema, true);
       allOptions.forEach((s) => {
         if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
-          forEach(schema[PROPERTIES_KEY], (value) => {
+          forEach(localSchema[PROPERTIES_KEY], (value) => {
             parseSchema<T, S, F>(validator, recurseList, rootSchema, value as S);
           });
         }
       });
-      if (ITEMS_KEY in schema && !Array.isArray(schema.items) && typeof schema.items !== 'boolean') {
-        parseSchema<T, S, F>(validator, recurseList, rootSchema, schema.items as S);
+      if (ITEMS_KEY in localSchema && !Array.isArray(localSchema.items) && typeof localSchema.items !== 'boolean') {
+        parseSchema<T, S, F>(validator, recurseList, rootSchema, localSchema.items as S);
       }
     }
   });

package/src/rangeSpec.ts

@@ -1,5 +1,4 @@
-import { RangeSpecType, StrictRJSFSchema } from './types';
-import { RJSFSchema } from './types';
+import type { RangeSpecType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Extracts the range spec information `{ step?: number, min?: number, max?: number }` that can be spread onto an HTML
  * input from the range analog in the schema `{ multipleOf?: number, minimum?: number, maximum?: number }`.

package/src/removeOptionalEmptyObjects.ts

@@ -1,6 +1,6 @@
 import isObject from './isObject';
 import { isValueEmpty, retrieveSchema } from './schema';
-import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from './types';
+import type { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from './types';
 
 /** Recursively removes optional objects from the `formData` that are empty (i.e., all their fields
  * are undefined, null, empty strings, or themselves empty optional objects). This solves the problem
@@ -19,7 +19,7 @@ import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, Valid
  * @deprecated - This function will be removed in a future release. The equivalent pruning behavior
  *   is now built into `omitExtraData` — use that instead.
  */
-// eslint-disable-next-line @typescript-eslint/no-deprecated
+// oxlint-disable-next-line @typescript-eslint/no-deprecated
 export default function removeOptionalEmptyObjects<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
@@ -43,7 +43,7 @@ export default function removeOptionalEmptyObjects<
       if (Array.isArray(itemsSchema)) {
         itemSchema = itemsSchema[index] || (resolvedSchema.additionalItems as S) || ({} as S);
       }
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      // oxlint-disable-next-line @typescript-eslint/no-deprecated
       const cleaned = removeOptionalEmptyObjects<T, S, F>(validator, itemSchema, rootSchema, item);
       if (cleaned !== item) {
         hasChanges = true;
@@ -69,23 +69,20 @@ export default function removeOptionalEmptyObjects<
   for (const key of Object.keys(data)) {
     const value = data[key];
     const propertySchema = (properties[key] || {}) as S;
-    const isRequired = (requiredFields as string[]).includes(key);
+    const isRequired = requiredFields.includes(key);
 
     const isObj = isObject(value);
     const isArr = Array.isArray(value);
 
     if ((isObj || isArr) && properties[key]) {
       // Recursively process nested objects and arrays
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      // oxlint-disable-next-line @typescript-eslint/no-deprecated
       const cleaned = removeOptionalEmptyObjects<T, S, F>(validator, propertySchema, rootSchema, value as T);
 
-      if (!isRequired && isValueEmpty(cleaned)) {
-        // This is an optional property and the cleaned result is empty — omit it
-        continue;
+      if (isRequired || !isValueEmpty(cleaned)) {
+        result[key] = cleaned;
+        hasAnyValue = true;
       }
-
-      result[key] = cleaned;
-      hasAnyValue = true;
     } else if (isRequired || !isValueEmpty(value) || !properties[key]) {
       // Keep: required, non-empty, or not schema-defined; skip optional empty scalars silently
       result[key] = value;

package/src/resolveUiSchema.ts

@@ -3,7 +3,15 @@ import isEmpty from 'lodash/isEmpty';
 import { ANY_OF_KEY, ONE_OF_KEY, REF_KEY, RJSF_REF_KEY } from './constants';
 import findSchemaDefinition from './findSchemaDefinition';
 import mergeObjects from './mergeObjects';
-import { FormContextType, GenericObjectType, Registry, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+import type {
+  FormContextType,
+  GenericObjectType,
+  Registry,
+  RJSFMarkedSchema,
+  RJSFSchema,
+  StrictRJSFSchema,
+  UiSchema,
+} from './types';
 
 /** Resolves the uiSchema for a given schema, considering `ui:definitions` stored in the registry.
  *
@@ -26,7 +34,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 as GenericObjectType)[RJSF_REF_KEY] ?? schema[REF_KEY]) as string | undefined;
+  const ref = ((schema as RJSFMarkedSchema)[RJSF_REF_KEY] ?? schema[REF_KEY]) as string | undefined;
   const definitions = registry.uiSchemaDefinitions;
   const definitionUiSchema = ref && definitions ? definitions[ref] : undefined;
 
@@ -47,10 +55,11 @@ export default function resolveUiSchema<
   // can read dropdown option titles at the parent level.
   if (definitions) {
     let resolvedSchema: S = schema;
-    if (ref && schema[REF_KEY] && !(schema as GenericObjectType)[RJSF_REF_KEY]) {
+    if (ref && schema[REF_KEY] && !(schema as RJSFMarkedSchema)[RJSF_REF_KEY]) {
       try {
-        resolvedSchema = findSchemaDefinition<S>(ref, registry.rootSchema as S);
+        resolvedSchema = findSchemaDefinition<S>(ref, registry.rootSchema);
       } catch (e) {
+        // oxlint-disable-next-line no-console
         console.warn('could not resolve $ref in resolveUiSchema:\n', e);
         return result;
       }
@@ -58,30 +67,28 @@ export default function resolveUiSchema<
 
     for (const keyword of [ONE_OF_KEY, ANY_OF_KEY] as const) {
       const schemaOptions = resolvedSchema[keyword];
-      if (!Array.isArray(schemaOptions) || schemaOptions.length === 0) {
-        continue;
-      }
-
-      const currentUiSchemaArray = (result as GenericObjectType)[keyword];
-      const uiSchemaArray: UiSchema<T, S, F>[] = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
+      if (Array.isArray(schemaOptions) && schemaOptions.length > 0) {
+        const currentUiSchemaArray = (result as GenericObjectType)[keyword];
+        const uiSchemaArray: UiSchema<T, S, F>[] = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
 
-      let hasExpanded = false;
-      for (let i = 0; i < schemaOptions.length; i++) {
-        const option = schemaOptions[i] as GenericObjectType | undefined;
-        const optionRef = (option?.[RJSF_REF_KEY] ?? option?.[REF_KEY]) as string | undefined;
-        if (optionRef && optionRef in definitions) {
-          const optionUiSchema = (uiSchemaArray[i] || {}) as GenericObjectType;
-          uiSchemaArray[i] = mergeObjects(definitions[optionRef] as GenericObjectType, optionUiSchema) as UiSchema<
-            T,
-            S,
-            F
-          >;
-          hasExpanded = true;
+        let hasExpanded = false;
+        for (let i = 0; i < schemaOptions.length; i++) {
+          const option = schemaOptions[i] as GenericObjectType | undefined;
+          const optionRef = ((option as RJSFMarkedSchema)?.[RJSF_REF_KEY] ?? option?.[REF_KEY]) as string | undefined;
+          if (optionRef && optionRef in definitions) {
+            const optionUiSchema = (uiSchemaArray[i] || {}) as GenericObjectType;
+            uiSchemaArray[i] = mergeObjects(definitions[optionRef] as GenericObjectType, optionUiSchema) as UiSchema<
+              T,
+              S,
+              F
+            >;
+            hasExpanded = true;
+          }
         }
-      }
 
-      if (hasExpanded) {
-        (result as GenericObjectType)[keyword] = uiSchemaArray;
+        if (hasExpanded) {
+          (result as GenericObjectType)[keyword] = uiSchemaArray;
+        }
       }
     }
   }

package/src/schema/findFieldInSchema.ts

@@ -2,7 +2,7 @@ import get from 'lodash/get';
 import has from 'lodash/has';
 
 import { ANY_OF_KEY, ONE_OF_KEY, PROPERTIES_KEY, REQUIRED_KEY } from '../constants';
-import {
+import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   FoundFieldType,

package/src/schema/findSelectedOptionInXxxOf.ts

@@ -3,7 +3,13 @@ import get from 'lodash/get';
 import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from '../constants';
 import deepEquals from '../deepEquals';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
-import { Experimental_CustomMergeAllOf, FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import type {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
 import retrieveSchema from './retrieveSchema';
 
 /** Finds the option inside the `schema['any/oneOf']` list which has the `properties[selectorField].default` or
@@ -36,17 +42,21 @@ export default function findSelectedOptionInXxxOf<
   if (Array.isArray(schema[xxx])) {
     const discriminator = getDiscriminatorFieldFromSchema<S>(schema);
     const selectorField = discriminator || fallbackField;
-    const xxxOfs = schema[xxx]!.map((xxxOf) =>
+    const xxxOfs = schema[xxx].map((xxxOf) =>
       retrieveSchema<T, S, F>(validator, xxxOf as S, rootSchema, formData, experimental_customMergeAllOf),
     );
     const data = get(formData, selectorField);
     if (data !== undefined) {
-      return xxxOfs.find((xxx) => {
-        return deepEquals(
-          get(xxx, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get(xxx, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+      return xxxOfs.find((xxxOfOption) =>
+        deepEquals(
+          get(
+            xxxOfOption,
+            [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
+            get(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY]),
+          ),
           data,
-        );
-      });
+        ),
+      );
     }
   }
   return undefined;

package/src/schema/getClosestMatchingOption.ts

@@ -10,7 +10,13 @@ import { ONE_OF_KEY, REF_KEY, JUNK_OPTION_ID, ANY_OF_KEY } from '../constants';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
 import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator';
 import guessType from '../guessType';
-import { Experimental_CustomMergeAllOf, FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import type {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
 import getFirstMatchingOption from './getFirstMatchingOption';
 import retrieveSchema, { resolveAllReferences } from './retrieveSchema';
 
@@ -85,7 +91,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
             );
           }
           if ((has(value, ONE_OF_KEY) || has(value, ANY_OF_KEY)) && formValue) {
-            const key = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            const xxxOfKey = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
             const discriminator = getDiscriminatorFieldFromSchema<S>(value as S);
             return (
               score +
@@ -93,7 +99,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
                 validator,
                 rootSchema,
                 formValue,
-                get(value, key) as S[],
+                get(value, xxxOfKey) as S[],
                 -1,
                 discriminator,
                 experimental_customMergeAllOf,
@@ -101,12 +107,11 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
             );
           }
           if (value.type === 'object') {
-            if (isObject(formValue)) {
-              // If the structure is matching then give it a little boost in score
-              score += 1;
-            }
+            // If the structure is matching then give it a little boost in score
+            const structureBoost = isObject(formValue) ? 1 : 0;
             return (
               score +
+              structureBoost +
               calculateIndexScore<T, S, F>(validator, rootSchema, value as S, formValue, experimental_customMergeAllOf)
             );
           }
@@ -173,9 +178,7 @@ export default function getClosestMatchingOption<
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): number {
   // First resolve any refs in the options
-  const resolvedOptions = options.map((option) => {
-    return resolveAllReferences<S>(option, rootSchema, []);
-  });
+  const resolvedOptions = options.map((option) => resolveAllReferences<S>(option, rootSchema, []));
 
   const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
   if (isNumber(simpleDiscriminatorMatch)) {
@@ -201,7 +204,10 @@ export default function getClosestMatchingOption<
     // No indexes were valid, so we'll score all the options, add all the indexes
     times(resolvedOptions.length, (i) => allValidIndexes.push(i));
   }
-  type BestType = { bestIndex: number; bestScore: number };
+  interface BestType {
+    bestIndex: number;
+    bestScore: number;
+  }
   const scoreCount = new Set<number>();
   // Score all the options in the list of valid indexes and return the index with the best score
   const { bestIndex }: BestType = allValidIndexes.reduce(