@rjsf/utils 5.11.2 → 5.12.0

package/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/lib/unwrapErrorHandler.d.ts

@@ -0,0 +1,7 @@
+import { ErrorSchema, FormValidation } from './types';
+/** Unwraps the `errorHandler` structure into the associated `ErrorSchema`, stripping the `addError()` functions from it
+ *
+ * @param errorHandler - The `FormValidation` error handling structure
+ * @returns - The `ErrorSchema` resulting from the stripping of the `addError()` function
+ */
+export default function unwrapErrorHandler<T = any>(errorHandler: FormValidation<T>): ErrorSchema<T>;

package/lib/unwrapErrorHandler.js

@@ -0,0 +1,21 @@
+import isPlainObject from 'lodash/isPlainObject';
+/** Unwraps the `errorHandler` structure into the associated `ErrorSchema`, stripping the `addError()` functions from it
+ *
+ * @param errorHandler - The `FormValidation` error handling structure
+ * @returns - The `ErrorSchema` resulting from the stripping of the `addError()` function
+ */
+export default function unwrapErrorHandler(errorHandler) {
+    return Object.keys(errorHandler).reduce((acc, key) => {
+        if (key === 'addError') {
+            return acc;
+        }
+        else {
+            const childSchema = errorHandler[key];
+            if (isPlainObject(childSchema)) {
+                return Object.assign(Object.assign({}, acc), { [key]: unwrapErrorHandler(childSchema) });
+            }
+            return Object.assign(Object.assign({}, acc), { [key]: childSchema });
+        }
+    }, {});
+}
+//# sourceMappingURL=unwrapErrorHandler.js.map

package/lib/unwrapErrorHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapErrorHandler.js","sourceRoot":"","sources":["../src/unwrapErrorHandler.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,sBAAsB,CAAC;AAIjD;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAU,YAA+B;IACjF,OAAO,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;QACnD,IAAI,GAAG,KAAK,UAAU,EAAE;YACtB,OAAO,GAAG,CAAC;SACZ;aAAM;YACL,MAAM,WAAW,GAAI,YAAkC,CAAC,GAAG,CAAC,CAAC;YAC7D,IAAI,aAAa,CAAC,WAAW,CAAC,EAAE;gBAC9B,uCACK,GAAG,KACN,CAAC,GAAG,CAAC,EAAE,kBAAkB,CAAC,WAAW,CAAC,IACtC;aACH;YACD,uCAAY,GAAG,KAAE,CAAC,GAAG,CAAC,EAAE,WAAW,IAAG;SACvC;IACH,CAAC,EAAE,EAAoB,CAAC,CAAC;AAC3B,CAAC"}

package/lib/utcToLocal.d.ts

@@ -0,0 +1,6 @@
+/** Converts a UTC date string into a local Date format
+ *
+ * @param jsonDate - A UTC date string
+ * @returns - An empty string when `jsonDate` is falsey, otherwise a date string in local format
+ */
+export default function utcToLocal(jsonDate: string): string;

package/lib/utcToLocal.js

@@ -0,0 +1,26 @@
+import pad from './pad';
+/** Converts a UTC date string into a local Date format
+ *
+ * @param jsonDate - A UTC date string
+ * @returns - An empty string when `jsonDate` is falsey, otherwise a date string in local format
+ */
+export default function utcToLocal(jsonDate) {
+    if (!jsonDate) {
+        return '';
+    }
+    // required format of `'yyyy-MM-ddThh:mm' followed by optional ':ss' or ':ss.SSS'
+    // https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type%3Ddatetime-local)
+    // > should be a _valid local date and time string_ (not GMT)
+    // Note - date constructor passed local ISO-8601 does not correctly
+    // change time to UTC in node pre-8
+    const date = new Date(jsonDate);
+    const yyyy = pad(date.getFullYear(), 4);
+    const MM = pad(date.getMonth() + 1, 2);
+    const dd = pad(date.getDate(), 2);
+    const hh = pad(date.getHours(), 2);
+    const mm = pad(date.getMinutes(), 2);
+    const ss = pad(date.getSeconds(), 2);
+    const SSS = pad(date.getMilliseconds(), 3);
+    return `${yyyy}-${MM}-${dd}T${hh}:${mm}:${ss}.${SSS}`;
+}
+//# sourceMappingURL=utcToLocal.js.map

