@rjsf/utils 5.11.2 → 5.12.0

package/src/unwrapErrorHandler.ts

@@ -0,0 +1,25 @@
+import isPlainObject from 'lodash/isPlainObject';
+
+import { ErrorSchema, FormValidation, GenericObjectType } 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> {
+  return Object.keys(errorHandler).reduce((acc, key) => {
+    if (key === 'addError') {
+      return acc;
+    } else {
+      const childSchema = (errorHandler as GenericObjectType)[key];
+      if (isPlainObject(childSchema)) {
+        return {
+          ...acc,
+          [key]: unwrapErrorHandler(childSchema),
+        };
+      }
+      return { ...acc, [key]: childSchema };
+    }
+  }, {} as ErrorSchema<T>);
+}

package/src/utcToLocal.ts

@@ -0,0 +1,30 @@
+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: string) {
+  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}`;
+}

package/src/validationDataMerge.ts

@@ -0,0 +1,31 @@
+import isEmpty from 'lodash/isEmpty';
+
+import mergeObjects from './mergeObjects';
+import toErrorList from './toErrorList';
+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> {
+  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) as ErrorSchema<T>;
+    errors = [...oldErrors].concat(errors);
+  }
+  return { errorSchema, errors };
+}

package/src/withIdRefPrefix.ts

@@ -0,0 +1,49 @@
+import { REF_KEY, ROOT_SCHEMA_PREFIX } from './constants';
+import { RJSFSchema, StrictRJSFSchema } from './types';
+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<S extends StrictRJSFSchema = RJSFSchema>(node: S): S {
+  for (const key in node) {
+    const realObj: { [k: string]: any } = node;
+    const value = realObj[key];
+    if (key === REF_KEY && typeof value === 'string' && value.startsWith('#')) {
+      realObj[key] = ROOT_SCHEMA_PREFIX + value;
+    } else {
+      realObj[key] = withIdRefPrefix<S>(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<S extends StrictRJSFSchema = RJSFSchema>(node: S[]): S[] {
+  for (let i = 0; i < node.length; i++) {
+    node[i] = withIdRefPrefix<S>(node[i]) as S;
+  }
+  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<S extends StrictRJSFSchema = RJSFSchema>(schemaNode: S): S | S[] {
+  if (Array.isArray(schemaNode)) {
+    return withIdRefPrefixArray<S>([...schemaNode]);
+  }
+  if (isObject(schemaNode)) {
+    return withIdRefPrefixObject<S>({ ...schemaNode });
+  }
+  return schemaNode;
+}