@rjsf/utils 6.6.1 → 6.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rjsf/utils",
-  "version": "6.6.1",
+  "version": "6.7.0",
   "main": "dist/index.js",
   "module": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -42,20 +42,6 @@
   "engines": {
     "node": ">=20"
   },
-  "scripts": {
-    "compileReplacer": "tsc -p tsconfig.replacer.json && move-file lodashReplacer.js lodashReplacer.cjs",
-    "build:ts": "npm run compileReplacer && rimraf ./lib && tsc -b tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "build:cjs": "esbuild ./src/index.ts --bundle --outfile=dist/index.cjs --sourcemap --packages=external --format=cjs",
-    "build:esm": "esbuild ./src/index.ts --bundle --outfile=dist/utils.esm.js --sourcemap --packages=external --format=esm",
-    "build:umd": "rollup dist/utils.esm.js --format=umd --file=dist/utils.umd.js --name=@rjsf/utils",
-    "build": "npm run build:ts && npm run build:cjs && npm run build:esm && npm run build:umd",
-    "cs-check": "oxfmt --check \"{src,test}/**/*.{ts,tsx}\"",
-    "cs-format": "oxfmt \"{src,test}/**/*.{ts,tsx}\"",
-    "lint": "oxlint src test",
-    "precommit": "lint-staged",
-    "test": "vitest run",
-    "test:debug": "node --inspect-brk ../../node_modules/.bin/vitest --pool=forks"
-  },
   "lint-staged": {
     "{src,test}/**/*.{ts,tsx}": [
       "oxlint --fix",
@@ -68,7 +54,7 @@
   "dependencies": {
     "@x0k/json-schema-merge": "^1.0.3",
     "fast-equals": "^6.0.0",
-    "fast-uri": "^3.1.2",
+    "fast-uri": "^4.0.0",
     "jsonpointer": "^5.0.1",
     "lodash": "^4.18.1",
     "lodash-es": "^4.18.1",
@@ -77,7 +63,7 @@
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
     "@types/react-is": "^18.3.1",
-    "deep-freeze-es6": "^4.0.1"
+    "deep-freeze-es6": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -96,5 +82,19 @@
     "type": "git",
     "url": "git+https://github.com/rjsf-team/react-jsonschema-form.git"
   },
-  "license": "Apache-2.0"
-}
+  "license": "Apache-2.0",
+  "scripts": {
+    "compileReplacer": "tsc -p tsconfig.replacer.json && move-file lodashReplacer.js lodashReplacer.cjs",
+    "build:ts": "pnpm run compileReplacer && rimraf ./lib && tsc -b tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "build:cjs": "esbuild ./src/index.ts --bundle --outfile=dist/index.cjs --sourcemap --packages=external --format=cjs",
+    "build:esm": "esbuild ./src/index.ts --bundle --outfile=dist/utils.esm.js --sourcemap --packages=external --format=esm",
+    "build:umd": "rollup dist/utils.esm.js --format=umd --file=dist/utils.umd.js --name=@rjsf/utils",
+    "build": "pnpm run build:ts && pnpm run build:cjs && pnpm run build:esm && pnpm run build:umd",
+    "cs-check": "oxfmt --check \"{src,test}/**/*.{ts,tsx}\"",
+    "cs-format": "oxfmt \"{src,test}/**/*.{ts,tsx}\"",
+    "lint": "oxlint src test",
+    "precommit": "lint-staged",
+    "test": "vitest run",
+    "test:debug": "node --inspect-brk ../../node_modules/.bin/vitest --pool=forks"
+  }
+}

package/src/ErrorSchemaBuilder.ts

@@ -4,7 +4,7 @@ import set from 'lodash/set';
 import setWith from 'lodash/setWith';
 
 import { ERRORS_KEY } from './constants';