package/lib/utcToLocal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utcToLocal.js","sourceRoot":"","sources":["../src/utcToLocal.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,OAAO,CAAC;AAExB;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,QAAgB;IACjD,IAAI,CAAC,QAAQ,EAAE;QACb,OAAO,EAAE,CAAC;KACX;IAED,iFAAiF;IACjF,sGAAsG;IACtG,6DAA6D;IAE7D,mEAAmE;IACnE,mCAAmC;IACnC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;IAEhC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC;IACxC,MAAM,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACvC,MAAM,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IAClC,MAAM,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC;IACnC,MAAM,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,CAAC;IACrC,MAAM,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,CAAC;IACrC,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC;IAE3C,OAAO,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,EAAE,CAAC;AACxD,CAAC"}

package/lib/validationDataMerge.d.ts

@@ -0,0 +1,11 @@
+import { ErrorSchema, ValidationData } 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
+ * `toErrorList()` on 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 optional additional set of errors in an `ErrorSchema`
+ * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+ */
+export default function validationDataMerge<T = any>(validationData: ValidationData<T>, additionalErrorSchema?: ErrorSchema<T>): ValidationData<T>;

package/lib/validationDataMerge.js

@@ -0,0 +1,26 @@
+import isEmpty from 'lodash/isEmpty';
+import mergeObjects from './mergeObjects';
+import toErrorList from './toErrorList';
+/** 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
+ * `toErrorList()` on 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 optional additional set of errors in an `ErrorSchema`
+ * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+ */
+export default function validationDataMerge(validationData, additionalErrorSchema) {
+    if (!additionalErrorSchema) {
+        return validationData;
+    }
+    const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
+    let errors = toErrorList(additionalErrorSchema);
+    let errorSchema = additionalErrorSchema;
+    if (!isEmpty(oldErrorSchema)) {
+        errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
+        errors = [...oldErrors].concat(errors);
+    }
+    return { errorSchema, errors };
+}
+//# sourceMappingURL=validationDataMerge.js.map

package/lib/validationDataMerge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationDataMerge.js","sourceRoot":"","sources":["../src/validationDataMerge.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,gBAAgB,CAAC;AAErC,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,WAAW,MAAM,eAAe,CAAC;AAGxC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,cAAiC,EACjC,qBAAsC;IAEtC,IAAI,CAAC,qBAAqB,EAAE;QAC1B,OAAO,cAAc,CAAC;KACvB;IACD,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,GAAG,cAAc,CAAC;IAC1E,IAAI,MAAM,GAAG,WAAW,CAAC,qBAAqB,CAAC,CAAC;IAChD,IAAI,WAAW,GAAG,qBAAqB,CAAC;IACxC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE;QAC5B,WAAW,GAAG,YAAY,CAAC,cAAc,EAAE,qBAAqB,EAAE,IAAI,CAAmB,CAAC;QAC1F,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;KACxC;IACD,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;AACjC,CAAC"}

package/lib/withIdRefPrefix.d.ts

@@ -0,0 +1,8 @@
+import { RJSFSchema, StrictRJSFSchema } from './types';
+/** Recursively prefixes all `$ref`s in a schema with the value of the `ROOT_SCHEMA_PREFIX` constant.
+ * This is used in isValid to make references to the rootSchema
+ *
+ * @param schemaNode - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
+ * @returns - A copy of the `schemaNode` with updated `$ref`s
+ */
+export default function withIdRefPrefix<S extends StrictRJSFSchema = RJSFSchema>(schemaNode: S): S | S[];

package/lib/withIdRefPrefix.js

