decap-cms-backend-forgejo 3.4.0

package/dist/esm/AuthenticationPage.js

@@ -0,0 +1,233 @@
+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 { PkceAuthenticator } from 'decap-cms-lib-auth';
+import { AuthenticationPage, Icon } from 'decap-cms-ui-default';
+import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+const LoginButtonIcon = /*#__PURE__*/_styled(Icon, {
+  target: "e1szyeam2",
+  label: "LoginButtonIcon"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1gnqu05",
+  styles: "margin-right:18px"
+} : {
+  name: "1gnqu05",
+  styles: "margin-right:18px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/AuthenticationPage.js"],"names":[],"mappings":"AAMoC","file":"../../src/AuthenticationPage.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport styled from '@emotion/styled';\nimport { PkceAuthenticator } from 'decap-cms-lib-auth';\nimport { AuthenticationPage, Icon } from 'decap-cms-ui-default';\n\nconst LoginButtonIcon = styled(Icon)`\n  margin-right: 18px;\n`;\n\nconst ForkApprovalContainer = styled.div`\n  display: flex;\n  flex-flow: column nowrap;\n  justify-content: space-around;\n  flex-grow: 0.2;\n`;\nconst ForkButtonsContainer = styled.div`\n  display: flex;\n  flex-flow: column nowrap;\n  justify-content: space-around;\n  align-items: center;\n`;\n\nexport default class ForgejoAuthenticationPage extends React.Component {\n  static propTypes = {\n    inProgress: PropTypes.bool,\n    config: PropTypes.object.isRequired,\n    onLogin: PropTypes.func.isRequired,\n    t: PropTypes.func.isRequired,\n    backend: PropTypes.object,\n  };\n\n  state = {};\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(\n      ForgejoAuthenticationPage.propTypes,\n      this.props,\n      'prop',\n      'ForgejoAuthenticationPage',\n    );\n\n    const { api_root, app_id = '' } = this.props.config.backend;\n    // Derive base_url from api_root by stripping the trailing /api/<version> path.\n    // Expected api_root format: https://<host>/api/v1\n    const base_url = api_root ? api_root.replace(/\\/api\\/[^/]+\\/?$/, '') : '';\n    if (!base_url) {\n      this.setState({\n        loginError: 'Forgejo backend requires \"api_root\" to be set in the backend configuration.',\n      });\n      return;\n    }\n    this.auth = new PkceAuthenticator({\n      base_url,\n      auth_endpoint: 'login/oauth/authorize',\n      app_id,\n      auth_token_endpoint: 'login/oauth/access_token',\n      auth_token_endpoint_content_type: 'application/json; charset=utf-8',\n    });\n    // Complete authentication if we were redirected back to from the provider.\n    this.auth.completeAuth((err, data) => {\n      if (err) {\n        this.setState({ loginError: err.toString() });\n        return;\n      } else if (data) {\n        const { open_authoring: openAuthoring = false } = this.props.config.backend;\n        if (openAuthoring) {\n          return this.loginWithOpenAuthoring(data)\n            .then(() => this.props.onLogin(data))\n            .catch(error => {\n              this.setState({\n                loginError: error && error.toString ? error.toString() : String(error),\n                findingFork: false,\n                requestingFork: false,\n              });\n            });\n        }\n        this.props.onLogin(data);\n      }\n    });\n  }\n\n  getPermissionToFork = () => {\n    return new Promise((resolve, reject) => {\n      this.setState({\n        requestingFork: true,\n        approveFork: () => {\n          this.setState({ requestingFork: false });\n          resolve();\n        },\n        refuseFork: () => {\n          this.setState({ requestingFork: false });\n          reject(new Error('User declined to create a fork'));\n        },\n      });\n    });\n  };\n\n  loginWithOpenAuthoring(data) {\n    const { backend } = this.props;\n\n    if (!backend) {\n      const error = new Error('Backend prop is required for open authoring login flow');\n      return Promise.reject(error);\n    }\n\n    this.setState({ findingFork: true });\n    return backend\n      .authenticateWithFork({ userData: data, getPermissionToFork: this.getPermissionToFork })\n      .catch(err => {\n        console.error(err);\n        throw err;\n      })\n      .finally(() => {\n        this.setState({\n          findingFork: false,\n          requestingFork: false,\n          approveFork: undefined,\n          refuseFork: undefined,\n        });\n      });\n  }\n\n  handleLogin = e => {\n    e.preventDefault();\n    if (!this.auth) {\n      return;\n    }\n    const { open_authoring: openAuthoring = false } = this.props.config.backend;\n    this.auth.authenticate({ scope: 'repository' }, (err, data) => {\n      if (err) {\n        this.setState({ loginError: err.toString() });\n        return;\n      }\n      if (openAuthoring) {\n        return this.loginWithOpenAuthoring(data)\n          .then(() => this.props.onLogin(data))\n          .catch(error => {\n            this.setState({\n              loginError: error && error.toString ? error.toString() : String(error),\n              findingFork: false,\n              requestingFork: false,\n            });\n          });\n      }\n      this.props.onLogin(data);\n    });\n  };\n\n  renderLoginButton = () => {\n    const { inProgress, t } = this.props;\n    return inProgress || this.state.findingFork ? (\n      t('auth.loggingIn')\n    ) : (\n      <React.Fragment>\n        <LoginButtonIcon type=\"forgejo\" />\n        {t('auth.loginWithForgejo')}\n      </React.Fragment>\n    );\n  };\n\n  getAuthenticationPageRenderArgs() {\n    const { requestingFork } = this.state;\n\n    if (requestingFork) {\n      const { approveFork, refuseFork } = this.state;\n      return {\n        renderPageContent: ({ LoginButton, TextButton, showAbortButton }) => (\n          <ForkApprovalContainer>\n            <p>\n              Open Authoring is enabled: we need to use a fork on your Forgejo account. (If a fork\n              already exists, we&apos;ll use that.)\n            </p>\n            <ForkButtonsContainer>\n              <LoginButton onClick={approveFork}>Fork the repo</LoginButton>\n              {showAbortButton && (\n                <TextButton onClick={refuseFork}>Don&apos;t fork the repo</TextButton>\n              )}\n            </ForkButtonsContainer>\n          </ForkApprovalContainer>\n        ),\n      };\n    }\n\n    return {\n      renderButtonContent: this.renderLoginButton,\n    };\n  }\n\n  render() {\n    const { config, t } = this.props;\n    const authenticationPageRenderArgs = this.getAuthenticationPageRenderArgs();\n    return (\n      <AuthenticationPage\n        onLogin={this.handleLogin}\n        loginDisabled={this.props.inProgress || this.state.findingFork || this.state.requestingFork}\n        loginErrorMessage={this.state.loginError}\n        logoUrl={config.logo_url} // Deprecated, replaced by `logo.src`\n        logo={config.logo}\n        siteUrl={config.site_url}\n        t={t}\n        {...authenticationPageRenderArgs}\n      />\n    );\n  }\n}\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const ForkApprovalContainer = /*#__PURE__*/_styled("div", {
+  target: "e1szyeam1",
+  label: "ForkApprovalContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "13alw87",
+  styles: "display:flex;flex-flow:column nowrap;justify-content:space-around;flex-grow:0.2"
+} : {
+  name: "13alw87",
+  styles: "display:flex;flex-flow:column nowrap;justify-content:space-around;flex-grow:0.2/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/AuthenticationPage.js"],"names":[],"mappings":"AAUwC","file":"../../src/AuthenticationPage.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport styled from '@emotion/styled';\nimport { PkceAuthenticator } from 'decap-cms-lib-auth';\nimport { AuthenticationPage, Icon } from 'decap-cms-ui-default';\n\nconst LoginButtonIcon = styled(Icon)`\n  margin-right: 18px;\n`;\n\nconst ForkApprovalContainer = styled.div`\n  display: flex;\n  flex-flow: column nowrap;\n  justify-content: space-around;\n  flex-grow: 0.2;\n`;\nconst ForkButtonsContainer = styled.div`\n  display: flex;\n  flex-flow: column nowrap;\n  justify-content: space-around;\n  align-items: center;\n`;\n\nexport default class ForgejoAuthenticationPage extends React.Component {\n  static propTypes = {\n    inProgress: PropTypes.bool,\n    config: PropTypes.object.isRequired,\n    onLogin: PropTypes.func.isRequired,\n    t: PropTypes.func.isRequired,\n    backend: PropTypes.object,\n  };\n\n  state = {};\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(\n      ForgejoAuthenticationPage.propTypes,\n      this.props,\n      'prop',\n      'ForgejoAuthenticationPage',\n    );\n\n    const { api_root, app_id = '' } = this.props.config.backend;\n    // Derive base_url from api_root by stripping the trailing /api/<version> path.\n    // Expected api_root format: https://<host>/api/v1\n    const base_url = api_root ? api_root.replace(/\\/api\\/[^/]+\\/?$/, '') : '';\n    if (!base_url) {\n      this.setState({\n        loginError: 'Forgejo backend requires \"api_root\" to be set in the backend configuration.',\n      });\n      return;\n    }\n    this.auth = new PkceAuthenticator({\n      base_url,\n      auth_endpoint: 'login/oauth/authorize',\n      app_id,\n      auth_token_endpoint: 'login/oauth/access_token',\n      auth_token_endpoint_content_type: 'application/json; charset=utf-8',\n    });\n    // Complete authentication if we were redirected back to from the provider.\n    this.auth.completeAuth((err, data) => {\n      if (err) {\n        this.setState({ loginError: err.toString() });\n        return;\n      } else if (data) {\n        const { open_authoring: openAuthoring = false } = this.props.config.backend;\n        if (openAuthoring) {\n          return this.loginWithOpenAuthoring(data)\n            .then(() => this.props.onLogin(data))\n            .catch(error => {\n              this.setState({\n                loginError: error && error.toString ? error.toString() : String(error),\n                findingFork: false,\n                requestingFork: false,\n              });\n            });\n        }\n        this.props.onLogin(data);\n      }\n    });\n  }\n\n  getPermissionToFork = () => {\n    return new Promise((resolve, reject) => {\n      this.setState({\n        requestingFork: true,\n        approveFork: () => {\n          this.setState({ requestingFork: false });\n          resolve();\n        },\n        refuseFork: () => {\n          this.setState({ requestingFork: false });\n          reject(new Error('User declined to create a fork'));\n        },\n      });\n    });\n  };\n\n  loginWithOpenAuthoring(data) {\n    const { backend } = this.props;\n\n    if (!backend) {\n      const error = new Error('Backend prop is required for open authoring login flow');\n      return Promise.reject(error);\n    }\n\n    this.setState({ findingFork: true });\n    return backend\n      .authenticateWithFork({ userData: data, getPermissionToFork: this.getPermissionToFork })\n      .catch(err => {\n        console.error(err);\n        throw err;\n      })\n      .finally(() => {\n        this.setState({\n          findingFork: false,\n          requestingFork: false,\n          approveFork: undefined,\n          refuseFork: undefined,\n        });\n      });\n  }\n\n  handleLogin = e => {\n    e.preventDefault();\n    if (!this.auth) {\n      return;\n    }\n    const { open_authoring: openAuthoring = false } = this.props.config.backend;\n    this.auth.authenticate({ scope: 'repository' }, (err, data) => {\n      if (err) {\n        this.setState({ loginError: err.toString() });\n        return;\n      }\n      if (openAuthoring) {\n        return this.loginWithOpenAuthoring(data)\n          .then(() => this.props.onLogin(data))\n          .catch(error => {\n            this.setState({\n              loginError: error && error.toString ? error.toString() : String(error),\n              findingFork: false,\n              requestingFork: false,\n            });\n          });\n      }\n      this.props.onLogin(data);\n    });\n  };\n\n  renderLoginButton = () => {\n    const { inProgress, t } = this.props;\n    return inProgress || this.state.findingFork ? (\n      t('auth.loggingIn')\n    ) : (\n      <React.Fragment>\n        <LoginButtonIcon type=\"forgejo\" />\n        {t('auth.loginWithForgejo')}\n      </React.Fragment>\n    );\n  };\n\n  getAuthenticationPageRenderArgs() {\n    const { requestingFork } = this.state;\n\n    if (requestingFork) {\n      const { approveFork, refuseFork } = this.state;\n      return {\n        renderPageContent: ({ LoginButton, TextButton, showAbortButton }) => (\n          <ForkApprovalContainer>\n            <p>\n              Open Authoring is enabled: we need to use a fork on your Forgejo account. (If a fork\n              already exists, we&apos;ll use that.)\n            </p>\n            <ForkButtonsContainer>\n              <LoginButton onClick={approveFork}>Fork the repo</LoginButton>\n              {showAbortButton && (\n                <TextButton onClick={refuseFork}>Don&apos;t fork the repo</TextButton>\n              )}\n            </ForkButtonsContainer>\n          </ForkApprovalContainer>\n        ),\n      };\n    }\n\n    return {\n      renderButtonContent: this.renderLoginButton,\n    };\n  }\n\n  render() {\n    const { config, t } = this.props;\n    const authenticationPageRenderArgs = this.getAuthenticationPageRenderArgs();\n    return (\n      <AuthenticationPage\n        onLogin={this.handleLogin}\n        loginDisabled={this.props.inProgress || this.state.findingFork || this.state.requestingFork}\n        loginErrorMessage={this.state.loginError}\n        logoUrl={config.logo_url} // Deprecated, replaced by `logo.src`\n        logo={config.logo}\n        siteUrl={config.site_url}\n        t={t}\n        {...authenticationPageRenderArgs}\n      />\n    );\n  }\n}\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const ForkButtonsContainer = /*#__PURE__*/_styled("div", {
+  target: "e1szyeam0",
+  label: "ForkButtonsContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "125bg8c",
+  styles: "display:flex;flex-flow:column nowrap;justify-content:space-around;align-items:center"
+} : {
+  name: "125bg8c",
+  styles: "display:flex;flex-flow:column nowrap;justify-content:space-around;align-items:center/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/AuthenticationPage.js"],"names":[],"mappings":"AAgBuC","file":"../../src/AuthenticationPage.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport styled from '@emotion/styled';\nimport { PkceAuthenticator } from 'decap-cms-lib-auth';\nimport { AuthenticationPage, Icon } from 'decap-cms-ui-default';\n\nconst LoginButtonIcon = styled(Icon)`\n  margin-right: 18px;\n`;\n\nconst ForkApprovalContainer = styled.div`\n  display: flex;\n  flex-flow: column nowrap;\n  justify-content: space-around;\n  flex-grow: 0.2;\n`;\nconst ForkButtonsContainer = styled.div`\n  display: flex;\n  flex-flow: column nowrap;\n  justify-content: space-around;\n  align-items: center;\n`;\n\nexport default class ForgejoAuthenticationPage extends React.Component {\n  static propTypes = {\n    inProgress: PropTypes.bool,\n    config: PropTypes.object.isRequired,\n    onLogin: PropTypes.func.isRequired,\n    t: PropTypes.func.isRequired,\n    backend: PropTypes.object,\n  };\n\n  state = {};\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(\n      ForgejoAuthenticationPage.propTypes,\n      this.props,\n      'prop',\n      'ForgejoAuthenticationPage',\n    );\n\n    const { api_root, app_id = '' } = this.props.config.backend;\n    // Derive base_url from api_root by stripping the trailing /api/<version> path.\n    // Expected api_root format: https://<host>/api/v1\n    const base_url = api_root ? api_root.replace(/\\/api\\/[^/]+\\/?$/, '') : '';\n    if (!base_url) {\n      this.setState({\n        loginError: 'Forgejo backend requires \"api_root\" to be set in the backend configuration.',\n      });\n      return;\n    }\n    this.auth = new PkceAuthenticator({\n      base_url,\n      auth_endpoint: 'login/oauth/authorize',\n      app_id,\n      auth_token_endpoint: 'login/oauth/access_token',\n      auth_token_endpoint_content_type: 'application/json; charset=utf-8',\n    });\n    // Complete authentication if we were redirected back to from the provider.\n    this.auth.completeAuth((err, data) => {\n      if (err) {\n        this.setState({ loginError: err.toString() });\n        return;\n      } else if (data) {\n        const { open_authoring: openAuthoring = false } = this.props.config.backend;\n        if (openAuthoring) {\n          return this.loginWithOpenAuthoring(data)\n            .then(() => this.props.onLogin(data))\n            .catch(error => {\n              this.setState({\n                loginError: error && error.toString ? error.toString() : String(error),\n                findingFork: false,\n                requestingFork: false,\n              });\n            });\n        }\n        this.props.onLogin(data);\n      }\n    });\n  }\n\n  getPermissionToFork = () => {\n    return new Promise((resolve, reject) => {\n      this.setState({\n        requestingFork: true,\n        approveFork: () => {\n          this.setState({ requestingFork: false });\n          resolve();\n        },\n        refuseFork: () => {\n          this.setState({ requestingFork: false });\n          reject(new Error('User declined to create a fork'));\n        },\n      });\n    });\n  };\n\n  loginWithOpenAuthoring(data) {\n    const { backend } = this.props;\n\n    if (!backend) {\n      const error = new Error('Backend prop is required for open authoring login flow');\n      return Promise.reject(error);\n    }\n\n    this.setState({ findingFork: true });\n    return backend\n      .authenticateWithFork({ userData: data, getPermissionToFork: this.getPermissionToFork })\n      .catch(err => {\n        console.error(err);\n        throw err;\n      })\n      .finally(() => {\n        this.setState({\n          findingFork: false,\n          requestingFork: false,\n          approveFork: undefined,\n          refuseFork: undefined,\n        });\n      });\n  }\n\n  handleLogin = e => {\n    e.preventDefault();\n    if (!this.auth) {\n      return;\n    }\n    const { open_authoring: openAuthoring = false } = this.props.config.backend;\n    this.auth.authenticate({ scope: 'repository' }, (err, data) => {\n      if (err) {\n        this.setState({ loginError: err.toString() });\n        return;\n      }\n      if (openAuthoring) {\n        return this.loginWithOpenAuthoring(data)\n          .then(() => this.props.onLogin(data))\n          .catch(error => {\n            this.setState({\n              loginError: error && error.toString ? error.toString() : String(error),\n              findingFork: false,\n              requestingFork: false,\n            });\n          });\n      }\n      this.props.onLogin(data);\n    });\n  };\n\n  renderLoginButton = () => {\n    const { inProgress, t } = this.props;\n    return inProgress || this.state.findingFork ? (\n      t('auth.loggingIn')\n    ) : (\n      <React.Fragment>\n        <LoginButtonIcon type=\"forgejo\" />\n        {t('auth.loginWithForgejo')}\n      </React.Fragment>\n    );\n  };\n\n  getAuthenticationPageRenderArgs() {\n    const { requestingFork } = this.state;\n\n    if (requestingFork) {\n      const { approveFork, refuseFork } = this.state;\n      return {\n        renderPageContent: ({ LoginButton, TextButton, showAbortButton }) => (\n          <ForkApprovalContainer>\n            <p>\n              Open Authoring is enabled: we need to use a fork on your Forgejo account. (If a fork\n              already exists, we&apos;ll use that.)\n            </p>\n            <ForkButtonsContainer>\n              <LoginButton onClick={approveFork}>Fork the repo</LoginButton>\n              {showAbortButton && (\n                <TextButton onClick={refuseFork}>Don&apos;t fork the repo</TextButton>\n              )}\n            </ForkButtonsContainer>\n          </ForkApprovalContainer>\n        ),\n      };\n    }\n\n    return {\n      renderButtonContent: this.renderLoginButton,\n    };\n  }\n\n  render() {\n    const { config, t } = this.props;\n    const authenticationPageRenderArgs = this.getAuthenticationPageRenderArgs();\n    return (\n      <AuthenticationPage\n        onLogin={this.handleLogin}\n        loginDisabled={this.props.inProgress || this.state.findingFork || this.state.requestingFork}\n        loginErrorMessage={this.state.loginError}\n        logoUrl={config.logo_url} // Deprecated, replaced by `logo.src`\n        logo={config.logo}\n        siteUrl={config.site_url}\n        t={t}\n        {...authenticationPageRenderArgs}\n      />\n    );\n  }\n}\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+export default class ForgejoAuthenticationPage extends React.Component {
+  static propTypes = {
+    inProgress: PropTypes.bool,
+    config: PropTypes.object.isRequired,
+    onLogin: PropTypes.func.isRequired,
+    t: PropTypes.func.isRequired,
+    backend: PropTypes.object
+  };
+  state = {};
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(ForgejoAuthenticationPage.propTypes, this.props, 'prop', 'ForgejoAuthenticationPage');
+    const {
+      api_root,
+      app_id = ''
+    } = this.props.config.backend;
+    // Derive base_url from api_root by stripping the trailing /api/<version> path.
+    // Expected api_root format: https://<host>/api/v1
+    const base_url = api_root ? api_root.replace(/\/api\/[^/]+\/?$/, '') : '';
+    if (!base_url) {
+      this.setState({
+        loginError: 'Forgejo backend requires "api_root" to be set in the backend configuration.'
+      });
+      return;
+    }
+    this.auth = new PkceAuthenticator({
+      base_url,
+      auth_endpoint: 'login/oauth/authorize',
+      app_id,
+      auth_token_endpoint: 'login/oauth/access_token',
+      auth_token_endpoint_content_type: 'application/json; charset=utf-8'
+    });
+    // Complete authentication if we were redirected back to from the provider.
+    this.auth.completeAuth((err, data) => {
+      if (err) {
+        this.setState({
+          loginError: err.toString()
+        });
+        return;
+      } else if (data) {
+        const {
+          open_authoring: openAuthoring = false
+        } = this.props.config.backend;
+        if (openAuthoring) {
+          return this.loginWithOpenAuthoring(data).then(() => this.props.onLogin(data)).catch(error => {
+            this.setState({
+              loginError: error && error.toString ? error.toString() : String(error),
+              findingFork: false,
+              requestingFork: false
+            });
+          });
+        }
+        this.props.onLogin(data);
+      }
+    });
+  }
+  getPermissionToFork = () => {
+    return new Promise((resolve, reject) => {
+      this.setState({
+        requestingFork: true,
+        approveFork: () => {
+          this.setState({
+            requestingFork: false
+          });
+          resolve();
+        },
+        refuseFork: () => {
+          this.setState({
+            requestingFork: false
+          });
+          reject(new Error('User declined to create a fork'));
+        }
+      });
+    });
+  };
+  loginWithOpenAuthoring(data) {
+    const {
+      backend
+    } = this.props;
+    if (!backend) {
+      const error = new Error('Backend prop is required for open authoring login flow');
+      return Promise.reject(error);
+    }
+    this.setState({
+      findingFork: true
+    });
+    return backend.authenticateWithFork({
+      userData: data,
+      getPermissionToFork: this.getPermissionToFork
+    }).catch(err => {
+      console.error(err);
+      throw err;
+    }).finally(() => {
+      this.setState({
+        findingFork: false,
+        requestingFork: false,
+        approveFork: undefined,
+        refuseFork: undefined
+      });
+    });
+  }
+  handleLogin = e => {
+    e.preventDefault();
+    if (!this.auth) {
+      return;
+    }
+    const {
+      open_authoring: openAuthoring = false
+    } = this.props.config.backend;
+    this.auth.authenticate({
+      scope: 'repository'
+    }, (err, data) => {
+      if (err) {
+        this.setState({
+          loginError: err.toString()
+        });
+        return;
+      }
+      if (openAuthoring) {
+        return this.loginWithOpenAuthoring(data).then(() => this.props.onLogin(data)).catch(error => {
+          this.setState({
+            loginError: error && error.toString ? error.toString() : String(error),
+            findingFork: false,
+            requestingFork: false
+          });
+        });
+      }
+      this.props.onLogin(data);
+    });
+  };
+  renderLoginButton = () => {
+    const {
+      inProgress,
+      t
+    } = this.props;
+    return inProgress || this.state.findingFork ? t('auth.loggingIn') : _jsxs(React.Fragment, {
+      children: [_jsx(LoginButtonIcon, {
+        type: "forgejo"
+      }), t('auth.loginWithForgejo')]
+    });
+  };
+  getAuthenticationPageRenderArgs() {
+    const {
+      requestingFork
+    } = this.state;
+    if (requestingFork) {
+      const {
+        approveFork,
+        refuseFork
+      } = this.state;
+      return {
+        renderPageContent: ({
+          LoginButton,
+          TextButton,
+          showAbortButton
+        }) => _jsxs(ForkApprovalContainer, {
+          children: [_jsx("p", {
+            children: "Open Authoring is enabled: we need to use a fork on your Forgejo account. (If a fork already exists, we'll use that.)"
+          }), _jsxs(ForkButtonsContainer, {
+            children: [_jsx(LoginButton, {
+              onClick: approveFork,
+              children: "Fork the repo"
+            }), showAbortButton && _jsx(TextButton, {
+              onClick: refuseFork,
+              children: "Don't fork the repo"
+            })]
+          })]
+        })
+      };
+    }
+    return {
+      renderButtonContent: this.renderLoginButton
+    };
+  }
+  render() {
+    const {
+      config,
+      t
+    } = this.props;
+    const authenticationPageRenderArgs = this.getAuthenticationPageRenderArgs();
+    return _jsx(AuthenticationPage, {
+      onLogin: this.handleLogin,
+      loginDisabled: this.props.inProgress || this.state.findingFork || this.state.requestingFork,
+      loginErrorMessage: this.state.loginError,
+      logoUrl: config.logo_url // Deprecated, replaced by `logo.src`
+      ,
+      logo: config.logo,
+      siteUrl: config.site_url,
+      t: t,
+      ...authenticationPageRenderArgs
+    });
+  }
+}