@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/components/MediaLibrary/MediaLibrarySearch.js

@@ -0,0 +1,51 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Icon, lengths, colors, zIndex } from 'decap-cms-ui-default';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const SearchContainer = /*#__PURE__*/_styled("div", {
+  target: "es105dq2",
+  label: "SearchContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "sycyb7",
+  styles: "height:37px;display:flex;align-items:center;position:relative;width:400px"
+} : {
+  name: "sycyb7",
+  styles: "height:37px;display:flex;align-items:center;position:relative;width:400px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const SearchInput = /*#__PURE__*/_styled("input", {
+  target: "es105dq1",
+  label: "SearchInput"
+})("background-color:#eff0f4;border-radius:", lengths.borderRadius, ";font-size:14px;padding:10px 6px 10px 32px;width:100%;position:relative;z-index:", zIndex.zIndex1, ";&:focus{outline:none;box-shadow:inset 0 0 0 2px ", colors.active, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const SearchIcon = /*#__PURE__*/_styled(Icon, {
+  target: "es105dq0",
+  label: "SearchIcon"
+})("position:absolute;top:50%;left:6px;z-index:", zIndex.zIndex2, ";transform:translate(0, -50%);" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL01lZGlhTGlicmFyeS9NZWRpYUxpYnJhcnlTZWFyY2guanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBNkIrQiIsImZpbGUiOiIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9NZWRpYUxpYnJhcnkvTWVkaWFMaWJyYXJ5U2VhcmNoLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCBQcm9wVHlwZXMgZnJvbSAncHJvcC10eXBlcyc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5pbXBvcnQgeyBJY29uLCBsZW5ndGhzLCBjb2xvcnMsIHpJbmRleCB9IGZyb20gJ2RlY2FwLWNtcy11aS1kZWZhdWx0JztcblxuY29uc3QgU2VhcmNoQ29udGFpbmVyID0gc3R5bGVkLmRpdmBcbiAgaGVpZ2h0OiAzN3B4O1xuICBkaXNwbGF5OiBmbGV4O1xuICBhbGlnbi1pdGVtczogY2VudGVyO1xuICBwb3NpdGlvbjogcmVsYXRpdmU7XG4gIHdpZHRoOiA0MDBweDtcbmA7XG5cbmNvbnN0IFNlYXJjaElucHV0ID0gc3R5bGVkLmlucHV0YFxuICBiYWNrZ3JvdW5kLWNvbG9yOiAjZWZmMGY0O1xuICBib3JkZXItcmFkaXVzOiAke2xlbmd0aHMuYm9yZGVyUmFkaXVzfTtcblxuICBmb250LXNpemU6IDE0cHg7XG4gIHBhZGRpbmc6IDEwcHggNnB4IDEwcHggMzJweDtcbiAgd2lkdGg6IDEwMCU7XG4gIHBvc2l0aW9uOiByZWxhdGl2ZTtcbiAgei1pbmRleDogJHt6SW5kZXguekluZGV4MX07XG5cbiAgJjpmb2N1cyB7XG4gICAgb3V0bGluZTogbm9uZTtcbiAgICBib3gtc2hhZG93OiBpbnNldCAwIDAgMCAycHggJHtjb2xvcnMuYWN0aXZlfTtcbiAgfVxuYDtcblxuY29uc3QgU2VhcmNoSWNvbiA9IHN0eWxlZChJY29uKWBcbiAgcG9zaXRpb246IGFic29sdXRlO1xuICB0b3A6IDUwJTtcbiAgbGVmdDogNnB4O1xuICB6LWluZGV4OiAke3pJbmRleC56SW5kZXgyfTtcbiAgdHJhbnNmb3JtOiB0cmFuc2xhdGUoMCwgLTUwJSk7XG5gO1xuXG5mdW5jdGlvbiBNZWRpYUxpYnJhcnlTZWFyY2goeyB2YWx1ZSwgb25DaGFuZ2UsIG9uS2V5RG93biwgcGxhY2Vob2xkZXIsIGRpc2FibGVkIH0pIHtcbiAgcmV0dXJuIChcbiAgICA8U2VhcmNoQ29udGFpbmVyPlxuICAgICAgPFNlYXJjaEljb24gdHlwZT1cInNlYXJjaFwiIHNpemU9XCJzbWFsbFwiIC8+XG4gICAgICA8U2VhcmNoSW5wdXRcbiAgICAgICAgdmFsdWU9e3ZhbHVlfVxuICAgICAgICBvbkNoYW5nZT17b25DaGFuZ2V9XG4gICAgICAgIG9uS2V5RG93bj17b25LZXlEb3dufVxuICAgICAgICBwbGFjZWhvbGRlcj17cGxhY2Vob2xkZXJ9XG4gICAgICAgIGRpc2FibGVkPXtkaXNhYmxlZH1cbiAgICAgIC8+XG4gICAgPC9TZWFyY2hDb250YWluZXI+XG4gICk7XG59XG5cbk1lZGlhTGlicmFyeVNlYXJjaC5wcm9wVHlwZXMgPSB7XG4gIHZhbHVlOiBQcm9wVHlwZXMuc3RyaW5nLFxuICBvbkNoYW5nZTogUHJvcFR5cGVzLmZ1bmMuaXNSZXF1aXJlZCxcbiAgb25LZXlEb3duOiBQcm9wVHlwZXMuZnVuYy5pc1JlcXVpcmVkLFxuICBwbGFjZWhvbGRlcjogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkLFxuICBkaXNhYmxlZDogUHJvcFR5cGVzLmJvb2wsXG59O1xuXG5leHBvcnQgZGVmYXVsdCBNZWRpYUxpYnJhcnlTZWFyY2g7XG4iXX0= */"));
+function MediaLibrarySearch({
+  value,
+  onChange,
+  onKeyDown,
+  placeholder,
+  disabled
+}) {
+  return ___EmotionJSX(SearchContainer, null, ___EmotionJSX(SearchIcon, {
+    type: "search",
+    size: "small"
+  }), ___EmotionJSX(SearchInput, {
+    value: value,
+    onChange: onChange,
+    onKeyDown: onKeyDown,
+    placeholder: placeholder,
+    disabled: disabled
+  }));
+}
+MediaLibrarySearch.propTypes = {
+  value: PropTypes.string,
+  onChange: PropTypes.func.isRequired,
+  onKeyDown: PropTypes.func.isRequired,
+  placeholder: PropTypes.string.isRequired,
+  disabled: PropTypes.bool
+};
+export default MediaLibrarySearch;

package/dist/esm/components/MediaLibrary/MediaLibraryTop.js

@@ -0,0 +1,123 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import MediaLibrarySearch from './MediaLibrarySearch';
+import MediaLibraryHeader from './MediaLibraryHeader';
+import { UploadButton, DeleteButton, DownloadButton, CopyToClipBoardButton, InsertButton } from './MediaLibraryButtons';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const LibraryTop = /*#__PURE__*/_styled("div", {
+  target: "e23c97a2",
+  label: "LibraryTop"
+})(process.env.NODE_ENV === "production" ? {
+  name: "16hjiy4",
+  styles: "position:relative;display:flex;flex-direction:column"
+} : {
+  name: "16hjiy4",
+  styles: "position:relative;display:flex;flex-direction:column/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const RowContainer = /*#__PURE__*/_styled("div", {
+  target: "e23c97a1",
+  label: "RowContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1eoy87d",
+  styles: "display:flex;justify-content:space-between"
+} : {
+  name: "1eoy87d",
+  styles: "display:flex;justify-content:space-between/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const ButtonsContainer = /*#__PURE__*/_styled("div", {
+  target: "e23c97a0",
+  label: "ButtonsContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "ozd7xs",
+  styles: "flex-shrink:0"
+} : {
+  name: "ozd7xs",
+  styles: "flex-shrink:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+function MediaLibraryTop({
+  t,
+  onClose,
+  privateUpload,
+  forImage,
+  onDownload,
+  onUpload,
+  query,
+  onSearchChange,
+  onSearchKeyDown,
+  searchDisabled,
+  onDelete,
+  canInsert,
+  onInsert,
+  hasSelection,
+  isPersisting,
+  isDeleting,
+  selectedFile
+}) {
+  const shouldShowButtonLoader = isPersisting || isDeleting;
+  const uploadEnabled = !shouldShowButtonLoader;
+  const deleteEnabled = !shouldShowButtonLoader && hasSelection;
+  const uploadButtonLabel = isPersisting ? t('mediaLibrary.mediaLibraryModal.uploading') : t('mediaLibrary.mediaLibraryModal.upload');
+  const deleteButtonLabel = isDeleting ? t('mediaLibrary.mediaLibraryModal.deleting') : t('mediaLibrary.mediaLibraryModal.deleteSelected');
+  const downloadButtonLabel = t('mediaLibrary.mediaLibraryModal.download');
+  const insertButtonLabel = t('mediaLibrary.mediaLibraryModal.chooseSelected');
+  return ___EmotionJSX(LibraryTop, null, ___EmotionJSX(RowContainer, null, ___EmotionJSX(MediaLibraryHeader, {
+    onClose: onClose,
+    title: `${privateUpload ? t('mediaLibrary.mediaLibraryModal.private') : ''}${forImage ? t('mediaLibrary.mediaLibraryModal.images') : t('mediaLibrary.mediaLibraryModal.mediaAssets')}`,
+    isPrivate: privateUpload
+  }), ___EmotionJSX(ButtonsContainer, null, ___EmotionJSX(CopyToClipBoardButton, {
+    disabled: !hasSelection,
+    path: selectedFile.path,
+    name: selectedFile.name,
+    draft: selectedFile.draft,
+    t: t
+  }), ___EmotionJSX(DownloadButton, {
+    onClick: onDownload,
+    disabled: !hasSelection
+  }, downloadButtonLabel), ___EmotionJSX(UploadButton, {
+    label: uploadButtonLabel,
+    imagesOnly: forImage,
+    onChange: onUpload,
+    disabled: !uploadEnabled
+  }))), ___EmotionJSX(RowContainer, null, ___EmotionJSX(MediaLibrarySearch, {
+    value: query,
+    onChange: onSearchChange,
+    onKeyDown: onSearchKeyDown,
+    placeholder: t('mediaLibrary.mediaLibraryModal.search'),
+    disabled: searchDisabled
+  }), ___EmotionJSX(ButtonsContainer, null, ___EmotionJSX(DeleteButton, {
+    onClick: onDelete,
+    disabled: !deleteEnabled
+  }, deleteButtonLabel), !canInsert ? null : ___EmotionJSX(InsertButton, {
+    onClick: onInsert,
+    disabled: !hasSelection
+  }, insertButtonLabel))));
+}
+MediaLibraryTop.propTypes = {
+  t: PropTypes.func.isRequired,
+  onClose: PropTypes.func.isRequired,
+  privateUpload: PropTypes.bool,
+  forImage: PropTypes.bool,
+  onDownload: PropTypes.func.isRequired,
+  onUpload: PropTypes.func.isRequired,
+  query: PropTypes.string,
+  onSearchChange: PropTypes.func.isRequired,
+  onSearchKeyDown: PropTypes.func.isRequired,
+  searchDisabled: PropTypes.bool.isRequired,
+  onDelete: PropTypes.func.isRequired,
+  canInsert: PropTypes.bool,
+  onInsert: PropTypes.func.isRequired,
+  hasSelection: PropTypes.bool.isRequired,
+  isPersisting: PropTypes.bool,
+  isDeleting: PropTypes.bool,
+  selectedFile: PropTypes.oneOfType([PropTypes.shape({
+    path: PropTypes.string.isRequired,
+    draft: PropTypes.bool.isRequired,
+    name: PropTypes.string.isRequired
+  }), PropTypes.shape({})])
+};
+export default MediaLibraryTop;

package/dist/esm/components/UI/DragDrop.js

@@ -0,0 +1,67 @@
+import { HTML5Backend as ReactDNDHTML5Backend } from 'react-dnd-html5-backend';
+import { DndProvider as ReactDNDProvider, DragSource as ReactDNDDragSource, DropTarget as ReactDNDDropTarget } from 'react-dnd';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+export function DragSource({
+  namespace,
+  ...props
+}) {
+  const DragComponent = ReactDNDDragSource(namespace, {
+    // eslint-disable-next-line no-unused-vars
+    beginDrag({
+      children,
+      isDragging,
+      connectDragComponent,
+      ...ownProps
+    }) {
+      // We return the rest of the props as the ID of the element being dragged.
+      return ownProps;
+    }
+  }, connect => ({
+    connectDragComponent: connect.dragSource()
+  }))(({
+    children,
+    connectDragComponent
+  }) => children(connectDragComponent));
+  return /*#__PURE__*/React.createElement(DragComponent, props, props.children);
+}
+DragSource.propTypes = {
+  namespace: PropTypes.any.isRequired,
+  children: PropTypes.func.isRequired
+};
+export function DropTarget({
+  onDrop,
+  namespace,
+  ...props
+}) {
+  const DropComponent = ReactDNDDropTarget(namespace, {
+    drop(ownProps, monitor) {
+      onDrop(monitor.getItem());
+    }
+  }, (connect, monitor) => ({
+    connectDropTarget: connect.dropTarget(),
+    isHovered: monitor.isOver()
+  }))(({
+    children,
+    connectDropTarget,
+    isHovered
+  }) => children(connectDropTarget, {
+    isHovered
+  }));
+  return /*#__PURE__*/React.createElement(DropComponent, props, props.children);
+}
+DropTarget.propTypes = {
+  onDrop: PropTypes.func.isRequired,
+  namespace: PropTypes.any.isRequired,
+  children: PropTypes.func.isRequired
+};
+export function HTML5DragDrop(WrappedComponent) {
+  return class HTML5DragDrop extends React.Component {
+    render() {
+      return ___EmotionJSX(ReactDNDProvider, {
+        backend: ReactDNDHTML5Backend
+      }, ___EmotionJSX(WrappedComponent, this.props));
+    }
+  };
+}

package/dist/esm/components/UI/ErrorBoundary.js

@@ -0,0 +1,173 @@
+import _styled from "@emotion/styled/base";
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate } from 'react-polyglot';
+import yaml from 'yaml';
+import truncate from 'lodash/truncate';
+import copyToClipboard from 'copy-text-to-clipboard';
+import { localForage } from 'decap-cms-lib-util';
+import { buttons, colors } from 'decap-cms-ui-default';
+import cleanStack from 'clean-stack';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const ISSUE_URL = 'https://github.com/decaporg/decap-cms/issues/new?';
+function getIssueTemplate({
+  version,
+  provider,
+  browser,
+  config
+}) {
+  return `
+**Describe the bug**
+
+**To Reproduce**
+
+**Expected behavior**
+
+**Screenshots**
+
+**Applicable Versions:**
+ - Decap CMS version: \`${version}\`
+ - Git provider: \`${provider}\`
+ - Browser version: \`${browser}\`
+
+**CMS configuration**
+\`\`\`
+${config}
+\`\`\`
+
+**Additional context**
+`;
+}
+function buildIssueTemplate({
+  config
+}) {
+  let version = '';
+  if (typeof DECAP_CMS_VERSION === 'string') {
+    version = `decap-cms@${DECAP_CMS_VERSION}`;
+  } else if (typeof "3.9.0" === 'string') {
+    version = `decap-cms-app@${"3.9.0"}`;
+  }
+  const template = getIssueTemplate({
+    version,
+    provider: config.backend.name,
+    browser: navigator.userAgent,
+    config: yaml.stringify(config)
+  });
+  return template;
+}
+function buildIssueUrl({
+  title,
+  config
+}) {
+  try {
+    const body = buildIssueTemplate({
+      config
+    });
+    const params = new URLSearchParams();
+    params.append('title', truncate(title, {
+      length: 100
+    }));
+    params.append('body', truncate(body, {
+      length: 4000,
+      omission: '\n...'
+    }));
+    params.append('labels', 'type: bug');
+    return `${ISSUE_URL}${params.toString()}`;
+  } catch (e) {
+    console.log(e);
+    return `${ISSUE_URL}template=bug_report.md`;
+  }
+}
+const ErrorBoundaryContainer = /*#__PURE__*/_styled("div", {
+  target: "e4lz5aw2",
+  label: "ErrorBoundaryContainer"
+})("padding:40px;h1{font-size:28px;color:", colors.text, ";}h2{font-size:20px;}strong{color:", colors.textLead, ";font-weight:500;}hr{width:200px;margin:30px 0;border:0;height:1px;background-color:", colors.text, ";}a{color:", colors.active, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL1VJL0Vycm9yQm91bmRhcnkuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0V5QyIsImZpbGUiOiIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9VSS9FcnJvckJvdW5kYXJ5LmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCBQcm9wVHlwZXMgZnJvbSAncHJvcC10eXBlcyc7XG5pbXBvcnQgeyB0cmFuc2xhdGUgfSBmcm9tICdyZWFjdC1wb2x5Z2xvdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5pbXBvcnQgeWFtbCBmcm9tICd5YW1sJztcbmltcG9ydCB0cnVuY2F0ZSBmcm9tICdsb2Rhc2gvdHJ1bmNhdGUnO1xuaW1wb3J0IGNvcHlUb0NsaXBib2FyZCBmcm9tICdjb3B5LXRleHQtdG8tY2xpcGJvYXJkJztcbmltcG9ydCB7IGxvY2FsRm9yYWdlIH0gZnJvbSAnZGVjYXAtY21zLWxpYi11dGlsJztcbmltcG9ydCB7IGJ1dHRvbnMsIGNvbG9ycyB9IGZyb20gJ2RlY2FwLWNtcy11aS1kZWZhdWx0JztcbmltcG9ydCBjbGVhblN0YWNrIGZyb20gJ2NsZWFuLXN0YWNrJztcblxuY29uc3QgSVNTVUVfVVJMID0gJ2h0dHBzOi8vZ2l0aHViLmNvbS9kZWNhcG9yZy9kZWNhcC1jbXMvaXNzdWVzL25ldz8nO1xuXG5mdW5jdGlvbiBnZXRJc3N1ZVRlbXBsYXRlKHsgdmVyc2lvbiwgcHJvdmlkZXIsIGJyb3dzZXIsIGNvbmZpZyB9KSB7XG4gIHJldHVybiBgXG4qKkRlc2NyaWJlIHRoZSBidWcqKlxuXG4qKlRvIFJlcHJvZHVjZSoqXG5cbioqRXhwZWN0ZWQgYmVoYXZpb3IqKlxuXG4qKlNjcmVlbnNob3RzKipcblxuKipBcHBsaWNhYmxlIFZlcnNpb25zOioqXG4gLSBEZWNhcCBDTVMgdmVyc2lvbjogXFxgJHt2ZXJzaW9ufVxcYFxuIC0gR2l0IHByb3ZpZGVyOiBcXGAke3Byb3ZpZGVyfVxcYFxuIC0gQnJvd3NlciB2ZXJzaW9uOiBcXGAke2Jyb3dzZXJ9XFxgXG5cbioqQ01TIGNvbmZpZ3VyYXRpb24qKlxuXFxgXFxgXFxgXG4ke2NvbmZpZ31cblxcYFxcYFxcYFxuXG4qKkFkZGl0aW9uYWwgY29udGV4dCoqXG5gO1xufVxuXG5mdW5jdGlvbiBidWlsZElzc3VlVGVtcGxhdGUoeyBjb25maWcgfSkge1xuICBsZXQgdmVyc2lvbiA9ICcnO1xuICBpZiAodHlwZW9mIERFQ0FQX0NNU19WRVJTSU9OID09PSAnc3RyaW5nJykge1xuICAgIHZlcnNpb24gPSBgZGVjYXAtY21zQCR7REVDQVBfQ01TX1ZFUlNJT059YDtcbiAgfSBlbHNlIGlmICh0eXBlb2YgREVDQVBfQ01TX0FQUF9WRVJTSU9OID09PSAnc3RyaW5nJykge1xuICAgIHZlcnNpb24gPSBgZGVjYXAtY21zLWFwcEAke0RFQ0FQX0NNU19BUFBfVkVSU0lPTn1gO1xuICB9XG4gIGNvbnN0IHRlbXBsYXRlID0gZ2V0SXNzdWVUZW1wbGF0ZSh7XG4gICAgdmVyc2lvbixcbiAgICBwcm92aWRlcjogY29uZmlnLmJhY2tlbmQubmFtZSxcbiAgICBicm93c2VyOiBuYXZpZ2F0b3IudXNlckFnZW50LFxuICAgIGNvbmZpZzogeWFtbC5zdHJpbmdpZnkoY29uZmlnKSxcbiAgfSk7XG5cbiAgcmV0dXJuIHRlbXBsYXRlO1xufVxuXG5mdW5jdGlvbiBidWlsZElzc3VlVXJsKHsgdGl0bGUsIGNvbmZpZyB9KSB7XG4gIHRyeSB7XG4gICAgY29uc3QgYm9keSA9IGJ1aWxkSXNzdWVUZW1wbGF0ZSh7IGNvbmZpZyB9KTtcblxuICAgIGNvbnN0IHBhcmFtcyA9IG5ldyBVUkxTZWFyY2hQYXJhbXMoKTtcbiAgICBwYXJhbXMuYXBwZW5kKCd0aXRsZScsIHRydW5jYXRlKHRpdGxlLCB7IGxlbmd0aDogMTAwIH0pKTtcbiAgICBwYXJhbXMuYXBwZW5kKCdib2R5JywgdHJ1bmNhdGUoYm9keSwgeyBsZW5ndGg6IDQwMDAsIG9taXNzaW9uOiAnXFxuLi4uJyB9KSk7XG4gICAgcGFyYW1zLmFwcGVuZCgnbGFiZWxzJywgJ3R5cGU6IGJ1ZycpO1xuXG4gICAgcmV0dXJuIGAke0lTU1VFX1VSTH0ke3BhcmFtcy50b1N0cmluZygpfWA7XG4gIH0gY2F0Y2ggKGUpIHtcbiAgICBjb25zb2xlLmxvZyhlKTtcbiAgICByZXR1cm4gYCR7SVNTVUVfVVJMfXRlbXBsYXRlPWJ1Z19yZXBvcnQubWRgO1xuICB9XG59XG5cbmNvbnN0IEVycm9yQm91bmRhcnlDb250YWluZXIgPSBzdHlsZWQuZGl2YFxuICBwYWRkaW5nOiA0MHB4O1xuXG4gIGgxIHtcbiAgICBmb250LXNpemU6IDI4cHg7XG4gICAgY29sb3I6ICR7Y29sb3JzLnRleHR9O1xuICB9XG5cbiAgaDIge1xuICAgIGZvbnQtc2l6ZTogMjBweDtcbiAgfVxuXG4gIHN0cm9uZyB7XG4gICAgY29sb3I6ICR7Y29sb3JzLnRleHRMZWFkfTtcbiAgICBmb250LXdlaWdodDogNTAwO1xuICB9XG5cbiAgaHIge1xuICAgIHdpZHRoOiAyMDBweDtcbiAgICBtYXJnaW46IDMwcHggMDtcbiAgICBib3JkZXI6IDA7XG4gICAgaGVpZ2h0OiAxcHg7XG4gICAgYmFja2dyb3VuZC1jb2xvcjogJHtjb2xvcnMudGV4dH07XG4gIH1cblxuICBhIHtcbiAgICBjb2xvcjogJHtjb2xvcnMuYWN0aXZlfTtcbiAgfVxuYDtcblxuY29uc3QgUHJpdmFjeVdhcm5pbmcgPSBzdHlsZWQuc3BhbmBcbiAgY29sb3I6ICR7Y29sb3JzLnRleHR9O1xuYDtcblxuY29uc3QgQ29weUJ1dHRvbiA9IHN0eWxlZC5idXR0b25gXG4gICR7YnV0dG9ucy5idXR0b259O1xuICAke2J1dHRvbnMuZGVmYXVsdH07XG4gICR7YnV0dG9ucy5ncmF5fTtcbiAgZGlzcGxheTogYmxvY2s7XG4gIG1hcmdpbjogMTJweCAwO1xuYDtcblxuZnVuY3Rpb24gUmVjb3ZlcmVkRW50cnkoeyBlbnRyeSwgdCB9KSB7XG4gIGNvbnNvbGUubG9nKGVudHJ5KTtcbiAgcmV0dXJuIChcbiAgICA8PlxuICAgICAgPGhyIC8+XG4gICAgICA8aDI+e3QoJ3VpLmVycm9yQm91bmRhcnkucmVjb3ZlcmVkRW50cnkuaGVhZGluZycpfTwvaDI+XG4gICAgICA8c3Ryb25nPnt0KCd1aS5lcnJvckJvdW5kYXJ5LnJlY292ZXJlZEVudHJ5Lndhcm5pbmcnKX08L3N0cm9uZz5cbiAgICAgIDxDb3B5QnV0dG9uIG9uQ2xpY2s9eygpID0+IGNvcHlUb0NsaXBib2FyZChlbnRyeSl9PlxuICAgICAgICB7dCgndWkuZXJyb3JCb3VuZGFyeS5yZWNvdmVyZWRFbnRyeS5jb3B5QnV0dG9uTGFiZWwnKX1cbiAgICAgIDwvQ29weUJ1dHRvbj5cbiAgICAgIDxwcmU+XG4gICAgICAgIDxjb2RlPntlbnRyeX08L2NvZGU+XG4gICAgICA8L3ByZT5cbiAgICA8Lz5cbiAgKTtcbn1cblxuZXhwb3J0IGNsYXNzIEVycm9yQm91bmRhcnkgZXh0ZW5kcyBSZWFjdC5Db21wb25lbnQge1xuICBzdGF0aWMgcHJvcFR5cGVzID0ge1xuICAgIGNoaWxkcmVuOiBQcm9wVHlwZXMubm9kZSxcbiAgICB0OiBQcm9wVHlwZXMuZnVuYy5pc1JlcXVpcmVkLFxuICAgIGNvbmZpZzogUHJvcFR5cGVzLm9iamVjdC5pc1JlcXVpcmVkLFxuICB9O1xuXG4gIHN0YXRlID0ge1xuICAgIGhhc0Vycm9yOiBmYWxzZSxcbiAgICBlcnJvck1lc3NhZ2U6ICcnLFxuICAgIGVycm9yVGl0bGU6ICcnLFxuICAgIGJhY2t1cDogJycsXG4gIH07XG5cbiAgc3RhdGljIGdldERlcml2ZWRTdGF0ZUZyb21FcnJvcihlcnJvcikge1xuICAgIGNvbnNvbGUuZXJyb3IoZXJyb3IpO1xuICAgIHJldHVybiB7XG4gICAgICBoYXNFcnJvcjogdHJ1ZSxcbiAgICAgIGVycm9yTWVzc2FnZTogY2xlYW5TdGFjayhlcnJvci5zdGFjaywgeyBiYXNlUGF0aDogd2luZG93LmxvY2F0aW9uLm9yaWdpbiB8fCAnJyB9KSxcbiAgICAgIGVycm9yVGl0bGU6IGVycm9yLnRvU3RyaW5nKCksXG4gICAgfTtcbiAgfVxuXG4gIGNvbXBvbmVudERpZE1vdW50KCkge1xuICAgIC8vIE1hbnVhbGx5IHZhbGlkYXRlIFByb3BUeXBlcyAtIFJlYWN0IDE5IGJyZWFraW5nIGNoYW5nZVxuICAgIFByb3BUeXBlcy5jaGVja1Byb3BUeXBlcyhFcnJvckJvdW5kYXJ5LnByb3BUeXBlcywgdGhpcy5wcm9wcywgJ3Byb3AnLCAnRXJyb3JCb3VuZGFyeScpO1xuICB9XG5cbiAgc2hvdWxkQ29tcG9uZW50VXBkYXRlKG5leHRQcm9wcywgbmV4dFN0YXRlKSB7XG4gICAgaWYgKHRoaXMucHJvcHMuc2hvd0JhY2t1cCkge1xuICAgICAgcmV0dXJuIChcbiAgICAgICAgdGhpcy5zdGF0ZS5lcnJvck1lc3NhZ2UgIT09IG5leHRTdGF0ZS5lcnJvck1lc3NhZ2UgfHwgdGhpcy5zdGF0ZS5iYWNrdXAgIT09IG5leHRTdGF0ZS5iYWNrdXBcbiAgICAgICk7XG4gICAgfVxuICAgIHJldHVybiB0cnVlO1xuICB9XG5cbiAgYXN5bmMgY29tcG9uZW50RGlkVXBkYXRlKCkge1xuICAgIGlmICh0aGlzLnByb3BzLnNob3dCYWNrdXApIHtcbiAgICAgIGNvbnN0IGJhY2t1cCA9IGF3YWl0IGxvY2FsRm9yYWdlLmdldEl0ZW0oJ2JhY2t1cCcpO1xuICAgICAgYmFja3VwICYmIGNvbnNvbGUubG9nKGJhY2t1cCk7XG4gICAgICB0aGlzLnNldFN0YXRlKHsgYmFja3VwIH0pO1xuICAgIH1cbiAgfVxuXG4gIHJlbmRlcigpIHtcbiAgICBjb25zdCB7IGhhc0Vycm9yLCBlcnJvck1lc3NhZ2UsIGJhY2t1cCwgZXJyb3JUaXRsZSB9ID0gdGhpcy5zdGF0ZTtcbiAgICBjb25zdCB7IHNob3dCYWNrdXAsIHQgfSA9IHRoaXMucHJvcHM7XG4gICAgaWYgKCFoYXNFcnJvcikge1xuICAgICAgcmV0dXJuIHRoaXMucHJvcHMuY2hpbGRyZW47XG4gICAgfVxuICAgIHJldHVybiAoXG4gICAgICA8RXJyb3JCb3VuZGFyeUNvbnRhaW5lcj5cbiAgICAgICAgPGgxPnt0KCd1aS5lcnJvckJvdW5kYXJ5LnRpdGxlJyl9PC9oMT5cbiAgICAgICAgPHA+XG4gICAgICAgICAgPHNwYW4+e3QoJ3VpLmVycm9yQm91bmRhcnkuZGV0YWlscycpfTwvc3Bhbj5cbiAgICAgICAgICA8YVxuICAgICAgICAgICAgaHJlZj17YnVpbGRJc3N1ZVVybCh7IHRpdGxlOiBlcnJvclRpdGxlLCBjb25maWc6IHRoaXMucHJvcHMuY29uZmlnIH0pfVxuICAgICAgICAgICAgdGFyZ2V0PVwiX2JsYW5rXCJcbiAgICAgICAgICAgIHJlbD1cIm5vb3BlbmVyIG5vcmVmZXJyZXJcIlxuICAgICAgICAgICAgZGF0YS10ZXN0aWQ9XCJpc3N1ZS11cmxcIlxuICAgICAgICAgID5cbiAgICAgICAgICAgIHt0KCd1aS5lcnJvckJvdW5kYXJ5LnJlcG9ydEl0Jyl9XG4gICAgICAgICAgPC9hPlxuICAgICAgICA8L3A+XG4gICAgICAgIDxwPlxuICAgICAgICAgIHt0KCd1aS5lcnJvckJvdW5kYXJ5LnByaXZhY3lXYXJuaW5nJylcbiAgICAgICAgICAgIC5zcGxpdCgnXFxuJylcbiAgICAgICAgICAgIC5tYXAoKGl0ZW0sIGluZGV4KSA9PiAoXG4gICAgICAgICAgICAgIDw+XG4gICAgICAgICAgICAgICAgPFByaXZhY3lXYXJuaW5nIGtleT17aW5kZXh9PntpdGVtfTwvUHJpdmFjeVdhcm5pbmc+XG4gICAgICAgICAgICAgICAgPGJyIC8+XG4gICAgICAgICAgICAgIDwvPlxuICAgICAgICAgICAgKSl9XG4gICAgICAgIDwvcD5cbiAgICAgICAgPGhyIC8+XG4gICAgICAgIDxoMj57dCgndWkuZXJyb3JCb3VuZGFyeS5kZXRhaWxzSGVhZGluZycpfTwvaDI+XG4gICAgICAgIDxwPntlcnJvck1lc3NhZ2V9PC9wPlxuICAgICAgICB7YmFja3VwICYmIHNob3dCYWNrdXAgJiYgPFJlY292ZXJlZEVudHJ5IGVudHJ5PXtiYWNrdXB9IHQ9e3R9IC8+fVxuICAgICAgPC9FcnJvckJvdW5kYXJ5Q29udGFpbmVyPlxuICAgICk7XG4gIH1cbn1cblxuZXhwb3J0IGRlZmF1bHQgdHJhbnNsYXRlKCkoRXJyb3JCb3VuZGFyeSk7XG4iXX0= */"));
+const PrivacyWarning = /*#__PURE__*/_styled("span", {
+  target: "e4lz5aw1",
+  label: "PrivacyWarning"
+})("color:", colors.text, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+const CopyButton = /*#__PURE__*/_styled("button", {
+  target: "e4lz5aw0",
+  label: "CopyButton"
+})(buttons.button, ";", buttons.default, ";", buttons.gray, ";display:block;margin:12px 0;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+function RecoveredEntry({
+  entry,
+  t
+}) {
+  console.log(entry);
+  return ___EmotionJSX(React.Fragment, null, ___EmotionJSX("hr", null), ___EmotionJSX("h2", null, t('ui.errorBoundary.recoveredEntry.heading')), ___EmotionJSX("strong", null, t('ui.errorBoundary.recoveredEntry.warning')), ___EmotionJSX(CopyButton, {
+    onClick: () => copyToClipboard(entry)
+  }, t('ui.errorBoundary.recoveredEntry.copyButtonLabel')), ___EmotionJSX("pre", null, ___EmotionJSX("code", null, entry)));
+}
+export class ErrorBoundary extends React.Component {
+  static propTypes = {
+    children: PropTypes.node,
+    t: PropTypes.func.isRequired,
+    config: PropTypes.object.isRequired
+  };
+  state = {
+    hasError: false,
+    errorMessage: '',
+    errorTitle: '',
+    backup: ''
+  };
+  static getDerivedStateFromError(error) {
+    console.error(error);
+    return {
+      hasError: true,
+      errorMessage: cleanStack(error.stack, {
+        basePath: window.location.origin || ''
+      }),
+      errorTitle: error.toString()
+    };
+  }
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(ErrorBoundary.propTypes, this.props, 'prop', 'ErrorBoundary');
+  }
+  shouldComponentUpdate(nextProps, nextState) {
+    if (this.props.showBackup) {
+      return this.state.errorMessage !== nextState.errorMessage || this.state.backup !== nextState.backup;
+    }
+    return true;
+  }
+  async componentDidUpdate() {
+    if (this.props.showBackup) {
+      const backup = await localForage.getItem('backup');
+      backup && console.log(backup);
+      this.setState({
+        backup
+      });
+    }
+  }
+  render() {
+    const {
+      hasError,
+      errorMessage,
+      backup,
+      errorTitle
+    } = this.state;
+    const {
+      showBackup,
+      t
+    } = this.props;
+    if (!hasError) {
+      return this.props.children;
+    }
+    return ___EmotionJSX(ErrorBoundaryContainer, null, ___EmotionJSX("h1", null, t('ui.errorBoundary.title')), ___EmotionJSX("p", null, ___EmotionJSX("span", null, t('ui.errorBoundary.details')), ___EmotionJSX("a", {
+      href: buildIssueUrl({
+        title: errorTitle,
+        config: this.props.config
+      }),
+      target: "_blank",
+      rel: "noopener noreferrer",
+      "data-testid": "issue-url"
+    }, t('ui.errorBoundary.reportIt'))), ___EmotionJSX("p", null, t('ui.errorBoundary.privacyWarning').split('\n').map((item, index) => ___EmotionJSX(React.Fragment, null, ___EmotionJSX(PrivacyWarning, {
+      key: index
+    }, item), ___EmotionJSX("br", null)))), ___EmotionJSX("hr", null), ___EmotionJSX("h2", null, t('ui.errorBoundary.detailsHeading')), ___EmotionJSX("p", null, errorMessage), backup && showBackup && ___EmotionJSX(RecoveredEntry, {
+      entry: backup,
+      t: t
+    }));
+  }
+}
+export default translate()(ErrorBoundary);

package/dist/esm/components/UI/FileUploadButton.js

@@ -0,0 +1,27 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+export function FileUploadButton({
+  label,
+  imagesOnly,
+  onChange,
+  disabled,
+  className
+}) {
+  return ___EmotionJSX("label", {
+    tabIndex: '0',
+    className: `nc-fileUploadButton ${className || ''}`
+  }, ___EmotionJSX("span", null, label), ___EmotionJSX("input", {
+    type: "file",
+    accept: imagesOnly ? 'image/*' : '*/*',
+    onChange: onChange,
+    disabled: disabled
+  }));
+}
+FileUploadButton.propTypes = {
+  className: PropTypes.string,
+  label: PropTypes.string.isRequired,
+  imagesOnly: PropTypes.bool,
+  onChange: PropTypes.func.isRequired,
+  disabled: PropTypes.bool
+};

package/dist/esm/components/UI/Modal.js

@@ -0,0 +1,104 @@
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import { css, Global, ClassNames } from '@emotion/react';
+import ReactModal from 'react-modal';
+import { transitions, shadows, lengths, zIndex } from 'decap-cms-ui-default';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "1o9c9d2-ReactModalGlobalStyles",
+  styles: ".ReactModal__Body--open{overflow:hidden;};label:ReactModalGlobalStyles;"
+} : {
+  name: "1o9c9d2-ReactModalGlobalStyles",
+  styles: ".ReactModal__Body--open{overflow:hidden;};label:ReactModalGlobalStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+function ReactModalGlobalStyles() {
+  return ___EmotionJSX(Global, {
+    styles: _ref
+  });
+}
+const styleStrings = {
+  modalBody: `
+    ${shadows.dropDeep};
+    background-color: #fff;
+    border-radius: ${lengths.borderRadius};
+    height: 80%;
+    text-align: center;
+    max-width: 2200px;
+    padding: 20px;
+
+    &:focus {
+      outline: none;
+    }
+  `,
+  overlay: `
+    z-index: ${zIndex.zIndex99999};
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    opacity: 0;
+    background-color: rgba(0, 0, 0, 0);
+    transition: background-color ${transitions.main}, opacity ${transitions.main};
+  `,
+  overlayAfterOpen: `
+    background-color: rgba(0, 0, 0, 0.6);
+    opacity: 1;
+  `,
+  overlayBeforeClose: `
+    background-color: rgba(0, 0, 0, 0);
+    opacity: 0;
+  `
+};
+export class Modal extends React.Component {
+  static propTypes = {
+    children: PropTypes.node.isRequired,
+    isOpen: PropTypes.bool.isRequired,
+    className: PropTypes.string,
+    onClose: PropTypes.func.isRequired
+  };
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(Modal.propTypes, this.props, 'prop', 'Modal');
+    ReactModal.setAppElement('#nc-root');
+  }
+  render() {
+    const {
+      isOpen,
+      children,
+      className,
+      onClose
+    } = this.props;
+    return ___EmotionJSX(React.Fragment, null, ___EmotionJSX(ReactModalGlobalStyles, null), ___EmotionJSX(ClassNames, null, ({
+      css,
+      cx
+    }) => ___EmotionJSX(ReactModal, {
+      isOpen: isOpen,
+      onRequestClose: onClose,
+      closeTimeoutMS: 300,
+      className: {
+        base: cx(css`
+                    ${styleStrings.modalBody};
+                  `, className),
+        afterOpen: '',
+        beforeClose: ''
+      },
+      overlayClassName: {
+        base: css`
+                  ${styleStrings.overlay};
+                `,
+        afterOpen: css`
+                  ${styleStrings.overlayAfterOpen};
+                `,
+        beforeClose: css`
+                  ${styleStrings.overlayBeforeClose};
+                `
+      }
+    }, children)));
+  }
+}