@rjsf/core 4.2.2 → 4.2.3

package/dist/cjs/validate.js

@@ -0,0 +1,354 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toErrorList = toErrorList;
+exports["default"] = validateFormData;
+exports.withIdRefPrefix = withIdRefPrefix;
+exports.isValid = isValid;
+
+var _toPath = _interopRequireDefault(require("lodash/toPath"));
+
+var _ajv = _interopRequireDefault(require("ajv"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var ajv = createAjvInstance();
+var formerCustomFormats = null;
+var formerMetaSchema = null;
+var ROOT_SCHEMA_PREFIX = "__rjsf_rootSchema";
+
+function createAjvInstance() {
+  var ajv = new _ajv["default"]({
+    errorDataPath: "property",
+    allErrors: true,
+    multipleOfPrecision: 8,
+    schemaId: "auto",
+    unknownFormats: "ignore"
+  }); // add custom formats
+
+  ajv.addFormat("data-url", /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/);
+  ajv.addFormat("color", /^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/);
+  return ajv;
+}
+
+function toErrorSchema(errors) {
+  // Transforms a ajv validation errors list:
+  // [
+  //   {property: ".level1.level2[2].level3", message: "err a"},
+  //   {property: ".level1.level2[2].level3", message: "err b"},
+  //   {property: ".level1.level2[4].level3", message: "err b"},
+  // ]
+  // Into an error tree:
+  // {
+  //   level1: {
+  //     level2: {
+  //       2: {level3: {errors: ["err a", "err b"]}},
+  //       4: {level3: {errors: ["err b"]}},
+  //     }
+  //   }
+  // };
+  if (!errors.length) {
+    return {};
+  }
+
+  return errors.reduce(function (errorSchema, error) {
+    var property = error.property,
+        message = error.message;
+    var path = (0, _toPath["default"])(property);
+    var parent = errorSchema; // If the property is at the root (.level1) then toPath creates
+    // an empty array element at the first index. Remove it.
+
+    if (path.length > 0 && path[0] === "") {
+      path.splice(0, 1);
+    }
+
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = path.slice(0)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var segment = _step.value;
+
+        if (!(segment in parent)) {
+          parent[segment] = {};
+        }
+
+        parent = parent[segment];
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
+          _iterator["return"]();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    if (Array.isArray(parent.__errors)) {
+      // 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 `validate.createErrorHandler`).
+      parent.__errors = parent.__errors.concat(message);
+    } else {
+      if (message) {
+        parent.__errors = [message];
+      }
+    }
+
+    return errorSchema;
+  }, {});
+}
+
+function toErrorList(errorSchema) {
+  var fieldName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "root";
+  // XXX: We should transform fieldName as a full field path string.
+  var errorList = [];
+
+  if ("__errors" in errorSchema) {
+    errorList = errorList.concat(errorSchema.__errors.map(function (stack) {
+      return {
+        stack: "".concat(fieldName, ": ").concat(stack)
+      };
+    }));
+  }
+
+  return Object.keys(errorSchema).reduce(function (acc, key) {
+    if (key !== "__errors") {
+      acc = acc.concat(toErrorList(errorSchema[key], key));
+    }
+
+    return acc;
+  }, errorList);
+}
+
+function createErrorHandler(formData) {
+  var 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: [],
+    addError: function addError(message) {
+      this.__errors.push(message);
+    }
+  };
+
+  if ((0, _utils.isObject)(formData)) {
+    return Object.keys(formData).reduce(function (acc, key) {
+      return _objectSpread({}, acc, _defineProperty({}, key, createErrorHandler(formData[key])));
+    }, handler);
+  }
+
+  if (Array.isArray(formData)) {
+    return formData.reduce(function (acc, value, key) {
+      return _objectSpread({}, acc, _defineProperty({}, key, createErrorHandler(value)));
+    }, handler);
+  }
+
+  return handler;
+}
+
+function unwrapErrorHandler(errorHandler) {
+  return Object.keys(errorHandler).reduce(function (acc, key) {
+    if (key === "addError") {
+      return acc;
+    } else if (key === "__errors") {
+      return _objectSpread({}, acc, _defineProperty({}, key, errorHandler[key]));
+    }
+
+    return _objectSpread({}, acc, _defineProperty({}, key, unwrapErrorHandler(errorHandler[key])));
+  }, {});
+}
+/**
+ * Transforming the error output from ajv to format used by jsonschema.
+ * At some point, components should be updated to support ajv.
+ */
+
+
+function transformAjvErrors() {
+  var errors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+  if (errors === null) {
+    return [];
+  }
+
+  return errors.map(function (e) {
+    var dataPath = e.dataPath,
+        keyword = e.keyword,
+        message = e.message,
+        params = e.params,
+        schemaPath = e.schemaPath;
+    var property = "".concat(dataPath); // put data in expected format
+
+    return {
+      name: keyword,
+      property: property,
+      message: message,
+      params: params,
+      // specific to ajv
+      stack: "".concat(property, " ").concat(message).trim(),
+      schemaPath: schemaPath
+    };
+  });
+}
+/**
+ * This function processes the formData with a user `validate` contributed
+ * function, which receives the form data and an `errorHandler` object that
+ * will be used to add custom validation errors for each field.
+ */
+
+
+function validateFormData(formData, schema, customValidate, transformErrors) {
+  var additionalMetaSchemas = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  var customFormats = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  // Include form data with undefined values, which is required for validation.
+  var rootSchema = schema;
+  formData = (0, _utils.getDefaultFormState)(schema, formData, rootSchema, true);
+  var newMetaSchemas = !(0, _utils.deepEquals)(formerMetaSchema, additionalMetaSchemas);
+  var newFormats = !(0, _utils.deepEquals)(formerCustomFormats, customFormats);
+
+  if (newMetaSchemas || newFormats) {
+    ajv = createAjvInstance();
+  } // add more schemas to validate against
+
+
+  if (additionalMetaSchemas && newMetaSchemas && Array.isArray(additionalMetaSchemas)) {
+    ajv.addMetaSchema(additionalMetaSchemas);
+    formerMetaSchema = additionalMetaSchemas;
+  } // add more custom formats to validate against
+
+
+  if (customFormats && newFormats && (0, _utils.isObject)(customFormats)) {
+    Object.keys(customFormats).forEach(function (formatName) {
+      ajv.addFormat(formatName, customFormats[formatName]);
+    });
+    formerCustomFormats = customFormats;
+  }
+
+  var validationError = null;
+
+  try {
+    ajv.validate(schema, formData);
+  } catch (err) {
+    validationError = err;
+  }
+
+  var errors = transformAjvErrors(ajv.errors); // Clear errors to prevent persistent errors, see #1104
+
+  ajv.errors = null;
+  var noProperMetaSchema = validationError && validationError.message && typeof validationError.message === "string" && validationError.message.includes("no schema with key or ref ");
+
+  if (noProperMetaSchema) {
+    errors = [].concat(_toConsumableArray(errors), [{
+      stack: validationError.message
+    }]);
+  }
+
+  if (typeof transformErrors === "function") {
+    errors = transformErrors(errors);
+  }
+
+  var errorSchema = toErrorSchema(errors);
+
+  if (noProperMetaSchema) {
+    errorSchema = _objectSpread({}, errorSchema, {
+      $schema: {
+        __errors: [validationError.message]
+      }
+    });
+  }
+
+  if (typeof customValidate !== "function") {
+    return {
+      errors: errors,
+      errorSchema: errorSchema
+    };
+  }
+
+  var errorHandler = customValidate(formData, createErrorHandler(formData));
+  var userErrorSchema = unwrapErrorHandler(errorHandler);
+  var newErrorSchema = (0, _utils.mergeObjects)(errorSchema, userErrorSchema, true); // XXX: The errors list produced is not fully compliant with the format
+  // exposed by the jsonschema lib, which contains full field paths and other
+  // properties.
+
+  var newErrors = toErrorList(newErrorSchema);
+  return {
+    errors: newErrors,
+    errorSchema: newErrorSchema
+  };
+}
+/**
+ * Recursively prefixes all $ref's in a schema with `ROOT_SCHEMA_PREFIX`
+ * This is used in isValid to make references to the rootSchema
+ */
+
+
+function withIdRefPrefix(schemaNode) {
+  var obj = schemaNode;
+
+  if (schemaNode.constructor === Object) {
+    obj = _objectSpread({}, schemaNode);
+
+    for (var key in obj) {
+      var value = obj[key];
+
+      if (key === "$ref" && typeof value === "string" && value.startsWith("#")) {
+        obj[key] = ROOT_SCHEMA_PREFIX + value;
+      } else {
+        obj[key] = withIdRefPrefix(value);
+      }
+    }
+  } else if (Array.isArray(schemaNode)) {
+    obj = _toConsumableArray(schemaNode);
+
+    for (var i = 0; i < obj.length; i++) {
+      obj[i] = withIdRefPrefix(obj[i]);
+    }
+  }
+
+  return obj;
+}
+/**
+ * Validates data against a schema, returning true if the data is valid, or
+ * false otherwise. If the schema is invalid, then this function will return
+ * false.
+ */
+
+
+function isValid(schema, data, rootSchema) {
+  try {
+    // add the rootSchema ROOT_SCHEMA_PREFIX as id.
+    // then rewrite the schema ref's to point to the rootSchema
+    // this accounts for the case where schema have references to models
+    // that lives in the rootSchema but not in the schema in question.
+    return ajv.addSchema(rootSchema, ROOT_SCHEMA_PREFIX).validate(withIdRefPrefix(schema), data);
+  } catch (e) {
+    return false;
+  } finally {
+    // make sure we remove the rootSchema from the global ajv instance
+    ajv.removeSchema(ROOT_SCHEMA_PREFIX);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/validate.js"],"names":["ajv","createAjvInstance","formerCustomFormats","formerMetaSchema","ROOT_SCHEMA_PREFIX","Ajv","errorDataPath","allErrors","multipleOfPrecision","schemaId","unknownFormats","addFormat","toErrorSchema","errors","length","reduce","errorSchema","error","property","message","path","parent","splice","slice","segment","Array","isArray","__errors","concat","toErrorList","fieldName","errorList","map","stack","Object","keys","acc","key","createErrorHandler","formData","handler","addError","push","value","unwrapErrorHandler","errorHandler","transformAjvErrors","e","dataPath","keyword","params","schemaPath","name","trim","validateFormData","schema","customValidate","transformErrors","additionalMetaSchemas","customFormats","rootSchema","newMetaSchemas","newFormats","addMetaSchema","forEach","formatName","validationError","validate","err","noProperMetaSchema","includes","$schema","userErrorSchema","newErrorSchema","newErrors","withIdRefPrefix","schemaNode","obj","constructor","startsWith","i","isValid","data","addSchema","removeSchema"],"mappings":"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","sourcesContent":["import toPath from \"lodash/toPath\";\nimport Ajv from \"ajv\";\nlet ajv = createAjvInstance();\nimport { deepEquals, getDefaultFormState } from \"./utils\";\n\nlet formerCustomFormats = null;\nlet formerMetaSchema = null;\nconst ROOT_SCHEMA_PREFIX = \"__rjsf_rootSchema\";\n\nimport { isObject, mergeObjects } from \"./utils\";\n\nfunction createAjvInstance() {\n  const ajv = new Ajv({\n    errorDataPath: \"property\",\n    allErrors: true,\n    multipleOfPrecision: 8,\n    schemaId: \"auto\",\n    unknownFormats: \"ignore\",\n  });\n\n  // add custom formats\n  ajv.addFormat(\n    \"data-url\",\n    /^data:([a-z]+\\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/\n  );\n  ajv.addFormat(\n    \"color\",\n    /^(#?([0-9A-Fa-f]{3}){1,2}\\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\\(\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*\\))|(rgb\\(\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*\\)))$/\n  );\n  return ajv;\n}\n\nfunction toErrorSchema(errors) {\n  // Transforms a ajv validation errors list:\n  // [\n  //   {property: \".level1.level2[2].level3\", message: \"err a\"},\n  //   {property: \".level1.level2[2].level3\", message: \"err b\"},\n  //   {property: \".level1.level2[4].level3\", message: \"err b\"},\n  // ]\n  // Into an error tree:\n  // {\n  //   level1: {\n  //     level2: {\n  //       2: {level3: {errors: [\"err a\", \"err b\"]}},\n  //       4: {level3: {errors: [\"err b\"]}},\n  //     }\n  //   }\n  // };\n  if (!errors.length) {\n    return {};\n  }\n  return errors.reduce((errorSchema, error) => {\n    const { property, message } = error;\n    const path = toPath(property);\n    let parent = errorSchema;\n\n    // If the property is at the root (.level1) then toPath creates\n    // an empty array element at the first index. Remove it.\n    if (path.length > 0 && path[0] === \"\") {\n      path.splice(0, 1);\n    }\n\n    for (const segment of path.slice(0)) {\n      if (!(segment in parent)) {\n        parent[segment] = {};\n      }\n      parent = parent[segment];\n    }\n\n    if (Array.isArray(parent.__errors)) {\n      // We store the list of errors for this node in a property named __errors\n      // to avoid name collision with a possible sub schema field named\n      // \"errors\" (see `validate.createErrorHandler`).\n      parent.__errors = parent.__errors.concat(message);\n    } else {\n      if (message) {\n        parent.__errors = [message];\n      }\n    }\n    return errorSchema;\n  }, {});\n}\n\nexport function toErrorList(errorSchema, fieldName = \"root\") {\n  // XXX: We should transform fieldName as a full field path string.\n  let errorList = [];\n  if (\"__errors\" in errorSchema) {\n    errorList = errorList.concat(\n      errorSchema.__errors.map(stack => {\n        return {\n          stack: `${fieldName}: ${stack}`,\n        };\n      })\n    );\n  }\n  return Object.keys(errorSchema).reduce((acc, key) => {\n    if (key !== \"__errors\") {\n      acc = acc.concat(toErrorList(errorSchema[key], key));\n    }\n    return acc;\n  }, errorList);\n}\n\nfunction createErrorHandler(formData) {\n  const handler = {\n    // We store the list of errors for this node in a property named __errors\n    // to avoid name collision with a possible sub schema field named\n    // \"errors\" (see `utils.toErrorSchema`).\n    __errors: [],\n    addError(message) {\n      this.__errors.push(message);\n    },\n  };\n  if (isObject(formData)) {\n    return Object.keys(formData).reduce((acc, key) => {\n      return { ...acc, [key]: createErrorHandler(formData[key]) };\n    }, handler);\n  }\n  if (Array.isArray(formData)) {\n    return formData.reduce((acc, value, key) => {\n      return { ...acc, [key]: createErrorHandler(value) };\n    }, handler);\n  }\n  return handler;\n}\n\nfunction unwrapErrorHandler(errorHandler) {\n  return Object.keys(errorHandler).reduce((acc, key) => {\n    if (key === \"addError\") {\n      return acc;\n    } else if (key === \"__errors\") {\n      return { ...acc, [key]: errorHandler[key] };\n    }\n    return { ...acc, [key]: unwrapErrorHandler(errorHandler[key]) };\n  }, {});\n}\n\n/**\n * Transforming the error output from ajv to format used by jsonschema.\n * At some point, components should be updated to support ajv.\n */\nfunction transformAjvErrors(errors = []) {\n  if (errors === null) {\n    return [];\n  }\n\n  return errors.map(e => {\n    const { dataPath, keyword, message, params, schemaPath } = e;\n    let property = `${dataPath}`;\n\n    // put data in expected format\n    return {\n      name: keyword,\n      property,\n      message,\n      params, // specific to ajv\n      stack: `${property} ${message}`.trim(),\n      schemaPath,\n    };\n  });\n}\n\n/**\n * This function processes the formData with a user `validate` contributed\n * function, which receives the form data and an `errorHandler` object that\n * will be used to add custom validation errors for each field.\n */\nexport default function validateFormData(\n  formData,\n  schema,\n  customValidate,\n  transformErrors,\n  additionalMetaSchemas = [],\n  customFormats = {}\n) {\n  // Include form data with undefined values, which is required for validation.\n  const rootSchema = schema;\n  formData = getDefaultFormState(schema, formData, rootSchema, true);\n\n  const newMetaSchemas = !deepEquals(formerMetaSchema, additionalMetaSchemas);\n  const newFormats = !deepEquals(formerCustomFormats, customFormats);\n\n  if (newMetaSchemas || newFormats) {\n    ajv = createAjvInstance();\n  }\n\n  // add more schemas to validate against\n  if (\n    additionalMetaSchemas &&\n    newMetaSchemas &&\n    Array.isArray(additionalMetaSchemas)\n  ) {\n    ajv.addMetaSchema(additionalMetaSchemas);\n    formerMetaSchema = additionalMetaSchemas;\n  }\n\n  // add more custom formats to validate against\n  if (customFormats && newFormats && isObject(customFormats)) {\n    Object.keys(customFormats).forEach(formatName => {\n      ajv.addFormat(formatName, customFormats[formatName]);\n    });\n\n    formerCustomFormats = customFormats;\n  }\n\n  let validationError = null;\n  try {\n    ajv.validate(schema, formData);\n  } catch (err) {\n    validationError = err;\n  }\n\n  let errors = transformAjvErrors(ajv.errors);\n  // Clear errors to prevent persistent errors, see #1104\n\n  ajv.errors = null;\n\n  const noProperMetaSchema =\n    validationError &&\n    validationError.message &&\n    typeof validationError.message === \"string\" &&\n    validationError.message.includes(\"no schema with key or ref \");\n\n  if (noProperMetaSchema) {\n    errors = [\n      ...errors,\n      {\n        stack: validationError.message,\n      },\n    ];\n  }\n  if (typeof transformErrors === \"function\") {\n    errors = transformErrors(errors);\n  }\n\n  let errorSchema = toErrorSchema(errors);\n\n  if (noProperMetaSchema) {\n    errorSchema = {\n      ...errorSchema,\n      ...{\n        $schema: {\n          __errors: [validationError.message],\n        },\n      },\n    };\n  }\n\n  if (typeof customValidate !== \"function\") {\n    return { errors, errorSchema };\n  }\n\n  const errorHandler = customValidate(formData, createErrorHandler(formData));\n  const userErrorSchema = unwrapErrorHandler(errorHandler);\n  const newErrorSchema = mergeObjects(errorSchema, userErrorSchema, true);\n  // XXX: The errors list produced is not fully compliant with the format\n  // exposed by the jsonschema lib, which contains full field paths and other\n  // properties.\n  const newErrors = toErrorList(newErrorSchema);\n\n  return {\n    errors: newErrors,\n    errorSchema: newErrorSchema,\n  };\n}\n\n/**\n * Recursively prefixes all $ref's in a schema with `ROOT_SCHEMA_PREFIX`\n * This is used in isValid to make references to the rootSchema\n */\nexport function withIdRefPrefix(schemaNode) {\n  let obj = schemaNode;\n  if (schemaNode.constructor === Object) {\n    obj = { ...schemaNode };\n    for (const key in obj) {\n      const value = obj[key];\n      if (\n        key === \"$ref\" &&\n        typeof value === \"string\" &&\n        value.startsWith(\"#\")\n      ) {\n        obj[key] = ROOT_SCHEMA_PREFIX + value;\n      } else {\n        obj[key] = withIdRefPrefix(value);\n      }\n    }\n  } else if (Array.isArray(schemaNode)) {\n    obj = [...schemaNode];\n    for (var i = 0; i < obj.length; i++) {\n      obj[i] = withIdRefPrefix(obj[i]);\n    }\n  }\n  return obj;\n}\n\n/**\n * Validates data against a schema, returning true if the data is valid, or\n * false otherwise. If the schema is invalid, then this function will return\n * false.\n */\nexport function isValid(schema, data, rootSchema) {\n  try {\n    // add the rootSchema ROOT_SCHEMA_PREFIX as id.\n    // then rewrite the schema ref's to point to the rootSchema\n    // this accounts for the case where schema have references to models\n    // that lives in the rootSchema but not in the schema in question.\n    return ajv\n      .addSchema(rootSchema, ROOT_SCHEMA_PREFIX)\n      .validate(withIdRefPrefix(schema), data);\n  } catch (e) {\n    return false;\n  } finally {\n    // make sure we remove the rootSchema from the global ajv instance\n    ajv.removeSchema(ROOT_SCHEMA_PREFIX);\n  }\n}\n"]}

package/dist/cjs/withTheme.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _ = _interopRequireDefault(require("./"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj["default"] = obj; return newObj; } }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function withTheme(themeProps) {
+  return (0, _react.forwardRef)(function (_ref, ref) {
+    var fields = _ref.fields,
+        widgets = _ref.widgets,
+        directProps = _objectWithoutProperties(_ref, ["fields", "widgets"]);
+
+    fields = _objectSpread({}, themeProps.fields, fields);
+    widgets = _objectSpread({}, themeProps.widgets, widgets);
+    return (
+      /*#__PURE__*/
+      _react["default"].createElement(_["default"], _extends({}, themeProps, directProps, {
+        fields: fields,
+        widgets: widgets,
+        ref: ref
+      }))
+    );
+  });
+}
+
+withTheme.propTypes = {
+  widgets: _propTypes["default"].object,
+  fields: _propTypes["default"].object
+};
+var _default = withTheme;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93aXRoVGhlbWUuanMiXSwibmFtZXMiOlsid2l0aFRoZW1lIiwidGhlbWVQcm9wcyIsInJlZiIsImZpZWxkcyIsIndpZGdldHMiLCJkaXJlY3RQcm9wcyIsInByb3BUeXBlcyIsIlByb3BUeXBlcyIsIm9iamVjdCJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFBOztBQUNBOztBQUNBOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsU0FBU0EsU0FBVCxDQUFtQkMsVUFBbkIsRUFBK0I7QUFDN0IsU0FBTyx1QkFBVyxnQkFBc0NDLEdBQXRDLEVBQThDO0FBQUEsUUFBM0NDLE1BQTJDLFFBQTNDQSxNQUEyQztBQUFBLFFBQW5DQyxPQUFtQyxRQUFuQ0EsT0FBbUM7QUFBQSxRQUF2QkMsV0FBdUI7O0FBQzlERixJQUFBQSxNQUFNLHFCQUFRRixVQUFVLENBQUNFLE1BQW5CLEVBQThCQSxNQUE5QixDQUFOO0FBQ0FDLElBQUFBLE9BQU8scUJBQVFILFVBQVUsQ0FBQ0csT0FBbkIsRUFBK0JBLE9BQS9CLENBQVA7QUFFQTtBQUFBO0FBQ0Usc0NBQUMsWUFBRCxlQUNNSCxVQUROLEVBRU1JLFdBRk47QUFHRSxRQUFBLE1BQU0sRUFBRUYsTUFIVjtBQUlFLFFBQUEsT0FBTyxFQUFFQyxPQUpYO0FBS0UsUUFBQSxHQUFHLEVBQUVGO0FBTFA7QUFERjtBQVNELEdBYk0sQ0FBUDtBQWNEOztBQUVERixTQUFTLENBQUNNLFNBQVYsR0FBc0I7QUFDcEJGLEVBQUFBLE9BQU8sRUFBRUcsc0JBQVVDLE1BREM7QUFFcEJMLEVBQUFBLE1BQU0sRUFBRUksc0JBQVVDO0FBRkUsQ0FBdEI7ZUFLZVIsUyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCwgeyBmb3J3YXJkUmVmIH0gZnJvbSBcInJlYWN0XCI7XG5pbXBvcnQgUHJvcFR5cGVzIGZyb20gXCJwcm9wLXR5cGVzXCI7XG5pbXBvcnQgRm9ybSBmcm9tIFwiLi9cIjtcblxuZnVuY3Rpb24gd2l0aFRoZW1lKHRoZW1lUHJvcHMpIHtcbiAgcmV0dXJuIGZvcndhcmRSZWYoKHsgZmllbGRzLCB3aWRnZXRzLCAuLi5kaXJlY3RQcm9wcyB9LCByZWYpID0+IHtcbiAgICBmaWVsZHMgPSB7IC4uLnRoZW1lUHJvcHMuZmllbGRzLCAuLi5maWVsZHMgfTtcbiAgICB3aWRnZXRzID0geyAuLi50aGVtZVByb3BzLndpZGdldHMsIC4uLndpZGdldHMgfTtcblxuICAgIHJldHVybiAoXG4gICAgICA8Rm9ybVxuICAgICAgICB7Li4udGhlbWVQcm9wc31cbiAgICAgICAgey4uLmRpcmVjdFByb3BzfVxuICAgICAgICBmaWVsZHM9e2ZpZWxkc31cbiAgICAgICAgd2lkZ2V0cz17d2lkZ2V0c31cbiAgICAgICAgcmVmPXtyZWZ9XG4gICAgICAvPlxuICAgICk7XG4gIH0pO1xufVxuXG53aXRoVGhlbWUucHJvcFR5cGVzID0ge1xuICB3aWRnZXRzOiBQcm9wVHlwZXMub2JqZWN0LFxuICBmaWVsZHM6IFByb3BUeXBlcy5vYmplY3QsXG59O1xuXG5leHBvcnQgZGVmYXVsdCB3aXRoVGhlbWU7XG4iXX0=

package/dist/es/components/AddButton.js

@@ -0,0 +1,28 @@
+import React from "react";
+import IconButton from "./IconButton";
+export default function AddButton(_ref) {
+  var className = _ref.className,
+      onClick = _ref.onClick,
+      disabled = _ref.disabled;
+  return (
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "row"
+    },
+    /*#__PURE__*/
+    React.createElement("p", {
+      className: "col-xs-3 col-xs-offset-9 text-right ".concat(className)
+    },
+    /*#__PURE__*/
+    React.createElement(IconButton, {
+      type: "info",
+      icon: "plus",
+      className: "btn-add col-xs-12",
+      "aria-label": "Add",
+      tabIndex: "0",
+      onClick: onClick,
+      disabled: disabled
+    })))
+  );
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL0FkZEJ1dHRvbi5qcyJdLCJuYW1lcyI6WyJSZWFjdCIsIkljb25CdXR0b24iLCJBZGRCdXR0b24iLCJjbGFzc05hbWUiLCJvbkNsaWNrIiwiZGlzYWJsZWQiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLEtBQVAsTUFBa0IsT0FBbEI7QUFDQSxPQUFPQyxVQUFQLE1BQXVCLGNBQXZCO0FBRUEsZUFBZSxTQUFTQyxTQUFULE9BQXFEO0FBQUEsTUFBaENDLFNBQWdDLFFBQWhDQSxTQUFnQztBQUFBLE1BQXJCQyxPQUFxQixRQUFyQkEsT0FBcUI7QUFBQSxNQUFaQyxRQUFZLFFBQVpBLFFBQVk7QUFDbEU7QUFBQTtBQUNFO0FBQUssTUFBQSxTQUFTLEVBQUM7QUFBZjtBQUFBO0FBQ0U7QUFBRyxNQUFBLFNBQVMsZ0RBQXlDRixTQUF6QztBQUFaO0FBQUE7QUFDRSx3QkFBQyxVQUFEO0FBQ0UsTUFBQSxJQUFJLEVBQUMsTUFEUDtBQUVFLE1BQUEsSUFBSSxFQUFDLE1BRlA7QUFHRSxNQUFBLFNBQVMsRUFBQyxtQkFIWjtBQUlFLG9CQUFXLEtBSmI7QUFLRSxNQUFBLFFBQVEsRUFBQyxHQUxYO0FBTUUsTUFBQSxPQUFPLEVBQUVDLE9BTlg7QUFPRSxNQUFBLFFBQVEsRUFBRUM7QUFQWixNQURGLENBREY7QUFERjtBQWVEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IEljb25CdXR0b24gZnJvbSBcIi4vSWNvbkJ1dHRvblwiO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBBZGRCdXR0b24oeyBjbGFzc05hbWUsIG9uQ2xpY2ssIGRpc2FibGVkIH0pIHtcbiAgcmV0dXJuIChcbiAgICA8ZGl2IGNsYXNzTmFtZT1cInJvd1wiPlxuICAgICAgPHAgY2xhc3NOYW1lPXtgY29sLXhzLTMgY29sLXhzLW9mZnNldC05IHRleHQtcmlnaHQgJHtjbGFzc05hbWV9YH0+XG4gICAgICAgIDxJY29uQnV0dG9uXG4gICAgICAgICAgdHlwZT1cImluZm9cIlxuICAgICAgICAgIGljb249XCJwbHVzXCJcbiAgICAgICAgICBjbGFzc05hbWU9XCJidG4tYWRkIGNvbC14cy0xMlwiXG4gICAgICAgICAgYXJpYS1sYWJlbD1cIkFkZFwiXG4gICAgICAgICAgdGFiSW5kZXg9XCIwXCJcbiAgICAgICAgICBvbkNsaWNrPXtvbkNsaWNrfVxuICAgICAgICAgIGRpc2FibGVkPXtkaXNhYmxlZH1cbiAgICAgICAgLz5cbiAgICAgIDwvcD5cbiAgICA8L2Rpdj5cbiAgKTtcbn1cbiJdfQ==

