@rjsf/core 4.2.2 → 4.2.3

package/dist/es/validate.js

@@ -0,0 +1,338 @@
+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; }
+
+import toPath from "lodash/toPath";
+import Ajv from "ajv";
+var ajv = createAjvInstance();
+import { deepEquals, getDefaultFormState } from "./utils";
+var formerCustomFormats = null;
+var formerMetaSchema = null;
+var ROOT_SCHEMA_PREFIX = "__rjsf_rootSchema";
+import { isObject, mergeObjects } from "./utils";
+
+function createAjvInstance() {
+  var ajv = new Ajv({
+    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 = toPath(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;
+  }, {});
+}
+
+export 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 (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.
+ */
+
+
+export default 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 = getDefaultFormState(schema, formData, rootSchema, true);
+  var newMetaSchemas = !deepEquals(formerMetaSchema, additionalMetaSchemas);
+  var newFormats = !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 && 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 = 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
+ */
+
+export 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.
+ */
+
+export 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":["toPath","Ajv","ajv","createAjvInstance","deepEquals","getDefaultFormState","formerCustomFormats","formerMetaSchema","ROOT_SCHEMA_PREFIX","isObject","mergeObjects","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/es/withTheme.js

@@ -0,0 +1,39 @@
+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; }
+
+import React, { forwardRef } from "react";
+import PropTypes from "prop-types";
+import Form from "./";
+
+function withTheme(themeProps) {
+  return 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.createElement(Form, _extends({}, themeProps, directProps, {
+        fields: fields,
+        widgets: widgets,
+        ref: ref
+      }))
+    );
+  });
+}
+
+withTheme.propTypes = {
+  widgets: PropTypes.object,
+  fields: PropTypes.object
+};
+export default withTheme;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL0FkZEJ1dHRvbi5qcyJdLCJuYW1lcyI6WyJSZWFjdCIsIkljb25CdXR0b24iLCJBZGRCdXR0b24iLCJjbGFzc05hbWUiLCJvbkNsaWNrIiwiZGlzYWJsZWQiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLEtBQVAsTUFBa0IsT0FBbEI7QUFDQSxPQUFPQyxVQUFQLE1BQXVCLGNBQXZCO0FBRUEsZUFBZSxTQUFTQyxTQUFULE9BQXFEO0FBQUEsTUFBaENDLFNBQWdDLFFBQWhDQSxTQUFnQztBQUFBLE1BQXJCQyxPQUFxQixRQUFyQkEsT0FBcUI7QUFBQSxNQUFaQyxRQUFZLFFBQVpBLFFBQVk7QUFDbEU7QUFBQTtBQUNFO0FBQUssTUFBQSxTQUFTLEVBQUM7QUFBZjtBQUFBO0FBQ0U7QUFBRyxNQUFBLFNBQVMsZ0RBQXlDRixTQUF6QztBQUFaO0FBQUE7QUFDRSx3QkFBQyxVQUFEO0FBQ0UsTUFBQSxJQUFJLEVBQUMsTUFEUDtBQUVFLE1BQUEsSUFBSSxFQUFDLE1BRlA7QUFHRSxNQUFBLFNBQVMsRUFBQyxtQkFIWjtBQUlFLG9CQUFXLEtBSmI7QUFLRSxNQUFBLFFBQVEsRUFBQyxHQUxYO0FBTUUsTUFBQSxPQUFPLEVBQUVDLE9BTlg7QUFPRSxNQUFBLFFBQVEsRUFBRUM7QUFQWixNQURGLENBREY7QUFERjtBQWVEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IEljb25CdXR0b24gZnJvbSBcIi4vSWNvbkJ1dHRvblwiO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBBZGRCdXR0b24oeyBjbGFzc05hbWUsIG9uQ2xpY2ssIGRpc2FibGVkIH0pIHtcbiAgcmV0dXJuIChcbiAgICA8ZGl2IGNsYXNzTmFtZT1cInJvd1wiPlxuICAgICAgPHAgY2xhc3NOYW1lPXtgY29sLXhzLTMgY29sLXhzLW9mZnNldC05IHRleHQtcmlnaHQgJHtjbGFzc05hbWV9YH0+XG4gICAgICAgIDxJY29uQnV0dG9uXG4gICAgICAgICAgdHlwZT1cImluZm9cIlxuICAgICAgICAgIGljb249XCJwbHVzXCJcbiAgICAgICAgICBjbGFzc05hbWU9XCJidG4tYWRkIGNvbC14cy0xMlwiXG4gICAgICAgICAgYXJpYS1sYWJlbD1cIkFkZFwiXG4gICAgICAgICAgdGFiSW5kZXg9XCIwXCJcbiAgICAgICAgICBvbkNsaWNrPXtvbkNsaWNrfVxuICAgICAgICAgIGRpc2FibGVkPXtkaXNhYmxlZH1cbiAgICAgICAgLz5cbiAgICAgIDwvcD5cbiAgICA8L2Rpdj5cbiAgKTtcbn1cbiJdfQ==

