@rjsf/utils 5.11.2 → 5.12.0

package/lib/ErrorSchemaBuilder.d.ts

@@ -0,0 +1,60 @@
+import { ErrorSchema } from './types';
+/** The `ErrorSchemaBuilder<T>` is used to build an `ErrorSchema<T>` since the definition of the `ErrorSchema` type is
+ * designed for reading information rather than writing it. Use this class to add, replace or clear errors in an error
+ * schema by using either dotted path or an array of path names. Once you are done building the `ErrorSchema`, you can
+ * get the result and/or reset all the errors back to an initial set and start again.
+ */
+export default class ErrorSchemaBuilder<T = any> {
+    /** The error schema being built
+     *
+     * @private
+     */
+    private errorSchema;
+    /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     */
+    constructor(initialSchema?: ErrorSchema<T>);
+    /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
+     */
+    get ErrorSchema(): ErrorSchema<T>;
+    /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one.
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The error block for the given `pathOfError` or the root if not provided
+     * @private
+     */
+    private getOrCreateErrorBlock;
+    /** Resets all errors in the `ErrorSchemaBuilder` back to the `initialSchema` if provided, otherwise an empty set.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    resetAllErrors(initialSchema?: ErrorSchema<T>): this;
+    /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within
+     * the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    addErrors(errorOrList: string | string[], pathOfError?: string | string[]): this;
+    /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location
+     * within the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    setErrors(errorOrList: string | string[], pathOfError?: string | string[]): this;
+    /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
+     * the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    clearErrors(pathOfError?: string | string[]): this;
+}

package/lib/ErrorSchemaBuilder.js

@@ -0,0 +1,103 @@
+import cloneDeep from 'lodash/cloneDeep';
+import get from 'lodash/get';
+import set from 'lodash/set';
+import { ERRORS_KEY } from './constants';
+/** The `ErrorSchemaBuilder<T>` is used to build an `ErrorSchema<T>` since the definition of the `ErrorSchema` type is
+ * designed for reading information rather than writing it. Use this class to add, replace or clear errors in an error
+ * schema by using either dotted path or an array of path names. Once you are done building the `ErrorSchema`, you can
+ * get the result and/or reset all the errors back to an initial set and start again.
+ */
+export default class ErrorSchemaBuilder {
+    /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     */
+    constructor(initialSchema) {
+        /** The error schema being built
+         *
+         * @private
+         */
+        this.errorSchema = {};
+        this.resetAllErrors(initialSchema);
+    }
+    /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
+     */
+    get ErrorSchema() {
+        return this.errorSchema;
+    }
+    /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one.
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The error block for the given `pathOfError` or the root if not provided
+     * @private
+     */
+    getOrCreateErrorBlock(pathOfError) {
+        const hasPath = (Array.isArray(pathOfError) && pathOfError.length > 0) || typeof pathOfError === 'string';
+        let errorBlock = hasPath ? get(this.errorSchema, pathOfError) : this.errorSchema;
+        if (!errorBlock && pathOfError) {
+            errorBlock = {};
+            set(this.errorSchema, pathOfError, errorBlock);
+        }
+        return errorBlock;
+    }
+    /** Resets all errors in the `ErrorSchemaBuilder` back to the `initialSchema` if provided, otherwise an empty set.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    resetAllErrors(initialSchema) {
+        this.errorSchema = initialSchema ? cloneDeep(initialSchema) : {};
+        return this;
+    }
+    /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within
+     * the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    addErrors(errorOrList, pathOfError) {
+        const errorBlock = this.getOrCreateErrorBlock(pathOfError);
+        let errorsList = get(errorBlock, ERRORS_KEY);
+        if (!Array.isArray(errorsList)) {
+            errorsList = [];
+            errorBlock[ERRORS_KEY] = errorsList;
+        }
+        if (Array.isArray(errorOrList)) {
+            errorsList.push(...errorOrList);
+        }
+        else {
+            errorsList.push(errorOrList);
+        }
+        return this;
+    }
+    /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location
+     * within the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    setErrors(errorOrList, pathOfError) {
+        const errorBlock = this.getOrCreateErrorBlock(pathOfError);
+        // Effectively clone the array being given to prevent accidental outside manipulation of the given list
+        const listToAdd = Array.isArray(errorOrList) ? [...errorOrList] : [errorOrList];
+        set(errorBlock, ERRORS_KEY, listToAdd);
+        return this;
+    }
+    /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
+     * the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    clearErrors(pathOfError) {
+        const errorBlock = this.getOrCreateErrorBlock(pathOfError);
+        set(errorBlock, ERRORS_KEY, []);
+        return this;
+    }
+}
+//# sourceMappingURL=ErrorSchemaBuilder.js.map

package/lib/ErrorSchemaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorSchemaBuilder.js","sourceRoot":"","sources":["../src/ErrorSchemaBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,kBAAkB,CAAC;AACzC,OAAO,GAAG,MAAM,YAAY,CAAC;AAC7B,OAAO,GAAG,MAAM,YAAY,CAAC;AAG7B,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAkB;IAOrC;;;OAGG;IACH,YAAY,aAA8B;QAV1C;;;WAGG;QACK,gBAAW,GAAmB,EAAE,CAAC;QAOvC,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;IACrC,CAAC;IAED;OACG;IACH,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACK,qBAAqB,CAAC,WAA+B;QAC3D,MAAM,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,OAAO,WAAW,KAAK,QAAQ,CAAC;QAC1G,IAAI,UAAU,GAAgB,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;QAC9F,IAAI,CAAC,UAAU,IAAI,WAAW,EAAE;YAC9B,UAAU,GAAG,EAAE,CAAC;YAChB,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;SAChD;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,aAA8B;QAC3C,IAAI,CAAC,WAAW,GAAG,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACjE,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,WAA8B,EAAE,WAA+B;QACvE,MAAM,UAAU,GAAgB,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QACxE,IAAI,UAAU,GAAG,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAC7C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YAC9B,UAAU,GAAG,EAAE,CAAC;YAChB,UAAU,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;SACrC;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;YAC9B,UAAU,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;SACjC;aAAM;YACL,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;SAC9B;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,WAA8B,EAAE,WAA+B;QACvE,MAAM,UAAU,GAAgB,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QACxE,uGAAuG;QACvG,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QAChF,GAAG,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,WAA+B;QACzC,MAAM,UAAU,GAAgB,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QACxE,GAAG,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/lib/allowAdditionalItems.d.ts

@@ -0,0 +1,8 @@
+import { 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`.
+ *
+ * @param schema - The schema object to check
+ * @returns - True if additional items is allowed, otherwise false
+ */
+export default function allowAdditionalItems<S extends StrictRJSFSchema = RJSFSchema>(schema: S): boolean;

package/lib/allowAdditionalItems.js

@@ -0,0 +1,14 @@
+import isObject from './isObject';
+/** 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`.
+ *
+ * @param schema - The schema object to check
+ * @returns - True if additional items is allowed, otherwise false
+ */
+export default function allowAdditionalItems(schema) {
+    if (schema.additionalItems === true) {
+        console.warn('additionalItems=true is currently not supported');
+    }
+    return isObject(schema.additionalItems);
+}
+//# sourceMappingURL=allowAdditionalItems.js.map

package/lib/allowAdditionalItems.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowAdditionalItems.js","sourceRoot":"","sources":["../src/allowAdditionalItems.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,YAAY,CAAC;AAGlC;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAA0C,MAAS;IAC7F,IAAI,MAAM,CAAC,eAAe,KAAK,IAAI,EAAE;QACnC,OAAO,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;KACjE;IACD,OAAO,QAAQ,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AAC1C,CAAC"}

package/lib/asNumber.d.ts

@@ -0,0 +1,10 @@
+/** Attempts to convert the string into a number. If an empty string is provided, then `undefined` is returned. If a
+ * `null` is provided, it is returned. If the string ends in a `.` then the string is returned because the user may be
+ * in the middle of typing a float number. If a number ends in a pattern like `.0`, `.20`, `.030`, string is returned
+ * because the user may be typing number that will end in a non-zero digit. Otherwise, the string is wrapped by
+ * `Number()` and if that result is not `NaN`, that number will be returned, otherwise the string `value` will be.
+ *
+ * @param value - The string or null value to convert to a number
+ * @returns - The `value` converted to a number when appropriate, otherwise the `value`
+ */
+export default function asNumber(value: string | null): string | number | null | undefined;

package/lib/asNumber.js

@@ -0,0 +1,36 @@
+/** Attempts to convert the string into a number. If an empty string is provided, then `undefined` is returned. If a
+ * `null` is provided, it is returned. If the string ends in a `.` then the string is returned because the user may be
+ * in the middle of typing a float number. If a number ends in a pattern like `.0`, `.20`, `.030`, string is returned
+ * because the user may be typing number that will end in a non-zero digit. Otherwise, the string is wrapped by
+ * `Number()` and if that result is not `NaN`, that number will be returned, otherwise the string `value` will be.
+ *
+ * @param value - The string or null value to convert to a number
+ * @returns - The `value` converted to a number when appropriate, otherwise the `value`
+ */
+export default function asNumber(value) {
+    if (value === '') {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    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;
+    }
+    if (/\.0$/.test(value)) {
+        // we need to return this as a string here, to allow for input like 3.07
+        return value;
+    }
+    if (/\.\d*0$/.test(value)) {
+        // It's a number, that's cool - but we need it as a string so it doesn't screw
+        // with the user when entering dollar amounts or other values (such as those with
+        // specific precision or number of significant digits)
+        return value;
+    }
+    const n = Number(value);
+    const valid = typeof n === 'number' && !Number.isNaN(n);
+    return valid ? n : value;
+}
+//# sourceMappingURL=asNumber.js.map

package/lib/asNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asNumber.js","sourceRoot":"","sources":["../src/asNumber.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAoB;IACnD,IAAI,KAAK,KAAK,EAAE,EAAE;QAChB,OAAO,SAAS,CAAC;KAClB;IACD,IAAI,KAAK,KAAK,IAAI,EAAE;QAClB,OAAO,IAAI,CAAC;KACb;IACD,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;QACrB,wEAAwE;QACxE,wCAAwC;QACxC,OAAO,KAAK,CAAC;KACd;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;QACtB,wEAAwE;QACxE,OAAO,KAAK,CAAC;KACd;IAED,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;QACzB,8EAA8E;QAC9E,iFAAiF;QACjF,sDAAsD;QACtD,OAAO,KAAK,CAAC;KACd;IAED,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IACxB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAExD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AAC3B,CAAC"}

package/lib/canExpand.d.ts

@@ -0,0 +1,11 @@
+import { 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
+ * `formData` object doesn't already have `schema.maxProperties` elements.
+ *
+ * @param schema - The schema for the field that is being checked
+ * @param [uiSchema={}] - The uiSchema for the field
+ * @param [formData] - The formData for the field
+ * @returns - True if the schema element has additionalProperties, is expandable, and not at the maxProperties limit
+ */
+export default function canExpand<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(schema: RJSFSchema, uiSchema?: UiSchema<T, S, F>, formData?: T): boolean;

package/lib/canExpand.js

@@ -0,0 +1,26 @@
+import getUiOptions from './getUiOptions';
+/** 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
+ * `formData` object doesn't already have `schema.maxProperties` elements.
+ *
+ * @param schema - The schema for the field that is being checked
+ * @param [uiSchema={}] - The uiSchema for the field
+ * @param [formData] - The formData for the field
+ * @returns - True if the schema element has additionalProperties, is expandable, and not at the maxProperties limit
+ */
+export default function canExpand(schema, uiSchema = {}, formData) {
+    if (!schema.additionalProperties) {
+        return false;
+    }
+    const { expandable = true } = getUiOptions(uiSchema);
+    if (expandable === false) {
+        return expandable;
+    }
+    // if ui:options.expandable was not explicitly set to false, we can add
+    // another property if we have not exceeded maxProperties yet
+    if (schema.maxProperties !== undefined && formData) {
+        return Object.keys(formData).length < schema.maxProperties;
+    }
+    return true;
+}
+//# sourceMappingURL=canExpand.js.map

package/lib/canExpand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canExpand.js","sourceRoot":"","sources":["../src/canExpand.ts"],"names":[],"mappings":"AACA,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,MAAkB,EAClB,WAA8B,EAAE,EAChC,QAAY;IAEZ,IAAI,CAAC,MAAM,CAAC,oBAAoB,EAAE;QAChC,OAAO,KAAK,CAAC;KACd;IACD,MAAM,EAAE,UAAU,GAAG,IAAI,EAAE,GAAG,YAAY,CAAU,QAAQ,CAAC,CAAC;IAC9D,IAAI,UAAU,KAAK,KAAK,EAAE;QACxB,OAAO,UAAU,CAAC;KACnB;IACD,uEAAuE;IACvE,6DAA6D;IAC7D,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,IAAI,QAAQ,EAAE;QAClD,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC;KAC5D;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/lib/constants.d.ts

@@ -0,0 +1,31 @@
+/** 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_ADDITONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
+ * utility.
+ */
+export declare const ADDITIONAL_PROPERTY_FLAG = "__additional_property";
+export declare const ADDITIONAL_PROPERTIES_KEY = "additionalProperties";
+export declare const ALL_OF_KEY = "allOf";
+export declare const ANY_OF_KEY = "anyOf";
+export declare const CONST_KEY = "const";
+export declare const DEFAULT_KEY = "default";
+export declare const DEFINITIONS_KEY = "definitions";
+export declare const DEPENDENCIES_KEY = "dependencies";
+export declare const ENUM_KEY = "enum";
+export declare const ERRORS_KEY = "__errors";
+export declare const ID_KEY = "$id";
+export declare const IF_KEY = "if";
+export declare const ITEMS_KEY = "items";
+export declare const JUNK_OPTION_ID = "_$junk_option_schema_id$_";
+export declare const NAME_KEY = "$name";
+export declare const ONE_OF_KEY = "oneOf";
+export declare const PROPERTIES_KEY = "properties";
+export declare const REQUIRED_KEY = "required";
+export declare const SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
+export declare const REF_KEY = "$ref";
+export declare const RJSF_ADDITONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
+export declare const ROOT_SCHEMA_PREFIX = "__rjsf_rootSchema";
+export declare const UI_FIELD_KEY = "ui:field";
+export declare const UI_WIDGET_KEY = "ui:widget";
+export declare const UI_OPTIONS_KEY = "ui:options";
+export declare const UI_GLOBAL_OPTIONS_KEY = "ui:globalOptions";

package/lib/constants.js

@@ -0,0 +1,32 @@
+/** 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_ADDITONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
+ * utility.
+ */
+export const ADDITIONAL_PROPERTY_FLAG = '__additional_property';
+export const ADDITIONAL_PROPERTIES_KEY = 'additionalProperties';
+export const ALL_OF_KEY = 'allOf';
+export const ANY_OF_KEY = 'anyOf';
+export const CONST_KEY = 'const';
+export const DEFAULT_KEY = 'default';
+export const DEFINITIONS_KEY = 'definitions';
+export const DEPENDENCIES_KEY = 'dependencies';
+export const ENUM_KEY = 'enum';
+export const ERRORS_KEY = '__errors';
+export const ID_KEY = '$id';
+export const IF_KEY = 'if';
+export const ITEMS_KEY = 'items';
+export const JUNK_OPTION_ID = '_$junk_option_schema_id$_';
+export const NAME_KEY = '$name';
+export const ONE_OF_KEY = 'oneOf';
+export const PROPERTIES_KEY = 'properties';
+export const REQUIRED_KEY = 'required';
+export const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
+export const REF_KEY = '$ref';
+export const RJSF_ADDITONAL_PROPERTIES_FLAG = '__rjsf_additionalProperties';
+export const ROOT_SCHEMA_PREFIX = '__rjsf_rootSchema';
+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';
+//# sourceMappingURL=constants.js.map

package/lib/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,uBAAuB,CAAC;AAChE,MAAM,CAAC,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAChE,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC;AAClC,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC;AAClC,MAAM,CAAC,MAAM,SAAS,GAAG,OAAO,CAAC;AACjC,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC;AACrC,MAAM,CAAC,MAAM,eAAe,GAAG,aAAa,CAAC;AAC7C,MAAM,CAAC,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAC/C,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC/B,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;AACrC,MAAM,CAAC,MAAM,MAAM,GAAG,KAAK,CAAC;AAC5B,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,CAAC;AAC3B,MAAM,CAAC,MAAM,SAAS,GAAG,OAAO,CAAC;AACjC,MAAM,CAAC,MAAM,cAAc,GAAG,2BAA2B,CAAC;AAC1D,MAAM,CAAC,MAAM,QAAQ,GAAG,OAAO,CAAC;AAChC,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC;AAClC,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;AAC3C,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;AACvC,MAAM,CAAC,MAAM,sBAAsB,GAAG,qBAAqB,CAAC;AAC5D,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC;AAC9B,MAAM,CAAC,MAAM,8BAA8B,GAAG,6BAA6B,CAAC;AAC5E,MAAM,CAAC,MAAM,kBAAkB,GAAG,mBAAmB,CAAC;AACtD,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;AACvC,MAAM,CAAC,MAAM,aAAa,GAAG,WAAW,CAAC;AACzC,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;AAC3C,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC"}

package/lib/createErrorHandler.d.ts

@@ -0,0 +1,7 @@
+import { FormValidation } from './types';
+/** Given a `formData` object, recursively creates a `FormValidation` error handling structure around it
+ *
+ * @param formData - The form data around which the error handler is created
+ * @returns - A `FormValidation` object based on the `formData` structure
+ */
+export default function createErrorHandler<T = any>(formData: T): FormValidation<T>;

package/lib/createErrorHandler.js

@@ -0,0 +1,31 @@
+import isPlainObject from 'lodash/isPlainObject';
+import { ERRORS_KEY } from './constants';
+/** Given a `formData` object, recursively creates a `FormValidation` error handling structure around it
+ *
+ * @param formData - The form data around which the error handler is created
+ * @returns - A `FormValidation` object based on the `formData` structure
+ */
+export default function createErrorHandler(formData) {
+    const handler = {
+        // We store the list of errors for this node in a property named __errors
+        // to avoid name collision with a possible sub schema field named
+        // 'errors' (see `utils.toErrorSchema`).
+        [ERRORS_KEY]: [],
+        addError(message) {
+            this[ERRORS_KEY].push(message);
+        },
+    };
+    if (Array.isArray(formData)) {
+        return formData.reduce((acc, value, key) => {
+            return Object.assign(Object.assign({}, acc), { [key]: createErrorHandler(value) });
+        }, handler);
+    }
+    if (isPlainObject(formData)) {
+        const formObject = formData;
+        return Object.keys(formObject).reduce((acc, key) => {
+            return Object.assign(Object.assign({}, acc), { [key]: createErrorHandler(formObject[key]) });
+        }, handler);
+    }
+    return handler;
+}
+//# sourceMappingURL=createErrorHandler.js.map

package/lib/createErrorHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createErrorHandler.js","sourceRoot":"","sources":["../src/createErrorHandler.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAU,QAAW;IAC7D,MAAM,OAAO,GAAoB;QAC/B,yEAAyE;QACzE,iEAAiE;QACjE,wCAAwC;QACxC,CAAC,UAAU,CAAC,EAAE,EAAE;QAChB,QAAQ,CAAC,OAAe;YACtB,IAAI,CAAC,UAAU,CAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC;KACF,CAAC;IACF,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QAC3B,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;YACzC,uCAAY,GAAG,KAAE,CAAC,GAAG,CAAC,EAAE,kBAAkB,CAAC,KAAK,CAAC,IAAG;QACtD,CAAC,EAAE,OAAO,CAAC,CAAC;KACb;IACD,IAAI,aAAa,CAAC,QAAQ,CAAC,EAAE;QAC3B,MAAM,UAAU,GAAsB,QAA6B,CAAC;QACpE,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YACjD,uCAAY,GAAG,KAAE,CAAC,GAAG,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,IAAG;QAChE,CAAC,EAAE,OAA4B,CAAC,CAAC;KAClC;IACD,OAAO,OAA4B,CAAC;AACtC,CAAC"}

package/lib/createSchemaUtils.d.ts

@@ -0,0 +1,10 @@
+import { FormContextType, RJSFSchema, SchemaUtilsType, StrictRJSFSchema, ValidatorType } from './types';
+/** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The
+ * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
+ * @returns - An implementation of a `SchemaUtilsType` interface
+ */
+export default function createSchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rootSchema: S, experimental_defaultFormStateBehavior?: {}): SchemaUtilsType<T, S, F>;

package/lib/createSchemaUtils.js

@@ -0,0 +1,207 @@
+import deepEquals from './deepEquals';
+import { getDefaultFormState, getDisplayLabel, getClosestMatchingOption, getFirstMatchingOption, getMatchingOption, isFilesArray, isMultiSelect, isSelect, mergeValidationData, retrieveSchema, sanitizeDataForNewSchema, toIdSchema, toPathSchema, } from './schema';
+/** The `SchemaUtils` class provides a wrapper around the publicly exported APIs in the `utils/schema` directory such
+ * that one does not have to explicitly pass the `validator`, `rootSchema`, or `experimental_defaultFormStateBehavior` to each method.
+ * Since these generally do not change across a `Form`, this allows for providing a simplified set of APIs to the
+ * `@rjsf/core` components and the various themes as well. This class implements the `SchemaUtilsType` interface.
+ */
+class SchemaUtils {
+    /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
+     *
+     * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+     * @param rootSchema - The root schema that will be forwarded to all the APIs
+     * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior
+     */
+    constructor(validator, rootSchema, experimental_defaultFormStateBehavior) {
+        this.rootSchema = rootSchema;
+        this.validator = validator;
+        this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
+    }
+    /** Returns the `ValidatorType` in the `SchemaUtilsType`
+     *
+     * @returns - The `ValidatorType`
+     */
+    getValidator() {
+        return this.validator;
+    }
+    /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of
+     * the `SchemaUtilsType`. If either `validator` or `rootSchema` are falsy, then return false to prevent the creation
+     * of a new `SchemaUtilsType` with incomplete properties.
+     *
+     * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
+     * @param rootSchema - The root schema that will be compared against the current one
+     * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
+     * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
+     */
+    doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
+        if (!validator || !rootSchema) {
+            return false;
+        }
+        return (this.validator !== validator ||
+            !deepEquals(this.rootSchema, rootSchema) ||
+            !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior));
+    }
+    /** 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 schema - The schema for which the default state is desired
+     * @param [formData] - 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.
+     *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+     *          object properties.
+     * @returns - The resulting `formData` with all the defaults provided
+     */
+    getDefaultFormState(schema, formData, includeUndefinedValues = false) {
+        return getDefaultFormState(this.validator, schema, formData, this.rootSchema, includeUndefinedValues, this.experimental_defaultFormStateBehavior);
+    }
+    /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
+     * should be displayed in a UI.
+     *
+     * @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 [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
+     * @returns - True if the label should be displayed or false if it should not
+     */
+    getDisplayLabel(schema, uiSchema, globalOptions) {
+        return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema, globalOptions);
+    }
+    /** Determines which of the given `options` provided most closely matches the `formData`.
+     * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
+     *
+     * The closest match is determined using the number of matching properties, and more heavily favors options with
+     * matching readOnly, default, or const values.
+     *
+     * @param formData - The form data associated with the schema
+     * @param options - The list of options that can be selected from
+     * @param [selectedOption] - The index of the currently selected option, defaulted to -1 if not specified
+     * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
+     *          determine which option is selected
+     * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
+     */
+    getClosestMatchingOption(formData, options, selectedOption, discriminatorField) {
+        return getClosestMatchingOption(this.validator, this.rootSchema, formData, options, selectedOption, discriminatorField);
+    }
+    /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
+     * Always returns the first option if there is nothing that matches.
+     *
+     * @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 [discriminatorField] - The optional name of the field within the options object whose value is used to
+     *          determine which option is selected
+     * @returns - The firstindex of the matched option or 0 if none is available
+     */
+    getFirstMatchingOption(formData, options, discriminatorField) {
+        return getFirstMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
+    }
+    /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+     * Deprecated, use `getFirstMatchingOption()` instead.
+     *
+     * @param formData - The current formData, if any, onto which to provide any missing defaults
+     * @param options - The list of options to find a matching options from
+     * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
+     *          determine which option is selected
+     * @returns - The index of the matched option or 0 if none is available
+     * @deprecated
+     */
+    getMatchingOption(formData, options, discriminatorField) {
+        return getMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
+    }
+    /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+     *
+     * @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
+     * @returns - True if schema/uiSchema contains an array of files, otherwise false
+     */
+    isFilesArray(schema, uiSchema) {
+        return isFilesArray(this.validator, schema, uiSchema, this.rootSchema);
+    }
+    /** Checks to see if the `schema` combination represents a multi-select
+     *
+     * @param schema - The schema for which check for a multi-select flag is desired
+     * @returns - True if schema contains a multi-select, otherwise false
+     */
+    isMultiSelect(schema) {
+        return isMultiSelect(this.validator, schema, this.rootSchema);
+    }
+    /** Checks to see if the `schema` combination represents a select
+     *
+     * @param schema - The schema for which check for a select flag is desired
+     * @returns - True if schema contains a select, otherwise false
+     */
+    isSelect(schema) {
+        return isSelect(this.validator, schema, this.rootSchema);
+    }
+    /** 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
+     * `getValidator().toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed,
+     * then `validationData` is returned.
+     *
+     * @param validationData - The current `ValidationData` into which to merge the additional errors
+     * @param [additionalErrorSchema] - The additional set of errors
+     * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+     * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
+     *        removed in the next major release.
+     */
+    mergeValidationData(validationData, additionalErrorSchema) {
+        return mergeValidationData(this.validator, validationData, additionalErrorSchema);
+    }
+    /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
+     * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
+     * recursive resolution.
+     *
+     * @param schema - The schema for which retrieving a schema is desired
+     * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+     * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+     */
+    retrieveSchema(schema, rawFormData) {
+        return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData);
+    }
+    /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
+     * new schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the
+     * nature of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the
+     * old schemas that are non-existent in the new schema are set to `undefined`.
+     *
+     * @param [newSchema] - The new schema for which the data is being sanitized
+     * @param [oldSchema] - The old schema from which the data originated
+     * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
+     * @returns - The new form data, with all the fields uniquely associated with the old schema set
+     *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
+     */
+    sanitizeDataForNewSchema(newSchema, oldSchema, data) {
+        return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
+    }
+    /** Generates an `IdSchema` object for the `schema`, recursively
+     *
+     * @param schema - The schema for which the display label flag is desired
+     * @param [id] - The base id for the schema
+     * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+     * @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`
+     */
+    toIdSchema(schema, id, formData, idPrefix = 'root', idSeparator = '_') {
+        return toIdSchema(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator);
+    }
+    /** Generates an `PathSchema` object for the `schema`, recursively
+     *
+     * @param schema - The schema for which the display label flag is desired
+     * @param [name] - The base name for the schema
+     * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+     * @returns - The `PathSchema` object for the `schema`
+     */
+    toPathSchema(schema, name, formData) {
+        return toPathSchema(this.validator, schema, name, this.rootSchema, formData);
+    }
+}
+/** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The
+ * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
+ * @returns - An implementation of a `SchemaUtilsType` interface
+ */
+export default function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
+    return new SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior);
+}
+//# sourceMappingURL=createSchemaUtils.js.map