package/dist/es/components/ErrorList.js

@@ -0,0 +1,31 @@
+import React from "react";
+export default function ErrorList(props) {
+  var errors = props.errors;
+  return (
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "panel panel-danger errors"
+    },
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "panel-heading"
+    },
+    /*#__PURE__*/
+    React.createElement("h3", {
+      className: "panel-title"
+    }, "Errors")),
+    /*#__PURE__*/
+    React.createElement("ul", {
+      className: "list-group"
+    }, errors.map(function (error, i) {
+      return (
+        /*#__PURE__*/
+        React.createElement("li", {
+          key: i,
+          className: "list-group-item text-danger"
+        }, error.stack)
+      );
+    })))
+  );
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL0Vycm9yTGlzdC5qcyJdLCJuYW1lcyI6WyJSZWFjdCIsIkVycm9yTGlzdCIsInByb3BzIiwiZXJyb3JzIiwibWFwIiwiZXJyb3IiLCJpIiwic3RhY2siXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLEtBQVAsTUFBa0IsT0FBbEI7QUFFQSxlQUFlLFNBQVNDLFNBQVQsQ0FBbUJDLEtBQW5CLEVBQTBCO0FBQUEsTUFDL0JDLE1BRCtCLEdBQ3BCRCxLQURvQixDQUMvQkMsTUFEK0I7QUFFdkM7QUFBQTtBQUNFO0FBQUssTUFBQSxTQUFTLEVBQUM7QUFBZjtBQUFBO0FBQ0U7QUFBSyxNQUFBLFNBQVMsRUFBQztBQUFmO0FBQUE7QUFDRTtBQUFJLE1BQUEsU0FBUyxFQUFDO0FBQWQsZ0JBREYsQ0FERjtBQUFBO0FBSUU7QUFBSSxNQUFBLFNBQVMsRUFBQztBQUFkLE9BQ0dBLE1BQU0sQ0FBQ0MsR0FBUCxDQUFXLFVBQUNDLEtBQUQsRUFBUUMsQ0FBUixFQUFjO0FBQ3hCO0FBQUE7QUFDRTtBQUFJLFVBQUEsR0FBRyxFQUFFQSxDQUFUO0FBQVksVUFBQSxTQUFTLEVBQUM7QUFBdEIsV0FDR0QsS0FBSyxDQUFDRSxLQURUO0FBREY7QUFLRCxLQU5BLENBREgsQ0FKRjtBQURGO0FBZ0JEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBFcnJvckxpc3QocHJvcHMpIHtcbiAgY29uc3QgeyBlcnJvcnMgfSA9IHByb3BzO1xuICByZXR1cm4gKFxuICAgIDxkaXYgY2xhc3NOYW1lPVwicGFuZWwgcGFuZWwtZGFuZ2VyIGVycm9yc1wiPlxuICAgICAgPGRpdiBjbGFzc05hbWU9XCJwYW5lbC1oZWFkaW5nXCI+XG4gICAgICAgIDxoMyBjbGFzc05hbWU9XCJwYW5lbC10aXRsZVwiPkVycm9yczwvaDM+XG4gICAgICA8L2Rpdj5cbiAgICAgIDx1bCBjbGFzc05hbWU9XCJsaXN0LWdyb3VwXCI+XG4gICAgICAgIHtlcnJvcnMubWFwKChlcnJvciwgaSkgPT4ge1xuICAgICAgICAgIHJldHVybiAoXG4gICAgICAgICAgICA8bGkga2V5PXtpfSBjbGFzc05hbWU9XCJsaXN0LWdyb3VwLWl0ZW0gdGV4dC1kYW5nZXJcIj5cbiAgICAgICAgICAgICAge2Vycm9yLnN0YWNrfVxuICAgICAgICAgICAgPC9saT5cbiAgICAgICAgICApO1xuICAgICAgICB9KX1cbiAgICAgIDwvdWw+XG4gICAgPC9kaXY+XG4gICk7XG59XG4iXX0=