@@ -0,0 +1,47 @@
+import { REF_KEY, ROOT_SCHEMA_PREFIX } from './constants';
+import isObject from 'lodash/isObject';
+/** Takes a `node` object and transforms any contained `$ref` node variables with a prefix, recursively calling
+ * `withIdRefPrefix` for any other elements.
+ *
+ * @param node - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
+ */
+function withIdRefPrefixObject(node) {
+    for (const key in node) {
+        const realObj = node;
+        const value = realObj[key];
+        if (key === REF_KEY && typeof value === 'string' && value.startsWith('#')) {
+            realObj[key] = ROOT_SCHEMA_PREFIX + value;
+        }
+        else {
+            realObj[key] = withIdRefPrefix(value);
+        }
+    }
+    return node;
+}
+/** Takes a `node` object list and transforms any contained `$ref` node variables with a prefix, recursively calling
+ * `withIdRefPrefix` for any other elements.
+ *
+ * @param node - The list of object nodes to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
+ */
+function withIdRefPrefixArray(node) {
+    for (let i = 0; i < node.length; i++) {
+        node[i] = withIdRefPrefix(node[i]);
+    }
+    return node;
+}
+/** Recursively prefixes all `$ref`s in a schema with the value of the `ROOT_SCHEMA_PREFIX` constant.
+ * This is used in isValid to make references to the rootSchema
+ *
+ * @param schemaNode - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
+ * @returns - A copy of the `schemaNode` with updated `$ref`s
+ */
+export default function withIdRefPrefix(schemaNode) {
+    if (Array.isArray(schemaNode)) {
+        return withIdRefPrefixArray([...schemaNode]);
+    }
+    if (isObject(schemaNode)) {
+        return withIdRefPrefixObject(Object.assign({}, schemaNode));
+    }
+    return schemaNode;
+}
+//# sourceMappingURL=withIdRefPrefix.js.map

package/lib/withIdRefPrefix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withIdRefPrefix.js","sourceRoot":"","sources":["../src/withIdRefPrefix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,QAAQ,MAAM,iBAAiB,CAAC;AAEvC;;;;GAIG;AACH,SAAS,qBAAqB,CAA0C,IAAO;IAC7E,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;QACtB,MAAM,OAAO,GAAyB,IAAI,CAAC;QAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,GAAG,KAAK,OAAO,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;YACzE,OAAO,CAAC,GAAG,CAAC,GAAG,kBAAkB,GAAG,KAAK,CAAC;SAC3C;aAAM;YACL,OAAO,CAAC,GAAG,CAAC,GAAG,eAAe,CAAI,KAAK,CAAC,CAAC;SAC1C;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAA0C,IAAS;IAC9E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACpC,IAAI,CAAC,CAAC,CAAC,GAAG,eAAe,CAAI,IAAI,CAAC,CAAC,CAAC,CAAM,CAAC;KAC5C;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAA0C,UAAa;IAC5F,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC7B,OAAO,oBAAoB,CAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;KACjD;IACD,IAAI,QAAQ,CAAC,UAAU,CAAC,EAAE;QACxB,OAAO,qBAAqB,mBAAS,UAAU,EAAG,CAAC;KACpD;IACD,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@rjsf/utils",
-  "version": "5.11.2",
+  "version": "5.12.0",
   "main": "dist/index.js",