package/lib/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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL0Vycm9yTGlzdC5qcyJdLCJuYW1lcyI6WyJSZWFjdCIsIkVycm9yTGlzdCIsInByb3BzIiwiZXJyb3JzIiwibWFwIiwiZXJyb3IiLCJpIiwic3RhY2siXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLEtBQVAsTUFBa0IsT0FBbEI7QUFFQSxlQUFlLFNBQVNDLFNBQVQsQ0FBbUJDLEtBQW5CLEVBQTBCO0FBQUEsTUFDL0JDLE1BRCtCLEdBQ3BCRCxLQURvQixDQUMvQkMsTUFEK0I7QUFFdkM7QUFBQTtBQUNFO0FBQUssTUFBQSxTQUFTLEVBQUM7QUFBZjtBQUFBO0FBQ0U7QUFBSyxNQUFBLFNBQVMsRUFBQztBQUFmO0FBQUE7QUFDRTtBQUFJLE1BQUEsU0FBUyxFQUFDO0FBQWQsZ0JBREYsQ0FERjtBQUFBO0FBSUU7QUFBSSxNQUFBLFNBQVMsRUFBQztBQUFkLE9BQ0dBLE1BQU0sQ0FBQ0MsR0FBUCxDQUFXLFVBQUNDLEtBQUQsRUFBUUMsQ0FBUixFQUFjO0FBQ3hCO0FBQUE7QUFDRTtBQUFJLFVBQUEsR0FBRyxFQUFFQSxDQUFUO0FBQVksVUFBQSxTQUFTLEVBQUM7QUFBdEIsV0FDR0QsS0FBSyxDQUFDRSxLQURUO0FBREY7QUFLRCxLQU5BLENBREgsQ0FKRjtBQURGO0FBZ0JEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBFcnJvckxpc3QocHJvcHMpIHtcbiAgY29uc3QgeyBlcnJvcnMgfSA9IHByb3BzO1xuICByZXR1cm4gKFxuICAgIDxkaXYgY2xhc3NOYW1lPVwicGFuZWwgcGFuZWwtZGFuZ2VyIGVycm9yc1wiPlxuICAgICAgPGRpdiBjbGFzc05hbWU9XCJwYW5lbC1oZWFkaW5nXCI+XG4gICAgICAgIDxoMyBjbGFzc05hbWU9XCJwYW5lbC10aXRsZVwiPkVycm9yczwvaDM+XG4gICAgICA8L2Rpdj5cbiAgICAgIDx1bCBjbGFzc05hbWU9XCJsaXN0LWdyb3VwXCI+XG4gICAgICAgIHtlcnJvcnMubWFwKChlcnJvciwgaSkgPT4ge1xuICAgICAgICAgIHJldHVybiAoXG4gICAgICAgICAgICA8bGkga2V5PXtpfSBjbGFzc05hbWU9XCJsaXN0LWdyb3VwLWl0ZW0gdGV4dC1kYW5nZXJcIj5cbiAgICAgICAgICAgICAge2Vycm9yLnN0YWNrfVxuICAgICAgICAgICAgPC9saT5cbiAgICAgICAgICApO1xuICAgICAgICB9KX1cbiAgICAgIDwvdWw+XG4gICAgPC9kaXY+XG4gICk7XG59XG4iXX0=