@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/bootstrap.js

@@ -0,0 +1,101 @@
+import './lib/polyfill';
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { Provider, connect } from 'react-redux';
+import { Route, Router } from 'react-router-dom';
+import { GlobalStyles } from 'decap-cms-ui-default';
+import { I18n } from 'react-polyglot';
+import { store } from './redux';
+import { history } from './routing/history';
+import { loadConfig } from './actions/config';
+import { authenticateUser } from './actions/auth';
+import { getPhrases } from './lib/phrases';
+import { selectLocale } from './reducers/config';
+import { ErrorBoundary } from './components/UI';
+import App from './components/App/App';
+import './components/EditorWidgets';
+import './mediaLibrary';
+import 'what-input';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const ROOT_ID = 'nc-root';
+function TranslatedApp({
+  locale,
+  config
+}) {
+  return ___EmotionJSX(I18n, {
+    locale: locale,
+    messages: getPhrases(locale)
+  }, ___EmotionJSX(ErrorBoundary, {
+    showBackup: true,
+    config: config
+  }, ___EmotionJSX(Router, {
+    history: history
+  }, ___EmotionJSX(Route, {
+    component: App
+  }))));
+}
+function mapDispatchToProps(state) {
+  return {
+    locale: selectLocale(state.config),
+    config: state.config
+  };
+}
+const ConnectedTranslatedApp = connect(mapDispatchToProps)(TranslatedApp);
+function bootstrap(opts = {}) {
+  const {
+    config
+  } = opts;
+
+  /**
+   * Log the version number.
+   */
+  if (typeof "3.9.1" === 'string') {
+    console.log(`decap-cms-core ${"3.9.1"}`);
+  }
+
+  /**
+   * Get DOM element where app will mount.
+   */
+  function getRoot() {
+    /**
+     * Return existing root if found.
+     */
+    const existingRoot = document.getElementById(ROOT_ID);
+    if (existingRoot) {
+      return existingRoot;
+    }
+
+    /**
+     * If no existing root, create and return a new root.
+     */
+    const newRoot = document.createElement('div');
+    newRoot.id = ROOT_ID;
+    document.body.appendChild(newRoot);
+    return newRoot;
+  }
+
+  /**
+   * Dispatch config to store if received. This config will be merged into
+   * config.yml if it exists, and any portion that produces a conflict will be
+   * overwritten.
+   */
+  store.dispatch(loadConfig(config, function onLoad() {
+    store.dispatch(authenticateUser());
+  }));
+
+  /**
+   * Create connected root component.
+   */
+  function Root() {
+    return ___EmotionJSX(React.Fragment, null, ___EmotionJSX(GlobalStyles, null), ___EmotionJSX(Provider, {
+      store: store
+    }, ___EmotionJSX(ConnectedTranslatedApp, null)));
+  }
+
+  /**
+   * Render application root.
+   */
+  const root = createRoot(getRoot());
+  root.render(___EmotionJSX(Root, null));
+}
+export default bootstrap;

package/dist/esm/components/App/App.js