-  "module": "dist/utils.esm.js",
-  "typings": "dist/index.d.ts",
+  "module": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "description": "Utility functions for @rjsf/core",
   "files": [
-    "dist"
+    "dist",
+    "lib",
+    "src"
   ],
   "engineStrict": false,
   "engines": {
     "node": ">=14"
   },
   "scripts": {
-    "build": "rimraf dist && dts build --rollupTypes --format cjs,esm,umd",
+    "build:ts": "rimraf lib && tsc",
+    "build:cjs": "esbuild ./src/index.ts --bundle --outfile=dist/index.js --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": "rimraf dist && npm run build:ts && npm run build:cjs && npm run build:esm && npm run build:umd",
     "cs-check": "prettier -l \"{src,test}/**/*.ts?(x)\"",
     "cs-format": "prettier \"{src,test}/**/*.ts?(x)\" --write",
     "lint": "eslint src test",
@@ -46,20 +52,21 @@
     "@babel/preset-typescript": "^7.22.5",
     "@types/json-schema": "^7.0.12",
     "@types/json-schema-merge-allof": "^0.6.1",
-    "@types/lodash": "^4.14.195",
+    "@types/lodash": "^4.14.196",
     "@types/react": "^17.0.62",
     "@types/react-is": "^17.0.4",
     "@types/react-test-renderer": "^17.0.2",
-    "babel-jest": "^29.6.1",
+    "babel-jest": "^29.6.2",
     "deep-freeze-es6": "^1.4.1",
-    "dts-cli": "^1.6.3",
-    "eslint": "^8.44.0",
-    "jest": "^29.6.1",
+    "esbuild": "^0.18.19",
+    "eslint": "^8.46.0",
+    "jest": "^29.6.2",
     "jest-environment-jsdom": "^29.6.1",
-    "jest-expect-message": "^1.1.3",
     "react": "^17.0.2",
     "react-test-renderer": "^17.0.2",
-    "rimraf": "^5.0.1"
+    "rimraf": "^5.0.1",
+    "rollup": "^3.27.2",
+    "typescript": "^4.9.5"
   },
   "publishConfig": {
     "access": "public"
@@ -79,5 +86,5 @@
     "url": "git+https://github.com/rjsf-team/react-jsonschema-form.git"
   },
   "license": "Apache-2.0",
-  "gitHead": "2fafced84e18aa2cd487715d11d2730cd23333f3"
+  "gitHead": "bab797c43a34e5ec68a84b2bdabb3c377e46b092"
 }

package/src/ErrorSchemaBuilder.ts

@@ -0,0 +1,112 @@
+import cloneDeep from 'lodash/cloneDeep';
+import get from 'lodash/get';
+import set from 'lodash/set';
+
+import { ErrorSchema } from './types';
+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<T = any> {
+  /** The error schema being built
+   *
+   * @private
+   */
+  private errorSchema: ErrorSchema<T> = {};
+
+  /** 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>) {
+    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
+   */
+  private getOrCreateErrorBlock(pathOfError?: string | string[]) {
+    const hasPath = (Array.isArray(pathOfError) && pathOfError.length > 0) || typeof pathOfError === 'string';
+    let errorBlock: ErrorSchema = 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?: ErrorSchema<T>) {
+    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: string | string[], pathOfError?: string | string[]) {
+    const errorBlock: ErrorSchema = 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: string | string[], pathOfError?: string | string[]) {
+    const errorBlock: ErrorSchema = 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?: string | string[]) {
+    const errorBlock: ErrorSchema = this.getOrCreateErrorBlock(pathOfError);
+    set(errorBlock, ERRORS_KEY, []);
+    return this;
+  }
+}

package/src/allowAdditionalItems.ts

@@ -0,0 +1,15 @@
+import isObject from './isObject';
+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) {
+  if (schema.additionalItems === true) {
+    console.warn('additionalItems=true is currently not supported');
+  }
+  return isObject(schema.additionalItems);
+}

package/src/asNumber.ts

@@ -0,0 +1,38 @@
+/** 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) {
+  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;
+}

package/src/canExpand.ts

@@ -0,0 +1,31 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+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<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  schema: RJSFSchema,
+  uiSchema: UiSchema<T, S, F> = {},
+  formData?: T
+) {
+  if (!schema.additionalProperties) {
+    return false;
+  }
+  const { expandable = true } = getUiOptions<T, S, F>(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;
+}

package/src/constants.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 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';

package/src/createErrorHandler.ts

@@ -0,0 +1,33 @@
+import isPlainObject from 'lodash/isPlainObject';
+
+import { ERRORS_KEY } from './constants';
+import { FieldValidation, FormValidation, GenericObjectType } 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> {
+  const handler: FieldValidation = {
+    // 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: string) {
+      this[ERRORS_KEY]!.push(message);
+    },
+  };
+  if (Array.isArray(formData)) {
+    return formData.reduce((acc, value, key) => {
+      return { ...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 handler as FormValidation<T>;
+}