@react-keycloak-refork/ssr 5.0.0

package/LICENSE.md

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2019-present, Mattia Panzeri <mattia.panzeri93@gmail.com>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,261 @@
+![React Keycloak](/art/react-keycloak-logo.png?raw=true 'React Keycloak Logo')
+
+# React Keycloak <!-- omit in toc -->
+
+> SSR bindings for [Keycloak](https://www.keycloak.org/). Fork of https://github.com/react-keycloak/react-keycloak.git with updated packages for Keycloak >=26 support.
+
+[![NPM (scoped)](https://img.shields.io/npm/v/@react-keycloak-fork/ssr?label=npm%20%7C%20ssr)](https://www.npmjs.com/package/@react-keycloak-fork/ssr)
+
+[![License](https://img.shields.io/github/license/react-keycloak/react-keycloak.svg)](https://github.com/react-keycloak/react-keycloak/blob/master/LICENSE.md)
+[![lerna](https://img.shields.io/badge/maintained%20with-lerna-cc00ff.svg)](https://lerna.js.org/)
+[![GitHub contributors](https://img.shields.io/github/contributors/react-keycloak/react-keycloak)](https://github.com/react-keycloak/react-keycloak/graphs/contributors)
+[![Github Issues](https://img.shields.io/github/issues/react-keycloak/react-keycloak.svg)](https://github.com/react-keycloak/react-keycloak/issues)
+
+[![Gitter](https://img.shields.io/gitter/room/react-keycloak/community)](https://gitter.im/react-keycloak/community)
+
+---
+
+## Table of Contents <!-- omit in toc -->
+
+- [Install](#install)
+- [Getting Started](#getting-started)
+  - [Setup](#setup)
+    - [NextJS](#nextjs)
+    - [Razzle](#razzle)
+  - [Hook Usage](#hook-usage)
+- [Examples](#examples)
+- [Guides and Articles](#guides-and-articles)
+- [Other Resources](#other-resources)
+  - [Securing NextJS API](#securing-nextjs-api)
+  - [External Usage (Advanced)](#external-usage-advanced)
+- [Alternatives](#alternatives)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Install
+
+React Keycloak requires:
+
+- React **16.8** or later
+- `keycloak-js` **9.0.2** or later
+
+```shell
+yarn add @react-keycloak-refork/ssr
+```
+
+or
+
+```shell
+npm install --save @react-keycloak-refork/ssr
+```
+
+## Getting Started
+
+This module has been created to support `NextJS` and `Razzle`, other SSR frameworks might be working as well.
+
+### Setup
+
+Follow the guide related to your SSR Framework and note that `SSRKeycloakProvider` also accepts all the properties of [`KeycloakProvider`](https://github.com/react-keycloak/react-keycloak/blob/master/packages/web/README.md#setup-keycloakprovider).
+
+#### NextJS
+
+Requires NextJS **9** or later
+
+Create the `_app.tsx` file under `pages` folder and wrap your App inside `SSRKeycloakProvider` component and pass `keycloakConfig` and a `TokenPersistor`.
+
+**Note:** `@react-keycloak-refork/ssr` provides a default `TokenPersistor` which works with `cookies` (exported as `ServerPersistors.SSRCookies`).
+
+The following examples will be based on that.
+
+```tsx
+import cookie from 'cookie'
+import * as React from 'react'
+import type { IncomingMessage } from 'http'
+import type { AppProps, AppContext } from 'next/app'
+
+import { SSRKeycloakProvider, SSRCookies } from '@react-keycloak-refork/ssr'
+
+const keycloakCfg = {
+  realm: '',
+  url: '',
+  clientId: '',
+}
+
+interface InitialProps {
+  cookies: unknown
+}
+
+function MyApp({ Component, pageProps, cookies }: AppProps & InitialProps) {
+  return (
+    <SSRKeycloakProvider
+      keycloakConfig={keycloakCfg}
+      persistor={SSRCookies(cookies)}
+    >
+      <Component {...pageProps} />
+    </SSRKeycloakProvider>
+  )
+}
+
+function parseCookies(req: IncomingMessage) {
+  return cookie.parse(req.headers.cookie || '')
+}
+
+MyApp.getInitialProps = async (context: AppContext) => {
+  // Extract cookies from AppContext
+  return {
+    cookies: context.ctx.req ? parseCookies(context.ctx.req) : {},
+  }
+}
+
+export default MyApp
+```
+
+#### Razzle
+
+Requires `Razzle` **3** or later
+
+> **N.B:** This setup requires you to install [`cookie-parser`](https://github.com/expressjs/cookie-parser) middleware.
+
+Edit your app `server.js` as follow
+
+```js
+...
+
+import { ExpressCookies, SSRKeycloakProvider } from '@react-keycloak-refork/ssr'
+
+// Create a function to retrieve Keycloak configuration parameters -- 'see examples/razzle-app'
+import { getKeycloakConfig } from './utils'
+
+const assets = require(process.env.RAZZLE_ASSETS_MANIFEST)
+
+const server = express()
+server
+  .disable('x-powered-by')
+  .use(express.static(process.env.RAZZLE_PUBLIC_DIR))
+  .use(cookieParser()) // 1. Add cookieParser Express middleware
+  .get('/*', (req, res) => {
+    const context = {}
+
+    // 2. Create an instance of ExpressCookies passing the current request
+    const cookiePersistor = ExpressCookies(req)
+
+    // 3. Wrap the App inside SSRKeycloakProvider
+    const markup = renderToString(
+      <SSRKeycloakProvider
+        keycloakConfig={getKeycloakConfig()}
+        persistor={cookiePersistor}
+      >
+        <StaticRouter context={context} location={req.url}>
+          <App />
+        </StaticRouter>
+      </SSRKeycloakProvider>
+    )
+    ...
+  })
+
+...
+```
+
+Edit your `client.js` as follow
+
+```js
+import { Cookies, SSRKeycloakProvider } from '@react-keycloak-refork/ssr'
+
+// Create a function to retrieve Keycloak configuration parameters -- 'see examples/razzle-app'
+import { getKeycloakConfig } from './utils'
+
+// 1. Create an instance of Cookies
+const cookiePersistor = new Cookies()
+
+// 2. Wrap the App inside SSRKeycloakProvider
+hydrate(
+  <SSRKeycloakProvider
+    keycloakConfig={getKeycloakConfig()}
+    persistor={cookiePersistor}
+  >
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </SSRKeycloakProvider>,
+  document.getElementById('root')
+)
+...
+```
+
+### Hook Usage
+
+When a component requires access to `Keycloak`, you can use the `useKeycloak` Hook.
+
+```js
+import { useKeycloak } from '@react-keycloak-refork/ssr'
+
+export default () => {
+  const { keycloak, initialized } = useKeycloak()
+
+  // Here you can access the current keycloak instance methods and variables...
+
+  return (
+    <div>
+      <div>{`User is ${
+        !keycloak.authenticated ? 'NOT ' : ''
+      }authenticated`}</div>
+
+      {!!keycloak.authenticated && (
+        <button type="button" onClick={() => keycloak.logout()}>
+          Logout
+        </button>
+      )}
+    </div>
+  )
+}
+```
+
+## Examples
+
+See inside `examples/nextjs-app` and `examples/razzle-app` folders of [`@react-keycloak-fork/react-keycloak-examples`](https://github.com/react-keycloak/react-keycloak-examples) repository for sample implementations.
+
+## Guides and Articles
+
+- Migration guide for `@react-keycloak-refork/ssr` `v2.x to v3.x` can be found here [MIGRATION.md](https://github.com/react-keycloak/react-keycloak/blob/master/packages/ssr/MIGRATION.md).
+
+## Other Resources
+
+### Securing NextJS API
+
+Whilst `@react-keycloak-refork/ssr` can help you secure the Frontend part of a `NextJS` app if you also want to secure `NextJS`-exposed APIs you can follow the sample in [this issue](https://github.com/react-keycloak/react-keycloak/issues/44#issuecomment-579877959).
+
+Thanks to [@webdeb](https://github.com/webdeb) for reporting the issue and helping develop a solution.
+
+### External Usage (Advanced)
+
+If you need to access `keycloak` instance from non-`React` files (such as `sagas`, `utils`, `providers` ...), you can retrieve the instance using the exported `getKeycloakInstance()` method.
+
+The instance will be initialized by `react-keycloak` but you'll need to be carefull when using the instance, expecially server-side, and avoid setting/overriding any props, you can however freely access the exposed methods (such as `refreshToken`, `login`, etc...).
+
+**Note:** This approach is NOT recommended on the server-side because can lead to `token leakage` issues (see [this issue](https://github.com/react-keycloak/react-keycloak/issues/65) for more details).
+
+Thanks to [@webdeb](https://github.com/webdeb) for requesting this feature and helping develop and test the solution.
+
+## Alternatives
+
+If you need to connect using a more generic OIDC client instead of `keycloak.js`, consider using one of the following libraries:
+
+- [bjerkio/oidc-react](https://github.com/bjerkio/oidc-react)
+- [thchia/react-oidc](https://github.com/thchia/react-oidc)
+- [@axa-fr/react-oidc](https://github.com/AxaGuilDEv/react-oidc)
+
+## Contributing
+
+See the [contributing guide](https://github.com/react-keycloak/react-keycloak/blob/master/CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+If you found this project to be helpful, please consider buying me a coffee.
+
+[![buy me a coffee](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://buymeacoff.ee/4f18nT0Nk)

package/lib/SSRKeycloakProvider.d.ts

@@ -0,0 +1,20 @@
+import type { AuthClient, AuthClientInitOptions, AuthProviderProps, AuthClientEvent, AuthClientError, AuthClientTokens } from '@react-keycloak-refork/core';
+import type { KeycloakConfig } from 'keycloak-js';
+import * as React from 'react';
+import type { TokenPersistor } from './persistors/types';
+import type { SSRAuthClient } from './types';
+export interface SSRKeycloakProviderProps<T extends SSRAuthClient> extends Omit<AuthProviderProps<T>, 'authClient'> {
+    persistor: TokenPersistor;
+    keycloakConfig: KeycloakConfig;
+}
+interface SSRKeycloakProviderState {
+    initOptions: AuthClientInitOptions;
+    keycloak: AuthClient;
+}
+export declare class SSRKeycloakProvider extends React.PureComponent<SSRKeycloakProviderProps<SSRAuthClient>, SSRKeycloakProviderState> {
+    constructor(props: SSRKeycloakProviderProps<SSRAuthClient>);
+    onEvent: (event: AuthClientEvent, error?: AuthClientError) => void;
+    onTokens: (tokens: AuthClientTokens) => void;
+    render(): React.JSX.Element;
+}
+export {};

package/lib/SSRKeycloakProvider.js

@@ -0,0 +1,78 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as React from 'react';
+import { getKeycloakInstance } from './internals/keycloak';
+import { KeycloakProvider } from './internals/KeycloakProvider';
+var SSRKeycloakProvider = /** @class */ (function (_super) {
+    __extends(SSRKeycloakProvider, _super);
+    function SSRKeycloakProvider(props) {
+        var _this = _super.call(this, props) || this;
+        _this.onEvent = function (event, error) {
+            var _a, _b, _c, _d;
+            if (event === 'onReady') {
+                if (!_this.state.keycloak.authenticated) {
+                    (_b = (_a = _this.props) === null || _a === void 0 ? void 0 : _a.persistor) === null || _b === void 0 ? void 0 : _b.resetTokens();
+                }
+            }
+            // Propagate events up
+            (_d = (_c = _this.props) === null || _c === void 0 ? void 0 : _c.onEvent) === null || _d === void 0 ? void 0 : _d.call(_c, event, error);
+        };
+        _this.onTokens = function (tokens) {
+            var _a, _b, _c, _d;
+            // Persist updated tokens
+            (_b = (_a = _this.props) === null || _a === void 0 ? void 0 : _a.persistor) === null || _b === void 0 ? void 0 : _b.setTokens(tokens);
+            // Propagate events up
+            (_d = (_c = _this.props) === null || _c === void 0 ? void 0 : _c.onTokens) === null || _d === void 0 ? void 0 : _d.call(_c, tokens);
+        };
+        var initOptions = props.initOptions, keycloakConfig = props.keycloakConfig, persistor = props.persistor;
+        var cachedTokens = persistor.getTokens();
+        _this.state = {
+            keycloak: getKeycloakInstance(keycloakConfig, persistor),
+            initOptions: __assign(__assign({}, cachedTokens), initOptions),
+        };
+        return _this;
+    }
+    SSRKeycloakProvider.prototype.render = function () {
+        var _a = this.props, children = _a.children, persistor = _a.persistor, providerProps = __rest(_a, ["children", "persistor"]);
+        var _b = this.state, initOptions = _b.initOptions, keycloak = _b.keycloak;
+        return (React.createElement(KeycloakProvider, __assign({}, providerProps, { authClient: keycloak, initOptions: initOptions, onEvent: this.onEvent, onTokens: this.onTokens }), children));
+    };
+    return SSRKeycloakProvider;
+}(React.PureComponent));
+export { SSRKeycloakProvider };
+//# sourceMappingURL=SSRKeycloakProvider.js.map

package/lib/SSRKeycloakProvider.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "SSRKeycloakProvider.js",
+  "sourceRoot": "",
+  "sources": [
+    "@react-keycloak-refork\\ssr\\SSRKeycloakProvider.tsx"
+  ],
+  "names": [],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AAiB/D;IAAyC,uCAGxC;IACC,6BAAY,KAA8C;QAA1D,YACE,kBAAM,KAAK,CAAC,SAYb;QAED,aAAO,GAAG,UAAC,KAAsB,EAAE,KAAuB;;YACxD,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,IAAI,CAAE,KAAI,CAAC,KAAK,CAAC,QAA6B,CAAC,aAAa,EAAE;oBAC5D,MAAA,MAAA,KAAI,CAAC,KAAK,0CAAE,SAAS,0CAAE,WAAW,EAAE,CAAA;iBACrC;aACF;YAED,sBAAsB;YACtB,MAAA,MAAA,KAAI,CAAC,KAAK,0CAAE,OAAO,mDAAG,KAAK,EAAE,KAAK,CAAC,CAAA;QACrC,CAAC,CAAA;QAED,cAAQ,GAAG,UAAC,MAAwB;;YAClC,yBAAyB;YACzB,MAAA,MAAA,KAAI,CAAC,KAAK,0CAAE,SAAS,0CAAE,SAAS,CAAC,MAAM,CAAC,CAAA;YAExC,sBAAsB;YACtB,MAAA,MAAA,KAAI,CAAC,KAAK,0CAAE,QAAQ,mDAAG,MAAM,CAAC,CAAA;QAChC,CAAC,CAAA;QA7BS,IAAA,WAAW,GAAgC,KAAK,YAArC,EAAE,cAAc,GAAgB,KAAK,eAArB,EAAE,SAAS,GAAK,KAAK,UAAV,CAAU;QACxD,IAAM,YAAY,GAAG,SAAS,CAAC,SAAS,EAAE,CAAA;QAE1C,KAAI,CAAC,KAAK,GAAG;YACX,QAAQ,EAAE,mBAAmB,CAAC,cAAc,EAAE,SAAS,CAAC;YACxD,WAAW,wBACN,YAAY,GACZ,WAAW,CACf;SACF,CAAA;;IACH,CAAC;IAqBD,oCAAM,GAAN;QACE,IAAM,KAA4C,IAAI,CAAC,KAAK,EAApD,QAAQ,cAAA,EAAE,SAAS,eAAA,EAAK,aAAa,cAAvC,yBAAyC,CAAa,CAAA;QACtD,IAAA,KAA4B,IAAI,CAAC,KAAK,EAApC,WAAW,iBAAA,EAAE,QAAQ,cAAe,CAAA;QAE5C,OAAO,CACL,oBAAC,gBAAgB,eACX,aAAa,IACjB,UAAU,EAAE,QAAQ,EACpB,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,IAAI,CAAC,OAAO,EACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ,KAEtB,QAAQ,CACQ,CACpB,CAAA;IACH,CAAC;IACH,0BAAC;AAAD,CAAC,AAtDD,CAAyC,KAAK,CAAC,aAAa,GAsD3D"
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { SSRKeycloakProvider } from './SSRKeycloakProvider';
+export { useKeycloak } from './useKeycloak';
+export { withKeycloak } from './withKeycloak';
+export { getKeycloakInstance } from './internals/keycloak';
+export * from './persistors/client';
+export * from './persistors/server';
+export * from './types';

package/lib/index.js

@@ -0,0 +1,8 @@
+export { SSRKeycloakProvider } from './SSRKeycloakProvider';
+export { useKeycloak } from './useKeycloak';
+export { withKeycloak } from './withKeycloak';
+export { getKeycloakInstance } from './internals/keycloak';
+export * from './persistors/client';
+export * from './persistors/server';
+export * from './types';
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "index.js",
+  "sourceRoot": "",
+  "sources": [
+    "@react-keycloak-refork\\ssr\\index.ts"
+  ],
+  "names": [],
+  "mappings": "AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAE1D,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AAEnC,cAAc,SAAS,CAAA"
+}

package/lib/internals/KeycloakProvider.d.ts

@@ -0,0 +1,146 @@
+/// <reference types="react" />
+export declare const KeycloakProvider: {
+    new (props: import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>): {
+        state: {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        };
+        componentDidMount(): void;
+        componentDidUpdate({ authClient: prevAuthClient, initOptions: prevInitOptions, }: import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>): void;
+        init(): void;
+        onError: (event: import("@react-keycloak-refork/core").AuthClientEvent) => (error?: import("@react-keycloak-refork/core").AuthClientError | undefined) => void;
+        updateState: (event: import("@react-keycloak-refork/core").AuthClientEvent) => () => void;
+        refreshToken: (event: import("@react-keycloak-refork/core").AuthClientEvent) => () => void;
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends keyof {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>(state: {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        } | ((prevState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, props: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>) => {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        } | Pick<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }, K> | null) | Pick<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, prevState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, nextContext: any): void;
+    };
+    new (props: import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>, context: any): {
+        state: {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        };
+        componentDidMount(): void;
+        componentDidUpdate({ authClient: prevAuthClient, initOptions: prevInitOptions, }: import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>): void;
+        init(): void;
+        onError: (event: import("@react-keycloak-refork/core").AuthClientEvent) => (error?: import("@react-keycloak-refork/core").AuthClientError | undefined) => void;
+        updateState: (event: import("@react-keycloak-refork/core").AuthClientEvent) => () => void;
+        refreshToken: (event: import("@react-keycloak-refork/core").AuthClientEvent) => () => void;
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K_1 extends keyof {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>(state: {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        } | ((prevState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, props: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>) => {
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        } | Pick<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }, K_1> | null) | Pick<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }, K_1> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, prevState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("@react-keycloak-refork/core").AuthProviderProps<import("@react-keycloak-refork/core").AuthClient>>, nextState: Readonly<{
+            initialized: boolean;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+        }>, nextContext: any): void;
+    };
+    contextType?: import("react").Context<any> | undefined;
+};

package/lib/internals/KeycloakProvider.js

@@ -0,0 +1,4 @@
+import { createAuthProvider } from '@react-keycloak-refork/core';
+import { reactKeycloakSsrContext } from './context';
+export var KeycloakProvider = createAuthProvider(reactKeycloakSsrContext);
+//# sourceMappingURL=KeycloakProvider.js.map

package/lib/internals/KeycloakProvider.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "KeycloakProvider.js",
+  "sourceRoot": "",
+  "sources": [
+    "@react-keycloak-refork\\ssr\\internals\\KeycloakProvider.ts"
+  ],
+  "names": [],
+  "mappings": "AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAEhE,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA;AAEnD,MAAM,CAAC,IAAM,gBAAgB,GAAG,kBAAkB,CAAC,uBAAuB,CAAC,CAAA"
+}

package/lib/internals/context.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { AuthClient } from '@react-keycloak-refork/core';
+export declare const reactKeycloakSsrContext: import("react").Context<import("@react-keycloak-refork/core").IAuthContextProps<AuthClient>>;
+export declare const ReactKeycloakSSRContextConsumer: import("react").Consumer<import("@react-keycloak-refork/core").IAuthContextProps<AuthClient>>;

package/lib/internals/context.js

@@ -0,0 +1,8 @@
+import { createAuthContext } from '@react-keycloak-refork/core';
+import { isServer } from './utils';
+// Context to hold Keycloak and his state
+export var reactKeycloakSsrContext = createAuthContext({
+    initialized: isServer(),
+});
+export var ReactKeycloakSSRContextConsumer = reactKeycloakSsrContext.Consumer;
+//# sourceMappingURL=context.js.map

package/lib/internals/context.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "context.js",
+  "sourceRoot": "",
+  "sources": [
+    "@react-keycloak-refork\\ssr\\internals\\context.ts"
+  ],
+  "names": [],
+  "mappings": "AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAG/D,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,yCAAyC;AACzC,MAAM,CAAC,IAAM,uBAAuB,GAAG,iBAAiB,CAAa;IACnE,WAAW,EAAE,QAAQ,EAAE;CACxB,CAAC,CAAA;AAEF,MAAM,CAAC,IAAM,+BAA+B,GAAG,uBAAuB,CAAC,QAAQ,CAAA"
+}

package/lib/internals/keycloak.d.ts

@@ -0,0 +1,5 @@
+import type { AuthClient } from '@react-keycloak-refork/core';
+import type { KeycloakConfig } from 'keycloak-js';
+import type { TokenPersistor } from '../persistors/types';
+export declare const getKeycloakStub: (persistor: TokenPersistor) => AuthClient;
+export declare const getKeycloakInstance: (keycloakConfig: KeycloakConfig, persistor?: TokenPersistor, recreate?: boolean) => AuthClient;

package/lib/internals/keycloak.js

@@ -0,0 +1,29 @@
+import { isServer } from './utils';
+// Keycloak singleton
+var keycloakInstance;
+// KeycloakStub singleton
+var keycloakStubInstance;
+// this is a fake Keycloak instance we use to initialize Keycloak on the server.
+// This gets over-written as soon as Keycloak is initialized on the client.
+export var getKeycloakStub = function (persistor) {
+    var kcTokens = persistor.getTokens();
+    keycloakStubInstance = {
+        init: function () { return Promise.resolve(true); },
+        updateToken: function () { return Promise.resolve(false); },
+        idToken: kcTokens.idToken,
+        token: kcTokens.token,
+        refreshToken: kcTokens.refreshToken,
+        authenticated: !!kcTokens.idToken && !!kcTokens.token,
+    };
+    return keycloakStubInstance;
+};
+var Keycloak = !isServer() ? require('keycloak-js').default : null;
+export var getKeycloakInstance = function (keycloakConfig, persistor, recreate) {
+    if (recreate === void 0) { recreate = false; }
+    var isServerCheck = isServer();
+    if (recreate || (!keycloakInstance && !isServerCheck)) {
+        keycloakInstance = Keycloak(keycloakConfig);
+    }
+    return !isServerCheck ? keycloakInstance : getKeycloakStub(persistor);
+};
+//# sourceMappingURL=keycloak.js.map