@rjsf/utils 5.0.0-beta.1

package/dist/mergeSchemas.d.ts

@@ -0,0 +1,10 @@
+import { GenericObjectType } from "./types";
+/** Recursively merge deeply nested schemas. The difference between `mergeSchemas` and `mergeObjects` is that
+ * `mergeSchemas` only concats arrays for values under the 'required' keyword, and when it does, it doesn't include
+ * duplicate values.
+ *
+ * @param obj1 - The first schema object to merge
+ * @param obj2 - The second schema object to merge
+ * @returns - The merged schema object
+ */
+export default function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjectType): GenericObjectType;

package/dist/optionsList.d.ts

@@ -0,0 +1,10 @@
+import { RJSFSchema, EnumOptionsType } from "./types";
+/** Gets the list of options from the schema. If the schema has an enum list, then those enum values are returned. The
+ * labels for the options will be extracted from the non-standard, RJSF-deprecated `enumNames` if it exists, otherwise
+ * the label will be the same as the `value`. If the schema has a `oneOf` or `anyOf`, then the value is the list of
+ * `const` values from the schema and the label is either the `schema.title` or the value.
+ *
+ * @param schema - The schema from which to extract the options list
+ * @returns - The list of options from the schema
+ */
+export default function optionsList(schema: RJSFSchema): EnumOptionsType[] | undefined;

package/dist/orderProperties.d.ts

@@ -0,0 +1,11 @@
+/** Given a list of `properties` and an `order` list, returns a list that contains the `properties` ordered correctly.
+ * If `order` is not an array, then the untouched `properties` list is returned. Otherwise `properties` is ordered per
+ * the `order` list. If `order` contains a '*' then any `properties` that are not mentioned explicity in `order` will be
+ * places in the location of the `*`.
+ *
+ * @param properties - The list of property keys to be ordered
+ * @param order - An array of property keys to be ordered first, with an optional '*' property
+ * @returns - A list with the `properties` ordered
+ * @throws - Error when the properties cannot be ordered correctly
+ */
+export default function orderProperties(properties: string[], order?: string[]): string[];

package/dist/pad.d.ts

@@ -0,0 +1,7 @@
+/** Returns a string representation of the `num` that is padded with leading "0"s if necessary
+ *
+ * @param num - The number to pad
+ * @param width - The width of the string at which no lead padding is necessary
+ * @returns - The number converted to a string with leading zero padding if the number of digits is less than `width`
+ */
+export default function pad(num: number, width: number): string;

package/dist/parseDateString.d.ts

@@ -0,0 +1,9 @@
+import { DateObject } from "./types";
+/** Parses the `dateString` into a `DateObject`, including the time information when `includeTime` is true
+ *
+ * @param dateString - The date string to parse into a DateObject
+ * @param [includeTime=true] - Optional flag, if false, will not include the time data into the object
+ * @returns - The date string converted to a `DateObject`
+ * @throws - Error when the date cannot be parsed from the string
+ */
+export default function parseDateString(dateString?: string, includeTime?: boolean): DateObject;

package/dist/processSelectValue.d.ts

@@ -0,0 +1,11 @@
+import { RJSFSchema, UIOptionsType } from "./types";
+/** Returns the real value for a select widget due to a silly limitation in the DOM which causes option change event
+ * values to always be retrieved as strings. Uses the `schema` to help determine the value's true type. If the value is
+ * an empty string, then the `emptyValue` from the `options` is returned, falling back to undefined.
+ *
+ * @param schema - The schema to used to determine the value's true type
+ * @param [value] - The value to convert
+ * @param [options] - The UIOptionsType from which to potentially extract the emptyValue
+ * @returns - The `value` converted to the proper type
+ */
+export default function processSelectValue<T = any, F = any>(schema: RJSFSchema, value?: any, options?: UIOptionsType<T, F>): any;

package/dist/rangeSpec.d.ts