-import { ErrorSchema, FieldPathList } from './types';
+import type { ErrorSchema, FieldPathList } from './types';
 
 /** Represents the type of the path which can be a string of dotted path values or a list of string or numbers where
  * numbers represent array indexes/

package/src/SelectedOptionDescription.tsx

@@ -0,0 +1,48 @@
+import enumOptionsIsSelected from './enumOptionsIsSelected';
+import getTemplate from './getTemplate';
+import getUiOptions from './getUiOptions';
+import { descriptionId } from './idGenerators';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, WidgetProps } from './types';
+
+export type SelectedOptionDescriptionProps<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+> = Pick<WidgetProps<T, S, F>, 'id' | 'multiple' | 'options' | 'registry' | 'uiSchema' | 'value' | 'hideLabel'>;
+
+/** Renders the description associated with the selected oneOf or anyOf option in a single-select widget. */
+export default function SelectedOptionDescription<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>({ hideLabel, id, multiple, options, registry, uiSchema, value }: SelectedOptionDescriptionProps<T, S, F>) {
+  if (multiple || hideLabel) {
+    return null;
+  }
+
+  const { label = true } = getUiOptions<T, S, F>(uiSchema, registry.globalUiOptions);
+  if (!label) {
+    return null;
+  }
+
+  const option = options.enumOptions?.find(({ value: enumValue }) => enumOptionsIsSelected(enumValue, value));
+  const description = option?.schema?.description;
+  if (!description) {
+    return null;
+  }
+
+  const DescriptionFieldTemplate = getTemplate<'DescriptionFieldTemplate', T, S, F>(
+    'DescriptionFieldTemplate',
+    registry,
+    options,
+  );
+  return (
+    <DescriptionFieldTemplate
+      id={descriptionId(id)}
+      description={description}
+      schema={option.schema!}
+      uiSchema={uiSchema}
+      registry={registry}
+    />
+  );
+}

package/src/allowAdditionalItems.ts

@@ -1,5 +1,5 @@
 import isObject from './isObject';
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Checks the schema to see if it is allowing additional items, by verifying that `schema.additionalItems` is an
  * object. The user is warned in the console if `schema.additionalItems` has the value `true`.
@@ -9,6 +9,7 @@ import { RJSFSchema, StrictRJSFSchema } from './types';
  */
 export default function allowAdditionalItems<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
   if (schema.additionalItems === true) {
+    // oxlint-disable-next-line no-console
     console.warn('additionalItems=true is currently not supported');
   }
   return isObject(schema.additionalItems);

package/src/asNumber.ts

