@krashnakant/next-keycloak/dist/next-keycloak.cjs.development.cjs

An authentication library based on Keycloak for NextJs applications

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var React = require('react');

const isServer = () => typeof window === 'undefined';
const getUserFromToken = token => {
  const parsedToken = parseToken(token);
  return {
    sub: parsedToken.sub,
    email: parsedToken.email,
    name: parsedToken.given_name,
    family: parsedToken.family_name
  };
};
const parseToken = token => {
  const base64Url = token.split('.')[1];
  const base64 = base64Url.replace('-', '+').replace('_', '/');
  const converted = decodeURIComponent(atob(base64).split('').map(function (c) {
    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
  }).join(''));
  return JSON.parse(converted);
};

const useInitKeycloak = (keycloakInstance, initOption = {}) => {
  const [keycloak, setKeycloak] = React.useState();
  React.useEffect(() => {
    if (keycloakInstance) {
      initialize();
    }
  }, []);
  const initialize = async () => {
    try {
      await keycloakInstance.init(initOption);
      setKeycloak(keycloakInstance);
    } catch (e) {
      console.error('failed to initialize keycloak');
    }
  };
  const login = option => {
    if (keycloak) {
      return keycloak.login(option);
    }
    return undefined;
  };
  const logout = option => {
    if (keycloak !== undefined) {
      return keycloak.logout(option);
    }
    return undefined;
  };
  const register = option => {
    if (keycloak) {
      return keycloak.register(option);
    }
    return undefined;
  };
  const accountManagement = () => {
    if (keycloak) {
      return keycloak.accountManagement();
    }
    return undefined;
  };
  const hasRealmRole = role => {
    if (keycloak) {
      return keycloak.hasRealmRole(role);
    }
    return false;
  };
  return {
    loading: !(keycloak != null && keycloak.authenticated && keycloak.token !== undefined),
    token: keycloak ? keycloak.token : '',
    authenticated: keycloak ? Boolean(keycloak.authenticated) : false,
    userInfo: keycloak != null && keycloak.authenticated ? getUserFromToken(String(keycloak.token)) : undefined,
    login,
    logout,
    register,
    hasRealmRole,
    accountManagement
  };
};

const Keycloak = ! /*#__PURE__*/isServer() ? /*#__PURE__*/require("keycloak-js") : null;
let keycloakInstance = Keycloak;
const getKeycloakInstance = keycloakConfig => {
  const isServerSide = isServer();
  if (isServerSide) {
    return undefined;
  }
  keycloakInstance = typeof Keycloak.default === 'function' ? new Keycloak.default(keycloakConfig) : new Keycloak(keycloakConfig);
  return keycloakInstance;
};

const NextKeycloakAuthContext = /*#__PURE__*/React.createContext({
  loading: true,
  authenticated: false,
  login: _option => {},
  logout: _option => {},
  register: _option => {},
  hasRealmRole: _option => false,
  accountManagement: () => {}
});

const NextKeycloakAuthProvider = ({
  children,
  config,
  initOption
}) => {
  const keycloak = React.useMemo(() => {
    return getKeycloakInstance(config);
  }, [config]);
  const initializedKeycloak = useInitKeycloak(keycloak, initOption);
  return /*#__PURE__*/React.createElement(NextKeycloakAuthContext.Provider, {
    value: initializedKeycloak
  }, children);
};

const useNextKeycloakAuth = () => React.useContext(NextKeycloakAuthContext);

exports.NextKeycloakAuthProvider = NextKeycloakAuthProvider;
exports.useNextKeycloakAuth = useNextKeycloakAuth;
//# sourceMappingURL=next-keycloak.cjs.development.cjs.map