@@ -0,0 +1,9 @@
+import { RangeSpecType } from "./types";
+import { RJSFSchema } 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 }`.
+ *
+ * @param schema - The schema from which to extract the range spec
+ * @returns - A range specification from the schema
+ */
+export default function rangeSpec(schema: RJSFSchema): RangeSpecType;

package/dist/schema/getDefaultFormState.d.ts

@@ -0,0 +1,47 @@
+import { RJSFSchema, ValidatorType } from "../types";
+/** Enum that indicates how `schema.additionalItems` should be handled by the `getInnerSchemaForArrayItem()` function.
+ */
+export declare enum AdditionalItemsHandling {
+    Ignore = 0,
+    Invert = 1,
+    Fallback = 2
+}
+/** Given a `schema` will return an inner schema that for an array item. This is computed differently based on the
+ * `additionalItems` enum and the value of `idx`. There are four possible returns:
+ * 1. If `idx` is >= 0, then if `schema.items` is an array the `idx`th element of the array is returned if it is a valid
+ *    index and not a boolean, otherwise it falls through to 3.
+ * 2. If `schema.items` is not an array AND truthy and not a boolean, then `schema.items` is returned since it actually
+ *    is a schema, otherwise it falls through to 3.
+ * 3. If `additionalItems` is not `AdditionalItemsHandling.Ignore` and `schema.additionalItems` is an object, then
+ *    `schema.additionalItems` is returned since it actually is a schema, otherwise it falls through to 4.
+ * 4. {} is returned representing an empty schema
+ *
+ * @param schema - The schema from which to get the particular item
+ * @param [additionalItems=AdditionalItemsHandling.Ignore] - How do we want to handle additional items?
+ * @param [idx=-1] - Index, if non-negative, will be used to return the idx-th element in a `schema.items` array
+ * @returns - The best fit schema object from the `schema` given the `additionalItems` and `idx` modifiers
+ */
+export declare function getInnerSchemaForArrayItem(schema: RJSFSchema, additionalItems?: AdditionalItemsHandling, idx?: number): RJSFSchema;
+/** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into
+ * the each level of the schema, recursively, to fill out every level of defaults provided by the schema.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the default state is desired
+ * @param [parentDefaults] - Any defaults provided by the parent field in the schema
+ * @param [rootSchema] - The options root schema, used to primarily to look up `$ref`s
+ * @param [rawFormData] - The current formData, if any, onto which to provide any missing defaults
+ * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
+ * @returns - The resulting `formData` with all the defaults provided
+ */
+export declare function computeDefaults<T = any>(validator: ValidatorType, schema: RJSFSchema, parentDefaults?: T, rootSchema?: RJSFSchema, rawFormData?: T, includeUndefinedValues?: boolean): T | T[] | undefined;
+/** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
+ * computed to have defaults provided in the `schema`.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which the default state is desired
+ * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
+ * @returns - The resulting `formData` with all the defaults provided
+ */
+export default function getDefaultFormState<T = any>(validator: ValidatorType, theSchema: RJSFSchema, formData?: T, rootSchema?: RJSFSchema, includeUndefinedValues?: boolean): T | T[] | undefined;

package/dist/schema/getDisplayLabel.d.ts

@@ -0,0 +1,11 @@
+import { RJSFSchema, UiSchema, ValidatorType } from "../types";
+/** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
+ * should be displayed in a UI.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the display label flag is desired
+ * @param [uiSchema={}] - The UI schema from which to derive potentially displayable information
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if the label should be displayed or false if it should not
+ */
+export default function getDisplayLabel<T = any, F = any>(validator: ValidatorType, schema: RJSFSchema, uiSchema?: UiSchema<T, F>, rootSchema?: RJSFSchema): boolean;

package/dist/schema/getMatchingOption.d.ts

@@ -0,0 +1,10 @@
+import { RJSFSchema, ValidatorType } from "../types";
+/** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param formData - The current formData, if any, used to figure out a match
+ * @param options - The list of options to find a matching options from
+ * @param rootSchema - The root schema, used to primarily to look up `$ref`s
+ * @returns - The index of the matched option or 0 if none is available
+ */
+export default function getMatchingOption<T = any>(validator: ValidatorType, formData: T | undefined, options: RJSFSchema[], rootSchema: RJSFSchema): number;

package/dist/schema/index.d.ts

@@ -0,0 +1,11 @@
+import getDefaultFormState from "./getDefaultFormState";
+import getDisplayLabel from "./getDisplayLabel";
+import getMatchingOption from "./getMatchingOption";
+import isFilesArray from "./isFilesArray";
+import isMultiSelect from "./isMultiSelect";
+import isSelect from "./isSelect";
+import mergeValidationData from "./mergeValidationData";
+import retrieveSchema from "./retrieveSchema";
+import toIdSchema from "./toIdSchema";
+import toPathSchema from "./toPathSchema";
+export { getDefaultFormState, getDisplayLabel, getMatchingOption, isFilesArray, isMultiSelect, isSelect, mergeValidationData, retrieveSchema, toIdSchema, toPathSchema, };

package/dist/schema/isFilesArray.d.ts

@@ -0,0 +1,10 @@
+import { RJSFSchema, UiSchema, ValidatorType } from "../types";
+/** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for array of files flag is desired
+ * @param [uiSchema={}] - The UI schema from which to check the widget
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema/uiSchema contains an array of files, otherwise false
+ */
+export default function isFilesArray<T = any, F = any>(validator: ValidatorType, schema: RJSFSchema, uiSchema?: UiSchema<T, F>, rootSchema?: RJSFSchema): boolean;

package/dist/schema/isMultiSelect.d.ts

@@ -0,0 +1,9 @@
+import { RJSFSchema, ValidatorType } from "../types";
+/** Checks to see if the `schema` combination represents a multi-select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for a multi-select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a multi-select, otherwise false
+ */
+export default function isMultiSelect<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema?: RJSFSchema): boolean;

package/dist/schema/isSelect.d.ts

@@ -0,0 +1,9 @@
+import { RJSFSchema, ValidatorType } from "../types";
+/** Checks to see if the `schema` combination represents a select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which check for a select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a select, otherwise false
+ */
+export default function isSelect<T = any>(validator: ValidatorType, theSchema: RJSFSchema, rootSchema?: RJSFSchema): boolean;

package/dist/schema/mergeValidationData.d.ts

@@ -0,0 +1,12 @@
+import { ErrorSchema, ValidationData, ValidatorType } from "../types";
+/** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
+ * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
+ * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
+ * `validationData` is returned.
+ *
+ * @param validator - The validator used to convert an ErrorSchema to a list of errors
+ * @param validationData - The current `ValidationData` into which to merge the additional errors
+ * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema`
+ * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+ */
+export default function mergeValidationData<T = any>(validator: ValidatorType<T>, validationData: ValidationData<T>, additionalErrorSchema?: ErrorSchema<T>): ValidationData<T>;