@@ -0,0 +1,289 @@
+import _styled from "@emotion/styled/base";
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+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 PropTypes from 'prop-types';
+import React from 'react';
+import { translate } from 'react-polyglot';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import { connect } from 'react-redux';
+import { Route, Switch, Redirect } from 'react-router-dom';
+import TopBarProgress from 'react-topbar-progress-indicator';
+import { Loader, colors } from 'decap-cms-ui-default';
+import { loginUser, logoutUser } from '../../actions/auth';
+import { currentBackend } from '../../backend';
+import { createNewEntry } from '../../actions/collections';
+import { openMediaLibrary } from '../../actions/mediaLibrary';
+import MediaLibrary from '../MediaLibrary/MediaLibrary';
+import { Notifications } from '../UI';
+import { history } from '../../routing/history';
+import { SIMPLE, EDITORIAL_WORKFLOW } from '../../constants/publishModes';
+import Collection from '../Collection/Collection';
+import Workflow from '../Workflow/Workflow';
+import Editor from '../Editor/Editor';
+import NotFoundPage from './NotFoundPage';
+import Header from './Header';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+TopBarProgress.config({
+  barColors: {
+    0: colors.active,
+    '1.0': colors.active
+  },
+  shadowBlur: 0,
+  barThickness: 2
+});
+const AppMainContainer = /*#__PURE__*/_styled("div", {
+  target: "es2eyhy2",
+  label: "AppMainContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "y0stlg",
+  styles: "min-width:800px;max-width:1440px;margin:0 auto"
+} : {
+  name: "y0stlg",
+  styles: "min-width:800px;max-width:1440px;margin:0 auto/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/App/App.js"],"names":[],"mappings":"AAiCmC","file":"../../../../src/components/App/App.js","sourcesContent":["import PropTypes from 'prop-types';\nimport React from 'react';\nimport { translate } from 'react-polyglot';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { Route, Switch, Redirect } from 'react-router-dom';\nimport TopBarProgress from 'react-topbar-progress-indicator';\nimport { Loader, colors } from 'decap-cms-ui-default';\n\nimport { loginUser, logoutUser } from '../../actions/auth';\nimport { currentBackend } from '../../backend';\nimport { createNewEntry } from '../../actions/collections';\nimport { openMediaLibrary } from '../../actions/mediaLibrary';\nimport MediaLibrary from '../MediaLibrary/MediaLibrary';\nimport { Notifications } from '../UI';\nimport { history } from '../../routing/history';\nimport { SIMPLE, EDITORIAL_WORKFLOW } from '../../constants/publishModes';\nimport Collection from '../Collection/Collection';\nimport Workflow from '../Workflow/Workflow';\nimport Editor from '../Editor/Editor';\nimport NotFoundPage from './NotFoundPage';\nimport Header from './Header';\n\nTopBarProgress.config({\n  barColors: {\n    0: colors.active,\n    '1.0': colors.active,\n  },\n  shadowBlur: 0,\n  barThickness: 2,\n});\n\nconst AppMainContainer = styled.div`\n  min-width: 800px;\n  max-width: 1440px;\n  margin: 0 auto;\n`;\n\nconst ErrorContainer = styled.div`\n  margin: 20px;\n`;\n\nconst ErrorCodeBlock = styled.pre`\n  margin-left: 20px;\n  font-size: 15px;\n  line-height: 1.5;\n`;\n\nfunction getDefaultPath(collections) {\n  const first = collections.filter(collection => collection.get('hide') !== true).first();\n  if (first) {\n    return `/collections/${first.get('name')}`;\n  } else {\n    throw new Error('Could not find a non hidden collection');\n  }\n}\n\nfunction RouteInCollection({ collections, render, ...props }) {\n  const defaultPath = getDefaultPath(collections);\n  return (\n    <Route\n      {...props}\n      render={routeProps => {\n        const collectionExists = collections.get(routeProps.match.params.name);\n        return collectionExists ? render(routeProps) : <Redirect to={defaultPath} />;\n      }}\n    />\n  );\n}\n\nclass App extends React.Component {\n  static propTypes = {\n    auth: PropTypes.object.isRequired,\n    config: PropTypes.object.isRequired,\n    collections: ImmutablePropTypes.map.isRequired,\n    loginUser: PropTypes.func.isRequired,\n    logoutUser: PropTypes.func.isRequired,\n    user: PropTypes.object,\n    isFetching: PropTypes.bool.isRequired,\n    publishMode: PropTypes.oneOf([SIMPLE, EDITORIAL_WORKFLOW]),\n    siteId: PropTypes.string,\n    useMediaLibrary: PropTypes.bool,\n    openMediaLibrary: PropTypes.func.isRequired,\n    showMediaButton: PropTypes.bool,\n    t: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(App.propTypes, this.props, 'prop', 'App');\n  }\n\n  configError(config) {\n    const t = this.props.t;\n    return (\n      <ErrorContainer>\n        <h1>{t('app.app.errorHeader')}</h1>\n        <div>\n          <strong>{t('app.app.configErrors')}:</strong>\n          <ErrorCodeBlock>{config.error}</ErrorCodeBlock>\n          <span>{t('app.app.checkConfigYml')}</span>\n        </div>\n      </ErrorContainer>\n    );\n  }\n\n  handleLogin(credentials) {\n    this.props.loginUser(credentials);\n  }\n\n  authenticating() {\n    const { auth, t } = this.props;\n    const backend = currentBackend(this.props.config);\n\n    if (backend == null) {\n      return (\n        <div>\n          <h1>{t('app.app.waitingBackend')}</h1>\n        </div>\n      );\n    }\n\n    return (\n      <div>\n        <Notifications />\n        {React.createElement(backend.authComponent(), {\n          onLogin: this.handleLogin.bind(this),\n          error: auth.error,\n          inProgress: auth.isFetching,\n          siteId: this.props.config.backend.site_domain,\n          base_url: this.props.config.backend.base_url,\n          authEndpoint: this.props.config.backend.auth_endpoint,\n          config: this.props.config,\n          clearHash: () => history.replace('/'),\n          t,\n        })}\n      </div>\n    );\n  }\n\n  handleLinkClick(event, handler, ...args) {\n    event.preventDefault();\n    handler(...args);\n  }\n\n  render() {\n    const {\n      user,\n      config,\n      collections,\n      logoutUser,\n      isFetching,\n      publishMode,\n      useMediaLibrary,\n      openMediaLibrary,\n      t,\n      showMediaButton,\n    } = this.props;\n\n    if (config === null) {\n      return null;\n    }\n\n    if (config.error) {\n      return this.configError(config);\n    }\n\n    if (config.isFetching) {\n      return <Loader active>{t('app.app.loadingConfig')}</Loader>;\n    }\n\n    if (user == null) {\n      return this.authenticating(t);\n    }\n\n    const defaultPath = getDefaultPath(collections);\n    const hasWorkflow = publishMode === EDITORIAL_WORKFLOW;\n\n    return (\n      <>\n        <Notifications />\n        <Header\n          user={user}\n          collections={collections}\n          onCreateEntryClick={createNewEntry}\n          onLogoutClick={logoutUser}\n          openMediaLibrary={openMediaLibrary}\n          hasWorkflow={hasWorkflow}\n          displayUrl={config.display_url}\n          logoUrl={config.logo_url} // Deprecated, replaced by `logo.src`\n          logo={config.logo}\n          isTestRepo={config.backend.name === 'test-repo'}\n          showMediaButton={showMediaButton}\n        />\n        <AppMainContainer>\n          {isFetching && <TopBarProgress />}\n          <Switch>\n            <Redirect exact from=\"/\" to={defaultPath} />\n            <Redirect exact from=\"/search/\" to={defaultPath} />\n            <RouteInCollection\n              exact\n              collections={collections}\n              path=\"/collections/:name/search/\"\n              render={({ match }) => <Redirect to={`/collections/${match.params.name}`} />}\n            />\n            <Redirect\n              // This happens on Identity + Invite Only + External Provider email not matching\n              // the registered user\n              from=\"/error=access_denied&error_description=Signups+not+allowed+for+this+instance\"\n              to={defaultPath}\n            />\n            {hasWorkflow ? <Route path=\"/workflow\" component={Workflow} /> : null}\n            <RouteInCollection\n              exact\n              collections={collections}\n              path=\"/collections/:name\"\n              render={props => <Collection {...props} />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/new\"\n              collections={collections}\n              render={props => <Editor {...props} newRecord />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/entries/*\"\n              collections={collections}\n              render={props => <Editor {...props} />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/search/:searchTerm\"\n              collections={collections}\n              render={props => <Collection {...props} isSearchResults isSingleSearchResult />}\n            />\n            <RouteInCollection\n              collections={collections}\n              path=\"/collections/:name/filter/:filterTerm*\"\n              render={props => <Collection {...props} />}\n            />\n            <Route\n              path=\"/search/:searchTerm\"\n              render={props => <Collection {...props} isSearchResults />}\n            />\n            <RouteInCollection\n              path=\"/edit/:name/:entryName\"\n              collections={collections}\n              render={({ match }) => {\n                const { name, entryName } = match.params;\n                return <Redirect to={`/collections/${name}/entries/${entryName}`} />;\n              }}\n            />\n            <Route component={NotFoundPage} />\n          </Switch>\n          {useMediaLibrary ? <MediaLibrary /> : null}\n        </AppMainContainer>\n      </>\n    );\n  }\n}\n\nfunction mapStateToProps(state) {\n  const { auth, config, collections, globalUI, mediaLibrary } = state;\n  const user = auth.user;\n  const isFetching = globalUI.isFetching;\n  const publishMode = config.publish_mode;\n  const useMediaLibrary = !mediaLibrary.get('externalLibrary');\n  const showMediaButton = mediaLibrary.get('showMediaButton');\n  return {\n    auth,\n    config,\n    collections,\n    user,\n    isFetching,\n    publishMode,\n    showMediaButton,\n    useMediaLibrary,\n  };\n}\n\nconst mapDispatchToProps = {\n  openMediaLibrary,\n  loginUser,\n  logoutUser,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(translate()(App));\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const ErrorContainer = /*#__PURE__*/_styled("div", {
+  target: "es2eyhy1",
+  label: "ErrorContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "3zy121",
+  styles: "margin:20px"
+} : {
+  name: "3zy121",
+  styles: "margin:20px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/App/App.js"],"names":[],"mappings":"AAuCiC","file":"../../../../src/components/App/App.js","sourcesContent":["import PropTypes from 'prop-types';\nimport React from 'react';\nimport { translate } from 'react-polyglot';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { Route, Switch, Redirect } from 'react-router-dom';\nimport TopBarProgress from 'react-topbar-progress-indicator';\nimport { Loader, colors } from 'decap-cms-ui-default';\n\nimport { loginUser, logoutUser } from '../../actions/auth';\nimport { currentBackend } from '../../backend';\nimport { createNewEntry } from '../../actions/collections';\nimport { openMediaLibrary } from '../../actions/mediaLibrary';\nimport MediaLibrary from '../MediaLibrary/MediaLibrary';\nimport { Notifications } from '../UI';\nimport { history } from '../../routing/history';\nimport { SIMPLE, EDITORIAL_WORKFLOW } from '../../constants/publishModes';\nimport Collection from '../Collection/Collection';\nimport Workflow from '../Workflow/Workflow';\nimport Editor from '../Editor/Editor';\nimport NotFoundPage from './NotFoundPage';\nimport Header from './Header';\n\nTopBarProgress.config({\n  barColors: {\n    0: colors.active,\n    '1.0': colors.active,\n  },\n  shadowBlur: 0,\n  barThickness: 2,\n});\n\nconst AppMainContainer = styled.div`\n  min-width: 800px;\n  max-width: 1440px;\n  margin: 0 auto;\n`;\n\nconst ErrorContainer = styled.div`\n  margin: 20px;\n`;\n\nconst ErrorCodeBlock = styled.pre`\n  margin-left: 20px;\n  font-size: 15px;\n  line-height: 1.5;\n`;\n\nfunction getDefaultPath(collections) {\n  const first = collections.filter(collection => collection.get('hide') !== true).first();\n  if (first) {\n    return `/collections/${first.get('name')}`;\n  } else {\n    throw new Error('Could not find a non hidden collection');\n  }\n}\n\nfunction RouteInCollection({ collections, render, ...props }) {\n  const defaultPath = getDefaultPath(collections);\n  return (\n    <Route\n      {...props}\n      render={routeProps => {\n        const collectionExists = collections.get(routeProps.match.params.name);\n        return collectionExists ? render(routeProps) : <Redirect to={defaultPath} />;\n      }}\n    />\n  );\n}\n\nclass App extends React.Component {\n  static propTypes = {\n    auth: PropTypes.object.isRequired,\n    config: PropTypes.object.isRequired,\n    collections: ImmutablePropTypes.map.isRequired,\n    loginUser: PropTypes.func.isRequired,\n    logoutUser: PropTypes.func.isRequired,\n    user: PropTypes.object,\n    isFetching: PropTypes.bool.isRequired,\n    publishMode: PropTypes.oneOf([SIMPLE, EDITORIAL_WORKFLOW]),\n    siteId: PropTypes.string,\n    useMediaLibrary: PropTypes.bool,\n    openMediaLibrary: PropTypes.func.isRequired,\n    showMediaButton: PropTypes.bool,\n    t: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(App.propTypes, this.props, 'prop', 'App');\n  }\n\n  configError(config) {\n    const t = this.props.t;\n    return (\n      <ErrorContainer>\n        <h1>{t('app.app.errorHeader')}</h1>\n        <div>\n          <strong>{t('app.app.configErrors')}:</strong>\n          <ErrorCodeBlock>{config.error}</ErrorCodeBlock>\n          <span>{t('app.app.checkConfigYml')}</span>\n        </div>\n      </ErrorContainer>\n    );\n  }\n\n  handleLogin(credentials) {\n    this.props.loginUser(credentials);\n  }\n\n  authenticating() {\n    const { auth, t } = this.props;\n    const backend = currentBackend(this.props.config);\n\n    if (backend == null) {\n      return (\n        <div>\n          <h1>{t('app.app.waitingBackend')}</h1>\n        </div>\n      );\n    }\n\n    return (\n      <div>\n        <Notifications />\n        {React.createElement(backend.authComponent(), {\n          onLogin: this.handleLogin.bind(this),\n          error: auth.error,\n          inProgress: auth.isFetching,\n          siteId: this.props.config.backend.site_domain,\n          base_url: this.props.config.backend.base_url,\n          authEndpoint: this.props.config.backend.auth_endpoint,\n          config: this.props.config,\n          clearHash: () => history.replace('/'),\n          t,\n        })}\n      </div>\n    );\n  }\n\n  handleLinkClick(event, handler, ...args) {\n    event.preventDefault();\n    handler(...args);\n  }\n\n  render() {\n    const {\n      user,\n      config,\n      collections,\n      logoutUser,\n      isFetching,\n      publishMode,\n      useMediaLibrary,\n      openMediaLibrary,\n      t,\n      showMediaButton,\n    } = this.props;\n\n    if (config === null) {\n      return null;\n    }\n\n    if (config.error) {\n      return this.configError(config);\n    }\n\n    if (config.isFetching) {\n      return <Loader active>{t('app.app.loadingConfig')}</Loader>;\n    }\n\n    if (user == null) {\n      return this.authenticating(t);\n    }\n\n    const defaultPath = getDefaultPath(collections);\n    const hasWorkflow = publishMode === EDITORIAL_WORKFLOW;\n\n    return (\n      <>\n        <Notifications />\n        <Header\n          user={user}\n          collections={collections}\n          onCreateEntryClick={createNewEntry}\n          onLogoutClick={logoutUser}\n          openMediaLibrary={openMediaLibrary}\n          hasWorkflow={hasWorkflow}\n          displayUrl={config.display_url}\n          logoUrl={config.logo_url} // Deprecated, replaced by `logo.src`\n          logo={config.logo}\n          isTestRepo={config.backend.name === 'test-repo'}\n          showMediaButton={showMediaButton}\n        />\n        <AppMainContainer>\n          {isFetching && <TopBarProgress />}\n          <Switch>\n            <Redirect exact from=\"/\" to={defaultPath} />\n            <Redirect exact from=\"/search/\" to={defaultPath} />\n            <RouteInCollection\n              exact\n              collections={collections}\n              path=\"/collections/:name/search/\"\n              render={({ match }) => <Redirect to={`/collections/${match.params.name}`} />}\n            />\n            <Redirect\n              // This happens on Identity + Invite Only + External Provider email not matching\n              // the registered user\n              from=\"/error=access_denied&error_description=Signups+not+allowed+for+this+instance\"\n              to={defaultPath}\n            />\n            {hasWorkflow ? <Route path=\"/workflow\" component={Workflow} /> : null}\n            <RouteInCollection\n              exact\n              collections={collections}\n              path=\"/collections/:name\"\n              render={props => <Collection {...props} />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/new\"\n              collections={collections}\n              render={props => <Editor {...props} newRecord />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/entries/*\"\n              collections={collections}\n              render={props => <Editor {...props} />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/search/:searchTerm\"\n              collections={collections}\n              render={props => <Collection {...props} isSearchResults isSingleSearchResult />}\n            />\n            <RouteInCollection\n              collections={collections}\n              path=\"/collections/:name/filter/:filterTerm*\"\n              render={props => <Collection {...props} />}\n            />\n            <Route\n              path=\"/search/:searchTerm\"\n              render={props => <Collection {...props} isSearchResults />}\n            />\n            <RouteInCollection\n              path=\"/edit/:name/:entryName\"\n              collections={collections}\n              render={({ match }) => {\n                const { name, entryName } = match.params;\n                return <Redirect to={`/collections/${name}/entries/${entryName}`} />;\n              }}\n            />\n            <Route component={NotFoundPage} />\n          </Switch>\n          {useMediaLibrary ? <MediaLibrary /> : null}\n        </AppMainContainer>\n      </>\n    );\n  }\n}\n\nfunction mapStateToProps(state) {\n  const { auth, config, collections, globalUI, mediaLibrary } = state;\n  const user = auth.user;\n  const isFetching = globalUI.isFetching;\n  const publishMode = config.publish_mode;\n  const useMediaLibrary = !mediaLibrary.get('externalLibrary');\n  const showMediaButton = mediaLibrary.get('showMediaButton');\n  return {\n    auth,\n    config,\n    collections,\n    user,\n    isFetching,\n    publishMode,\n    showMediaButton,\n    useMediaLibrary,\n  };\n}\n\nconst mapDispatchToProps = {\n  openMediaLibrary,\n  loginUser,\n  logoutUser,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(translate()(App));\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const ErrorCodeBlock = /*#__PURE__*/_styled("pre", {
+  target: "es2eyhy0",
+  label: "ErrorCodeBlock"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1dps4tx",
+  styles: "margin-left:20px;font-size:15px;line-height:1.5"
+} : {
+  name: "1dps4tx",
+  styles: "margin-left:20px;font-size:15px;line-height:1.5/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/App/App.js"],"names":[],"mappings":"AA2CiC","file":"../../../../src/components/App/App.js","sourcesContent":["import PropTypes from 'prop-types';\nimport React from 'react';\nimport { translate } from 'react-polyglot';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { Route, Switch, Redirect } from 'react-router-dom';\nimport TopBarProgress from 'react-topbar-progress-indicator';\nimport { Loader, colors } from 'decap-cms-ui-default';\n\nimport { loginUser, logoutUser } from '../../actions/auth';\nimport { currentBackend } from '../../backend';\nimport { createNewEntry } from '../../actions/collections';\nimport { openMediaLibrary } from '../../actions/mediaLibrary';\nimport MediaLibrary from '../MediaLibrary/MediaLibrary';\nimport { Notifications } from '../UI';\nimport { history } from '../../routing/history';\nimport { SIMPLE, EDITORIAL_WORKFLOW } from '../../constants/publishModes';\nimport Collection from '../Collection/Collection';\nimport Workflow from '../Workflow/Workflow';\nimport Editor from '../Editor/Editor';\nimport NotFoundPage from './NotFoundPage';\nimport Header from './Header';\n\nTopBarProgress.config({\n  barColors: {\n    0: colors.active,\n    '1.0': colors.active,\n  },\n  shadowBlur: 0,\n  barThickness: 2,\n});\n\nconst AppMainContainer = styled.div`\n  min-width: 800px;\n  max-width: 1440px;\n  margin: 0 auto;\n`;\n\nconst ErrorContainer = styled.div`\n  margin: 20px;\n`;\n\nconst ErrorCodeBlock = styled.pre`\n  margin-left: 20px;\n  font-size: 15px;\n  line-height: 1.5;\n`;\n\nfunction getDefaultPath(collections) {\n  const first = collections.filter(collection => collection.get('hide') !== true).first();\n  if (first) {\n    return `/collections/${first.get('name')}`;\n  } else {\n    throw new Error('Could not find a non hidden collection');\n  }\n}\n\nfunction RouteInCollection({ collections, render, ...props }) {\n  const defaultPath = getDefaultPath(collections);\n  return (\n    <Route\n      {...props}\n      render={routeProps => {\n        const collectionExists = collections.get(routeProps.match.params.name);\n        return collectionExists ? render(routeProps) : <Redirect to={defaultPath} />;\n      }}\n    />\n  );\n}\n\nclass App extends React.Component {\n  static propTypes = {\n    auth: PropTypes.object.isRequired,\n    config: PropTypes.object.isRequired,\n    collections: ImmutablePropTypes.map.isRequired,\n    loginUser: PropTypes.func.isRequired,\n    logoutUser: PropTypes.func.isRequired,\n    user: PropTypes.object,\n    isFetching: PropTypes.bool.isRequired,\n    publishMode: PropTypes.oneOf([SIMPLE, EDITORIAL_WORKFLOW]),\n    siteId: PropTypes.string,\n    useMediaLibrary: PropTypes.bool,\n    openMediaLibrary: PropTypes.func.isRequired,\n    showMediaButton: PropTypes.bool,\n    t: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(App.propTypes, this.props, 'prop', 'App');\n  }\n\n  configError(config) {\n    const t = this.props.t;\n    return (\n      <ErrorContainer>\n        <h1>{t('app.app.errorHeader')}</h1>\n        <div>\n          <strong>{t('app.app.configErrors')}:</strong>\n          <ErrorCodeBlock>{config.error}</ErrorCodeBlock>\n          <span>{t('app.app.checkConfigYml')}</span>\n        </div>\n      </ErrorContainer>\n    );\n  }\n\n  handleLogin(credentials) {\n    this.props.loginUser(credentials);\n  }\n\n  authenticating() {\n    const { auth, t } = this.props;\n    const backend = currentBackend(this.props.config);\n\n    if (backend == null) {\n      return (\n        <div>\n          <h1>{t('app.app.waitingBackend')}</h1>\n        </div>\n      );\n    }\n\n    return (\n      <div>\n        <Notifications />\n        {React.createElement(backend.authComponent(), {\n          onLogin: this.handleLogin.bind(this),\n          error: auth.error,\n          inProgress: auth.isFetching,\n          siteId: this.props.config.backend.site_domain,\n          base_url: this.props.config.backend.base_url,\n          authEndpoint: this.props.config.backend.auth_endpoint,\n          config: this.props.config,\n          clearHash: () => history.replace('/'),\n          t,\n        })}\n      </div>\n    );\n  }\n\n  handleLinkClick(event, handler, ...args) {\n    event.preventDefault();\n    handler(...args);\n  }\n\n  render() {\n    const {\n      user,\n      config,\n      collections,\n      logoutUser,\n      isFetching,\n      publishMode,\n      useMediaLibrary,\n      openMediaLibrary,\n      t,\n      showMediaButton,\n    } = this.props;\n\n    if (config === null) {\n      return null;\n    }\n\n    if (config.error) {\n      return this.configError(config);\n    }\n\n    if (config.isFetching) {\n      return <Loader active>{t('app.app.loadingConfig')}</Loader>;\n    }\n\n    if (user == null) {\n      return this.authenticating(t);\n    }\n\n    const defaultPath = getDefaultPath(collections);\n    const hasWorkflow = publishMode === EDITORIAL_WORKFLOW;\n\n    return (\n      <>\n        <Notifications />\n        <Header\n          user={user}\n          collections={collections}\n          onCreateEntryClick={createNewEntry}\n          onLogoutClick={logoutUser}\n          openMediaLibrary={openMediaLibrary}\n          hasWorkflow={hasWorkflow}\n          displayUrl={config.display_url}\n          logoUrl={config.logo_url} // Deprecated, replaced by `logo.src`\n          logo={config.logo}\n          isTestRepo={config.backend.name === 'test-repo'}\n          showMediaButton={showMediaButton}\n        />\n        <AppMainContainer>\n          {isFetching && <TopBarProgress />}\n          <Switch>\n            <Redirect exact from=\"/\" to={defaultPath} />\n            <Redirect exact from=\"/search/\" to={defaultPath} />\n            <RouteInCollection\n              exact\n              collections={collections}\n              path=\"/collections/:name/search/\"\n              render={({ match }) => <Redirect to={`/collections/${match.params.name}`} />}\n            />\n            <Redirect\n              // This happens on Identity + Invite Only + External Provider email not matching\n              // the registered user\n              from=\"/error=access_denied&error_description=Signups+not+allowed+for+this+instance\"\n              to={defaultPath}\n            />\n            {hasWorkflow ? <Route path=\"/workflow\" component={Workflow} /> : null}\n            <RouteInCollection\n              exact\n              collections={collections}\n              path=\"/collections/:name\"\n              render={props => <Collection {...props} />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/new\"\n              collections={collections}\n              render={props => <Editor {...props} newRecord />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/entries/*\"\n              collections={collections}\n              render={props => <Editor {...props} />}\n            />\n            <RouteInCollection\n              path=\"/collections/:name/search/:searchTerm\"\n              collections={collections}\n              render={props => <Collection {...props} isSearchResults isSingleSearchResult />}\n            />\n            <RouteInCollection\n              collections={collections}\n              path=\"/collections/:name/filter/:filterTerm*\"\n              render={props => <Collection {...props} />}\n            />\n            <Route\n              path=\"/search/:searchTerm\"\n              render={props => <Collection {...props} isSearchResults />}\n            />\n            <RouteInCollection\n              path=\"/edit/:name/:entryName\"\n              collections={collections}\n              render={({ match }) => {\n                const { name, entryName } = match.params;\n                return <Redirect to={`/collections/${name}/entries/${entryName}`} />;\n              }}\n            />\n            <Route component={NotFoundPage} />\n          </Switch>\n          {useMediaLibrary ? <MediaLibrary /> : null}\n        </AppMainContainer>\n      </>\n    );\n  }\n}\n\nfunction mapStateToProps(state) {\n  const { auth, config, collections, globalUI, mediaLibrary } = state;\n  const user = auth.user;\n  const isFetching = globalUI.isFetching;\n  const publishMode = config.publish_mode;\n  const useMediaLibrary = !mediaLibrary.get('externalLibrary');\n  const showMediaButton = mediaLibrary.get('showMediaButton');\n  return {\n    auth,\n    config,\n    collections,\n    user,\n    isFetching,\n    publishMode,\n    showMediaButton,\n    useMediaLibrary,\n  };\n}\n\nconst mapDispatchToProps = {\n  openMediaLibrary,\n  loginUser,\n  logoutUser,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(translate()(App));\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+function getDefaultPath(collections) {
+  const first = collections.filter(collection => collection.get('hide') !== true).first();
+  if (first) {
+    return `/collections/${first.get('name')}`;
+  } else {
+    throw new Error('Could not find a non hidden collection');
+  }
+}
+function RouteInCollection({
+  collections,
+  render,
+  ...props
+}) {
+  const defaultPath = getDefaultPath(collections);
+  return ___EmotionJSX(Route, _extends({}, props, {
+    render: routeProps => {
+      const collectionExists = collections.get(routeProps.match.params.name);
+      return collectionExists ? render(routeProps) : ___EmotionJSX(Redirect, {
+        to: defaultPath
+      });
+    }
+  }));
+}
+class App extends React.Component {
+  static propTypes = {
+    auth: PropTypes.object.isRequired,
+    config: PropTypes.object.isRequired,
+    collections: ImmutablePropTypes.map.isRequired,
+    loginUser: PropTypes.func.isRequired,
+    logoutUser: PropTypes.func.isRequired,
+    user: PropTypes.object,
+    isFetching: PropTypes.bool.isRequired,
+    publishMode: PropTypes.oneOf([SIMPLE, EDITORIAL_WORKFLOW]),
+    siteId: PropTypes.string,
+    useMediaLibrary: PropTypes.bool,
+    openMediaLibrary: PropTypes.func.isRequired,
+    showMediaButton: PropTypes.bool,
+    t: PropTypes.func.isRequired
+  };
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(App.propTypes, this.props, 'prop', 'App');
+  }
+  configError(config) {
+    const t = this.props.t;
+    return ___EmotionJSX(ErrorContainer, null, ___EmotionJSX("h1", null, t('app.app.errorHeader')), ___EmotionJSX("div", null, ___EmotionJSX("strong", null, t('app.app.configErrors'), ":"), ___EmotionJSX(ErrorCodeBlock, null, config.error), ___EmotionJSX("span", null, t('app.app.checkConfigYml'))));
+  }
+  handleLogin(credentials) {
+    this.props.loginUser(credentials);
+  }
+  authenticating() {
+    const {
+      auth,
+      t
+    } = this.props;
+    const backend = currentBackend(this.props.config);
+    if (backend == null) {
+      return ___EmotionJSX("div", null, ___EmotionJSX("h1", null, t('app.app.waitingBackend')));
+    }
+    return ___EmotionJSX("div", null, ___EmotionJSX(Notifications, null), /*#__PURE__*/React.createElement(backend.authComponent(), {
+      onLogin: this.handleLogin.bind(this),
+      error: auth.error,
+      inProgress: auth.isFetching,
+      siteId: this.props.config.backend.site_domain,
+      base_url: this.props.config.backend.base_url,
+      authEndpoint: this.props.config.backend.auth_endpoint,
+      config: this.props.config,
+      clearHash: () => history.replace('/'),
+      t
+    }));
+  }
+  handleLinkClick(event, handler, ...args) {
+    event.preventDefault();
+    handler(...args);
+  }
+  render() {
+    const {
+      user,
+      config,
+      collections,
+      logoutUser,
+      isFetching,
+      publishMode,
+      useMediaLibrary,
+      openMediaLibrary,
+      t,
+      showMediaButton
+    } = this.props;
+    if (config === null) {
+      return null;
+    }
+    if (config.error) {
+      return this.configError(config);
+    }
+    if (config.isFetching) {
+      return ___EmotionJSX(Loader, {
+        active: true
+      }, t('app.app.loadingConfig'));
+    }
+    if (user == null) {
+      return this.authenticating(t);
+    }
+    const defaultPath = getDefaultPath(collections);
+    const hasWorkflow = publishMode === EDITORIAL_WORKFLOW;
+    return ___EmotionJSX(React.Fragment, null, ___EmotionJSX(Notifications, null), ___EmotionJSX(Header, {
+      user: user,
+      collections: collections,
+      onCreateEntryClick: createNewEntry,
+      onLogoutClick: logoutUser,
+      openMediaLibrary: openMediaLibrary,
+      hasWorkflow: hasWorkflow,
+      displayUrl: config.display_url,
+      logoUrl: config.logo_url // Deprecated, replaced by `logo.src`
+      ,
+      logo: config.logo,
+      isTestRepo: config.backend.name === 'test-repo',
+      showMediaButton: showMediaButton
+    }), ___EmotionJSX(AppMainContainer, null, isFetching && ___EmotionJSX(TopBarProgress, null), ___EmotionJSX(Switch, null, ___EmotionJSX(Redirect, {
+      exact: true,
+      from: "/",
+      to: defaultPath
+    }), ___EmotionJSX(Redirect, {
+      exact: true,
+      from: "/search/",
+      to: defaultPath
+    }), ___EmotionJSX(RouteInCollection, {
+      exact: true,
+      collections: collections,
+      path: "/collections/:name/search/",
+      render: ({
+        match
+      }) => ___EmotionJSX(Redirect, {
+        to: `/collections/${match.params.name}`
+      })
+    }), ___EmotionJSX(Redirect
+    // This happens on Identity + Invite Only + External Provider email not matching
+    // the registered user
+    , {
+      from: "/error=access_denied&error_description=Signups+not+allowed+for+this+instance",
+      to: defaultPath
+    }), hasWorkflow ? ___EmotionJSX(Route, {
+      path: "/workflow",
+      component: Workflow
+    }) : null, ___EmotionJSX(RouteInCollection, {
+      exact: true,
+      collections: collections,
+      path: "/collections/:name",
+      render: props => ___EmotionJSX(Collection, props)
+    }), ___EmotionJSX(RouteInCollection, {
+      path: "/collections/:name/new",
+      collections: collections,
+      render: props => ___EmotionJSX(Editor, _extends({}, props, {
+        newRecord: true
+      }))
+    }), ___EmotionJSX(RouteInCollection, {
+      path: "/collections/:name/entries/*",
+      collections: collections,
+      render: props => ___EmotionJSX(Editor, props)
+    }), ___EmotionJSX(RouteInCollection, {
+      path: "/collections/:name/search/:searchTerm",
+      collections: collections,
+      render: props => ___EmotionJSX(Collection, _extends({}, props, {
+        isSearchResults: true,
+        isSingleSearchResult: true
+      }))
+    }), ___EmotionJSX(RouteInCollection, {
+      collections: collections,
+      path: "/collections/:name/filter/:filterTerm*",
+      render: props => ___EmotionJSX(Collection, props)
+    }), ___EmotionJSX(Route, {
+      path: "/search/:searchTerm",
+      render: props => ___EmotionJSX(Collection, _extends({}, props, {
+        isSearchResults: true
+      }))
+    }), ___EmotionJSX(RouteInCollection, {
+      path: "/edit/:name/:entryName",
+      collections: collections,
+      render: ({
+        match
+      }) => {
+        const {
+          name,
+          entryName
+        } = match.params;
+        return ___EmotionJSX(Redirect, {
+          to: `/collections/${name}/entries/${entryName}`
+        });
+      }
+    }), ___EmotionJSX(Route, {
+      component: NotFoundPage
+    })), useMediaLibrary ? ___EmotionJSX(MediaLibrary, null) : null));
+  }
+}
+function mapStateToProps(state) {
+  const {
+    auth,
+    config,
+    collections,
+    globalUI,
+    mediaLibrary
+  } = state;
+  const user = auth.user;
+  const isFetching = globalUI.isFetching;
+  const publishMode = config.publish_mode;
+  const useMediaLibrary = !mediaLibrary.get('externalLibrary');
+  const showMediaButton = mediaLibrary.get('showMediaButton');
+  return {
+    auth,
+    config,
+    collections,
+    user,
+    isFetching,
+    publishMode,
+    showMediaButton,
+    useMediaLibrary
+  };
+}
+const mapDispatchToProps = {
+  openMediaLibrary,
+  loginUser,
+  logoutUser
+};
+export default connect(mapStateToProps, mapDispatchToProps)(translate()(App));