@@ -14,11 +14,13 @@ export default function asNumber(value: string | null) {
   if (value === null) {
     return null;
   }
+  // oxlint-disable-next-line typescript/prefer-string-starts-ends-with -- regex test() coerces undefined to "undefined" safely; endsWith() throws on undefined values passed at runtime
   if (/\.$/.test(value)) {
     // '3.' can't really be considered a number even if it parses in js. The
     // user is most likely entering a float.
     return value;
   }
+  // oxlint-disable-next-line typescript/prefer-string-starts-ends-with -- same as above
   if (/\.0$/.test(value)) {
     // we need to return this as a string here, to allow for input like 3.07
     return value;

package/src/canExpand.ts

@@ -1,5 +1,5 @@
 import getUiOptions from './getUiOptions';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
 
 /** Checks whether the field described by `schema`, having the `uiSchema` and `formData` supports expanding. The UI for
  * the field can expand if it has additional properties, is not forced as non-expandable by the `uiSchema` and the

package/src/constIsAjvDataReference.ts

@@ -1,8 +1,8 @@
-import { JSONSchema7Type } from 'json-schema';
+import type { JSONSchema7Type } from 'json-schema';
 import isString from 'lodash/isString';
 
 import { CONST_KEY, getSchemaType, isObject } from './';
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { RJSFSchema, StrictRJSFSchema } from './types';
 
 /**
  * Checks if the schema const property value is an AJV $data reference

package/src/constants.ts

@@ -1,9 +1,10 @@
 /** Below are the list of all the keys into various elements of a RJSFSchema or UiSchema that are used by the various
- * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG` and
- * `RJSF_ADDITIONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
- * utility.
+ * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG`,
+ * `RJSF_REF_KEY`, and `RJSF_REF_CYCLE_KEY` Symbols that are added to a schema under certain conditions by the
+ * `retrieveSchema()` utility. Using Symbols keeps these internal markers invisible to JSON serialisation and
+ * JSON Schema validators (AJV, ATA, etc.), which only enumerate string-keyed properties.
  */
-export const ADDITIONAL_PROPERTY_FLAG = '__additional_property';
+export const ADDITIONAL_PROPERTY_FLAG = Symbol('__additional_property');
 export const ADDITIONAL_PROPERTIES_KEY = 'additionalProperties';
 export const ALL_OF_KEY = 'allOf';
 export const ANY_OF_KEY = 'anyOf';
@@ -25,7 +26,8 @@ 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 RJSF_REF_KEY = Symbol('__rjsf_ref');
+export const RJSF_REF_CYCLE_KEY = Symbol('__rjsf_ref_cycle');
 export const SCHEMA_KEY = '$schema';
 export const DEFAULT_ID_PREFIX = 'root';
 export const DEFAULT_ID_SEPARATOR = '_';
@@ -40,8 +42,9 @@ export const FORM_CONTEXT_NAME = 'formContext';
 /** The name of the `layoutGridLookupMap` attribute in the form context
  */
 export const LOOKUP_MAP_NAME = 'layoutGridLookupMap';
-export const RJSF_ADDITIONAL_PROPERTIES_FLAG = '__rjsf_additionalProperties';
-export const ROOT_SCHEMA_PREFIX = '__rjsf_rootSchema';
+export const RJSF_PREFIX_KEY = '__rjsf';
+export const RJSF_ADDITIONAL_PROPERTIES_FLAG = `${RJSF_PREFIX_KEY}_additionalProperties`;
+export const ROOT_SCHEMA_PREFIX = `${RJSF_PREFIX_KEY}_rootSchema`;
 export const UI_FIELD_KEY = 'ui:field';
 export const UI_WIDGET_KEY = 'ui:widget';
 export const UI_OPTIONS_KEY = 'ui:options';

package/src/createErrorHandler.ts

@@ -1,7 +1,7 @@
 import isPlainObject from 'lodash/isPlainObject';
 
 import { ERRORS_KEY } from './constants';
-import { FieldValidation, FormValidation, GenericObjectType } from './types';
+import type { FieldValidation, FormValidation, GenericObjectType } from './types';
 
 /** Given a `formData` object, recursively creates a `FormValidation` error handling structure around it
  *
@@ -19,15 +19,14 @@ export default function createErrorHandler<T = any>(formData: T): FormValidation
     },
   };
   if (Array.isArray(formData)) {
-    return formData.reduce((acc, value, key) => {
-      return { ...acc, [key]: createErrorHandler(value) };
-    }, handler);
+    return formData.reduce((acc, value, key) => ({ ...acc, [key]: createErrorHandler(value) }), handler);
   }
   if (isPlainObject(formData)) {
     const formObject: GenericObjectType = formData as GenericObjectType;
-    return Object.keys(formObject).reduce((acc, key) => {
-      return { ...acc, [key]: createErrorHandler(formObject[key]) };
-    }, handler as FormValidation<T>);
+    return Object.keys(formObject).reduce(
+      (acc, key) => ({ ...acc, [key]: createErrorHandler(formObject[key]) }),
+      handler as FormValidation<T>,
+    );
   }
   return handler as FormValidation<T>;
 }

package/src/createSchemaUtils.ts

@@ -19,7 +19,7 @@ import {
   sanitizeDataForNewSchema,
   toPathSchema,
 } from './schema';
-import {
+import type {
   Experimental_CustomMergeAllOf,
   Experimental_DefaultFormStateBehavior,
   FormContextType,
@@ -63,7 +63,7 @@ class SchemaUtils<
     experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior,
     experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
   ) {
-    if (rootSchema && rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+    if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
       this.rootSchema = makeAllReferencesAbsolute(rootSchema, get(rootSchema, ID_KEY, '#'));
     } else {
       this.rootSchema = rootSchema;
@@ -364,7 +364,9 @@ class SchemaUtils<
    * @param [formData] - The current formData, if any, onto which to provide any missing defaults
    * @returns - The `PathSchema` object for the `schema`
    */
+  // oxlint-disable-next-line typescript/no-deprecated
   toPathSchema(schema: S, name?: string, formData?: T): PathSchema<T> {
+    // oxlint-disable-next-line typescript/no-deprecated
     return toPathSchema<T, S, F>(
       this.validator,
       schema,

package/src/dataURItoBlob.ts

@@ -6,7 +6,7 @@
  */
 export default function dataURItoBlob(dataURILike: string) {
   // check if is dataURI
-  if (dataURILike.indexOf('data:') === -1) {
+  if (!dataURILike.includes('data:')) {
     throw new Error('File is invalid: URI must be a dataURI');
   }
   const dataURI = dataURILike.slice(5);
@@ -32,7 +32,7 @@ export default function dataURItoBlob(dataURILike: string) {
   try {
     const binary = atob(base64);
     const array = new Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
+    for (let i = 0; i < binary.length; i += 1) {
       array[i] = binary.charCodeAt(i);
     }
     // Create the blob object
@@ -40,6 +40,6 @@ export default function dataURItoBlob(dataURILike: string) {
 
     return { blob, name };
   } catch (error) {
-    throw new Error('File is invalid: ' + (error as Error).message);
+    throw new Error(`File is invalid: ${(error as Error).message}`);
   }
 }

package/src/dateRangeOptions.ts

@@ -1,5 +1,5 @@
 import pad from './pad';
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Returns a list of options for a date range between `start` and `stop`. If the start date is greater than the end
  * date, then the date range is reversed. If `start` and `stop` are negative numbers (or zero), then they will be
@@ -14,17 +14,19 @@ export default function dateRangeOptions<S extends StrictRJSFSchema = RJSFSchema
   start: number,
   stop: number,
 ): EnumOptionsType<S>[] {
-  if (start <= 0 && stop <= 0) {
-    start = new Date().getFullYear() + start;
-    stop = new Date().getFullYear() + stop;
-  } else if (start < 0 || stop < 0) {
+  const bothRelative = start <= 0 && stop <= 0;
+  const eitherNegative = start < 0 || stop < 0;
+  if (!bothRelative && eitherNegative) {
     throw new Error(`Both start (${start}) and stop (${stop}) must both be <= 0 or > 0, got one of each`);
   }
-  if (start > stop) {
+  const currentYear = new Date().getFullYear();
+  const resolvedStart = bothRelative ? currentYear + start : start;
+  const resolvedStop = bothRelative ? currentYear + stop : stop;
+  if (resolvedStart > resolvedStop) {
     return dateRangeOptions<S>(stop, start).reverse();
   }
   const options: EnumOptionsType<S>[] = [];
-  for (let i = start; i <= stop; i++) {
+  for (let i = resolvedStart; i <= resolvedStop; i += 1) {
     options.push({ value: i, label: pad(i, 2) });
   }
   return options;

package/src/englishStringTranslator.ts

@@ -1,4 +1,4 @@
-import { TranslatableString } from './enums';
+import type { TranslatableString } from './enums';
 import replaceStringParameters from './replaceStringParameters';
 
 /** Translates a `TranslatableString` value `stringToTranslate` into english. When a `params` array is provided, each

package/src/enumOptionSelectedValue.ts

@@ -1,5 +1,5 @@
 import enumOptionsIndexForValue from './enumOptionsIndexForValue';
-import { EnumOptionsType, OptionValueFormat, StrictRJSFSchema, RJSFSchema } from './types';
+import type { EnumOptionsType, OptionValueFormat, StrictRJSFSchema, RJSFSchema } from './types';
 
 /** Computes the value to pass to a select element's `value` attribute.
  *

package/src/enumOptionValueDecoder.ts

@@ -1,5 +1,5 @@
 import enumOptionsValueForIndex from './enumOptionsValueForIndex';
-import { EnumOptionsType, OptionValueFormat, StrictRJSFSchema, RJSFSchema } from './types';
+import type { EnumOptionsType, OptionValueFormat, StrictRJSFSchema, RJSFSchema } from './types';
 
 /** Resolves a single DOM value string back to its typed enum value in `'realValue'` mode.
  *
@@ -27,7 +27,7 @@ function decodeSingle<S extends StrictRJSFSchema = RJSFSchema>(
   }
   // Fallback: value might be an index (for object/array enum values)
   const index = Number(value);
-  if (!isNaN(index) && index >= 0 && index < enumOptions.length) {
+  if (!Number.isNaN(index) && index >= 0 && index < enumOptions.length) {
     return enumOptions[index].value;
   }
   return emptyValue;

package/src/enumOptionValueEncoder.ts

@@ -1,6 +1,6 @@
 import isNil from 'lodash/isNil';
 
-import { OptionValueFormat } from './types';
+import type { OptionValueFormat } from './types';
 
 /** Encodes an enum option value into a string for a DOM value attribute.
  *

package/src/enumOptionsDeselectValue.ts

@@ -1,6 +1,6 @@
 import deepEquals from './deepEquals';
 import enumOptionsValueForIndex from './enumOptionsValueForIndex';
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Removes the enum option value at the `valueIndex` from the currently `selected` (list of) value(s). If `selected` is
  * a list, then that list is updated to remove the enum option value with the `valueIndex` in `allEnumOptions`. If it is

package/src/enumOptionsIndexForValue.ts

@@ -1,5 +1,5 @@
 import enumOptionsIsSelected from './enumOptionsIsSelected';
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Returns the index(es) of the options in `allEnumOptions` whose value(s) match the ones in `value`. All the
  * `enumOptions` are filtered based on whether they are a "selected" `value` and the index of each selected one is then
@@ -19,7 +19,7 @@ export default function enumOptionsIndexForValue<S extends StrictRJSFSchema = RJ
 ): string | string[] | undefined {
   const selectedIndexes: string[] = allEnumOptions
     .map((opt, index) => (enumOptionsIsSelected(opt.value, value) ? String(index) : undefined))
-    .filter((opt) => typeof opt !== 'undefined') as string[];
+    .filter((opt) => typeof opt !== 'undefined');
   if (!multiple) {
     return selectedIndexes[0];
   }

package/src/enumOptionsIsSelected.ts

@@ -1,5 +1,5 @@
 import deepEquals from './deepEquals';
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Determines whether the given `value` is (one of) the `selected` value(s).
  *

package/src/enumOptionsSelectValue.ts

@@ -1,7 +1,7 @@
 import isNil from 'lodash/isNil';
 
 import enumOptionsValueForIndex from './enumOptionsValueForIndex';
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Add the enum option value at the `valueIndex` to the list of `selected` values in the proper order as defined by
  * `allEnumOptions`

package/src/enumOptionsValueForIndex.ts

@@ -1,4 +1,4 @@
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Returns the value(s) from `allEnumOptions` at the index(es) provided by `valueIndex`. If `valueIndex` is not an
  * array AND the index is not valid for `allEnumOptions`, `emptyValue` is returned. If `valueIndex` is an array, AND it
@@ -12,7 +12,7 @@ import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
  *        `emptyValue` or an empty list.
  */
 export default function enumOptionsValueForIndex<S extends StrictRJSFSchema = RJSFSchema>(
-  valueIndex: string | number | Array<string | number>,
+  valueIndex: string | number | (string | number)[],
   allEnumOptions: EnumOptionsType<S>[] = [],
   emptyValue?: EnumOptionsType<S>['value'],
 ): EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][] | undefined {

package/src/enums.ts

@@ -27,6 +27,8 @@ export enum TranslatableString {
   AddItemButton = 'Add Item',
   /** Copy button title, used by IconButton */
   CopyButton = 'Copy',
+  /** Expand cycle button title */
+  ExpandButton = 'Expand Cycle',
   /** Move down button title, used by IconButton */
   MoveDownButton = 'Move down',
   /** Move up button title, used by IconButton */
@@ -70,6 +72,8 @@ export enum TranslatableString {
   KeyLabel = '%1 Key',
   /** Deprecated label, where %1 will be replaced by the label as provided by SchemaField */
   DeprecatedLabel = '%1 (deprecated)',
+  /** Cyclic schema message */
+  CycleDetected = 'Circular reference ($ref cycle) detected for field "%1". You may choose to expand to the next cycle break',
   // Strings with replaceable parameters AND/OR that support markdown and html
   /** Invalid object field configuration as provided by the ObjectField.
    * NOTE: Use markdown notation rather than html tags.

package/src/findSchemaDefinition.ts

@@ -13,7 +13,7 @@ import {
   REF_KEY,
   SCHEMA_KEY,
 } from './constants';
-import { GenericObjectType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { GenericObjectType, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Looks for the `$id` pointed by `ref` in the schema definitions embedded in
  * a JSON Schema bundle
@@ -32,14 +32,14 @@ function findEmbeddedSchemaRecursive<S extends StrictRJSFSchema = RJSFSchema>(sc
         if (isObject(item)) {
           const result = findEmbeddedSchemaRecursive<S>(item as S, ref);
           if (result !== undefined) {
-            return result as S;
+            return result;
           }
         }
       }
     } else if (isObject(subSchema)) {
       const result = findEmbeddedSchemaRecursive<S>(subSchema as S, ref);
       if (result !== undefined) {
-        return result as S;
+        return result;
       }
     }
   }
@@ -53,22 +53,23 @@ function findEmbeddedSchemaRecursive<S extends StrictRJSFSchema = RJSFSchema>(sc
  */
 export function makeAllReferencesAbsolute<S extends StrictRJSFSchema = RJSFSchema>(schema: S, baseURI: string): S {
   const currentURI = get(schema, ID_KEY, baseURI);
+  let result = schema;
   // Make all other references absolute
-  if (REF_KEY in schema) {
-    schema = { ...schema, [REF_KEY]: UriResolver.resolve(currentURI, schema[REF_KEY]!) };
+  if (REF_KEY in result) {
+    result = { ...result, [REF_KEY]: UriResolver.resolve(currentURI, result[REF_KEY]!) };
   }
   // Look for references in nested subschemas
-  for (const [key, subSchema] of Object.entries(schema)) {
+  for (const [key, subSchema] of Object.entries(result)) {
     if (Array.isArray(subSchema)) {
-      schema = {
-        ...schema,
+      result = {
+        ...result,
         [key]: subSchema.map((item) => (isObject(item) ? makeAllReferencesAbsolute(item as S, currentURI) : item)),
       };
     } else if (isObject(subSchema)) {
-      schema = { ...schema, [key]: makeAllReferencesAbsolute(subSchema as S, currentURI) };
+      result = { ...result, [key]: makeAllReferencesAbsolute(subSchema as S, currentURI) };
     }
   }
-  return schema;
+  return result;
 }
 
 /** Splits out the value at the `key` in `object` from the `object`, returning an array that contains in the first
@@ -105,23 +106,24 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
 ): S {
   const ref = $ref || '';
   let current: S | undefined = undefined;
+  let currentBaseURI = baseURI;
   if (ref.startsWith('#')) {
     // Decode URI fragment representation.
     const decodedRef = decodeURIComponent(ref.substring(1));
-    if (baseURI === undefined || (ID_KEY in rootSchema && rootSchema[ID_KEY] === baseURI)) {
+    if (currentBaseURI === undefined || (ID_KEY in rootSchema && rootSchema[ID_KEY] === currentBaseURI)) {
       current = jsonpointer.get(rootSchema, decodedRef);
     } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-      current = findEmbeddedSchemaRecursive<S>(rootSchema, baseURI.replace(/\/$/, ''));
+      current = findEmbeddedSchemaRecursive<S>(rootSchema, currentBaseURI.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 resolvedRef = currentBaseURI ? UriResolver.resolve(currentBaseURI, ref) : ref;
     const [refId, ...refAnchor] = resolvedRef.replace(/#\/?$/, '').split('#');
     current = findEmbeddedSchemaRecursive<S>(rootSchema, refId.replace(/\/$/, ''));
     if (current !== undefined) {
-      baseURI = current[ID_KEY];
+      currentBaseURI = current[ID_KEY];
       if (!isEmpty(refAnchor)) {
         current = jsonpointer.get(current, decodeURIComponent(refAnchor.join('#')));
       }
@@ -142,16 +144,15 @@ 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], baseURI);
+    const subSchema = findSchemaDefinitionRecursive<S>(theRef, rootSchema, [...recurseList, ref], currentBaseURI);
     if (Object.keys(remaining).length > 0) {
       if (
         rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2019_09 ||
         rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12
       ) {
         return { [ALL_OF_KEY]: [remaining, subSchema] } as S;
-      } else {
-        return { ...remaining, ...subSchema };
       }
+      return { ...remaining, ...subSchema };
     }
     return subSchema;
   }

package/src/getChangedFields.ts

@@ -31,11 +31,11 @@ export default function getChangedFields(a: unknown, b: unknown): string[] {
   }
   if (aIsPlainObject && !bIsPlainObject) {
     return keys(a);
-  } else if (!aIsPlainObject && bIsPlainObject) {
+  }
+  if (!aIsPlainObject && bIsPlainObject) {
     return keys(b);
-  } else {
-    const unequalFields = keys(pickBy(a as object, (value, key) => !deepEquals(value, get(b, key))));
-    const diffFields = difference(keys(b), keys(a));
-    return [...unequalFields, ...diffFields];
   }
+  const unequalFields = keys(pickBy(a as object, (value, key) => !deepEquals(value, get(b, key))));
+  const diffFields = difference(keys(b), keys(a));
+  return [...unequalFields, ...diffFields];
 }

package/src/getDateElementProps.ts

@@ -1,14 +1,14 @@
-import { type DateObject } from './types';
+import type { DateObject } from './types';
 
 /** Available options for re-ordering date input element */
 export type DateElementFormat = 'DMY' | 'MDY' | 'YMD';
 
 /** Type describing format of DateElement prop */
-export type DateElementProp = {
+export interface DateElementProp {
   type: string;
   range: [number, number];
   value: number | undefined;
-};
+}
 
 /** Given date & time information with optional yearRange & format, returns props for DateElement
  *

package/src/getDiscriminatorFieldFromSchema.ts

@@ -2,7 +2,7 @@ import get from 'lodash/get';
 import isString from 'lodash/isString';
 
 import { DISCRIMINATOR_PATH } from './constants';
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Returns the `discriminator.propertyName` when defined in the `schema` if it is a string. A warning is generated when
  * it is not a string. Returns `undefined` when a valid discriminator is not present.
@@ -16,6 +16,7 @@ export default function getDiscriminatorFieldFromSchema<S extends StrictRJSFSche
   if (isString(maybeString)) {
     discriminator = maybeString;
   } else if (maybeString !== undefined) {
+    // oxlint-disable-next-line no-console
     console.warn(`Expecting discriminator to be a string, got "${typeof maybeString}" instead`);
   }
   return discriminator;

package/src/getInputProps.ts

@@ -1,5 +1,5 @@
 import rangeSpec from './rangeSpec';
-import { FormContextType, InputPropsType, RJSFSchema, StrictRJSFSchema, UIOptionsType } from './types';
+import type { FormContextType, InputPropsType, RJSFSchema, StrictRJSFSchema, UIOptionsType } from './types';
 
 /** Using the `schema`, `defaultType` and `options`, extract out the props for the <input> element that make sense.
  *