package/dist/schema/retrieveSchema.d.ts

@@ -0,0 +1,98 @@
+import { GenericObjectType, RJSFSchema, RJSFSchemaDefinition, ValidatorType } from "../types";
+/** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
+ * with the rest of the schema
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that is used to detect valid schema conditions
+ * @param schema - The schema for which resolving a condition is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param formData - The current formData to assist retrieving a schema
+ * @returns - A schema with the appropriate condition resolved
+ */
+export declare function resolveCondition<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, formData: T): import("json-schema").JSONSchema7;
+/** Resolves references and dependencies within a schema and its 'allOf' children.
+ * Called internally by retrieveSchema.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a schema is desired
+ * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema having its references and dependencies resolved
+ */
+export declare function resolveSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema?: RJSFSchema, formData?: T): RJSFSchema;
+/** Resolves references within a schema and its 'allOf' children.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a reference is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema having its references resolved
+ */
+export declare function resolveReference<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, formData?: T): RJSFSchema;
+/** Creates new 'properties' items for each key in the `formData`
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which the existing additional properties is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param validator
+ * @param [aFormData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The updated schema with additional properties stubbed
+ */
+export declare function stubExistingAdditionalProperties<T = any>(validator: ValidatorType, theSchema: RJSFSchema, rootSchema?: RJSFSchema, aFormData?: T): RJSFSchema;
+/** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
+ * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
+ * potentially recursive resolution.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which retrieving a schema is desired
+ * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
+ * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+ */
+export default function retrieveSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema?: RJSFSchema, rawFormData?: T): RJSFSchema;
+/** Resolves dependencies within a schema and its 'allOf' children.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a dependency is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema with its dependencies resolved
+ */
+export declare function resolveDependencies<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, formData?: T): RJSFSchema;
+/** Processes all the `dependencies` recursively into the `resolvedSchema` as needed
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param dependencies - The set of dependencies that needs to be processed
+ * @param resolvedSchema - The schema for which processing dependencies is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema with the `dependencies` resolved into it
+ */
+export declare function processDependencies<T = any>(validator: ValidatorType, dependencies: RJSFSchema["dependencies"], resolvedSchema: RJSFSchema, rootSchema: RJSFSchema, formData?: T): RJSFSchema;
+/** Updates a schema with additionally required properties added
+ *
+ * @param schema - The schema for which resolving a dependent properties is desired
+ * @param [additionallyRequired] - An optional array of additionally required names
+ * @returns - The schema with the additional required values merged in
+ */
+export declare function withDependentProperties(schema: RJSFSchema, additionallyRequired?: string[]): import("json-schema").JSONSchema7;
+/** Merges a dependent schema into the `schema` dealing with oneOfs and references
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a dependent schema is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param dependencyKey - The key name of the dependency
+ * @param dependencyValue - The potentially dependent schema
+ * @param formData- The current formData to assist retrieving a schema
+ * @returns - The schema with the dependent schema resolved into it
+ */
+export declare function withDependentSchema<T>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, dependencyKey: string, dependencyValue: RJSFSchema, formData?: T): GenericObjectType;
+/** Returns a `schema` with the best choice from the `oneOf` options merged into it
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used to validate oneOf options
+ * @param schema - The schema for which resolving a oneOf subschema is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param dependencyKey - The key name of the oneOf dependency
+ * @param oneOf - The list of schemas representing the oneOf options
+ * @param [formData] - The current formData to assist retrieving a schema
+ * @returns  The schema with best choice of oneOf schemas merged into
+ */
+export declare function withExactlyOneSubschema<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, dependencyKey: string, oneOf: RJSFSchemaDefinition[], formData?: T): GenericObjectType;

package/dist/schema/toIdSchema.d.ts

@@ -0,0 +1,13 @@
+import { IdSchema, RJSFSchema, ValidatorType } from "../types";
+/** Generates an `IdSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `IdSchema` is desired
+ * @param [id] - The base id for the schema
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @param [idPrefix='root'] - The prefix to use for the id
+ * @param [idSeparator='_'] - The separator to use for the path segments in the id
+ * @returns - The `IdSchema` object for the `schema`
+ */
+export default function toIdSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, id?: string | null, rootSchema?: RJSFSchema, formData?: T, idPrefix?: string, idSeparator?: string): IdSchema<T>;

package/dist/schema/toPathSchema.d.ts

@@ -0,0 +1,11 @@
+import { PathSchema, RJSFSchema, ValidatorType } from "../types";
+/** Generates an `PathSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `PathSchema` is desired
+ * @param [name=''] - The base name for the schema
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The `PathSchema` object for the `schema`
+ */
+export default function toPathSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, name?: string, rootSchema?: RJSFSchema, formData?: T): PathSchema<T>;

package/dist/schemaRequiresTrueValue.d.ts

@@ -0,0 +1,11 @@
+import { RJSFSchema } from "./types";
+/** Check to see if a `schema` specifies that a value must be true. This happens when:
+ * - `schema.const` is truthy
+ * - `schema.enum` == `[true]`
+ * - `schema.anyOf` or `schema.oneOf` has a single value which recursively returns true
+ * - `schema.allOf` has at least one value which recursively returns true
+ *
+ * @param schema - The schema to check
+ * @returns - True if the schema specifies a value that must be true, false otherwise
+ */
+export default function schemaRequiresTrueValue(schema: RJSFSchema): boolean;

package/dist/shouldRender.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+/** Determines whether the given `component` should be rerendered by comparing its current set of props and state
+ * against the next set. If either of those two sets are not the same, then the component should be rerendered.
+ *
+ * @param component - A React component being checked
+ * @param nextProps - The next set of props against which to check
+ * @param nextState - The next set of state against which to check
+ * @returns - True if the component should be re-rendered, false otherwise
+ */
+export default function shouldRender(component: React.Component, nextProps: any, nextState: any): boolean;

package/dist/toConstant.d.ts

@@ -0,0 +1,9 @@
+import { RJSFSchema } from "./types";
+/** Returns the constant value from the schema when it is either a single value enum or has a const key. Otherwise
+ * throws an error.
+ *
+ * @param schema - The schema from which to obtain the constant value
+ * @returns - The constant value for the schema
+ * @throws - Error when the schema does not have a constant value
+ */
+export default function toConstant(schema: RJSFSchema): import("json-schema").JSONSchema7Type | undefined;

package/dist/toDateString.d.ts

@@ -0,0 +1,9 @@
+import { DateObject } from "./types";
+/** Returns a UTC date string for the given `dateObject`. If `time` is false, then the time portion of the string is
+ * removed.
+ *
+ * @param dateObject - The `DateObject` to convert to a date string
+ * @param [time=true] - Optional flag used to remove the time portion of the date string if false
+ * @returns - The UTC date string
+ */
+export default function toDateString(dateObject: DateObject, time?: boolean): string;