@axa-fr/react-oidc 5.7.0-alpha0

package/README.md

@@ -0,0 +1,502 @@
+<H1> @axa-fr/react-oidc-context</H1>
+
+Try the demo at https://black-rock-0dc6b0d03.1.azurestaticapps.net/
+
+<p align="center">
+    <img src="https://github.com/AxaGuilDEv/react-oidc/blob/master/docs/img/introduction.gif?raw=true"
+     alt="Sample React Oicd"
+      />
+</p>
+
+<p align="center">
+  A set of react components to make Oidc (OpenID Connect) client easy. It aim to simplify OAuth authentication between multiples providers.
+</p>
+
+- [About](#about)
+- [Getting Started](#getting-started)
+- [Run The Demo](#run-the-demo)
+- [Examples](#examples)
+- [How It Works](#how-it-works)
+- [Service Worker Support](#service-worker-support)
+
+Easy set up of OIDC for react and use the new react context api as state management.
+It use AppAuthJS behind the scene.
+
+- **Secure** :
+  - With the use of Service Worker, your tokens (refresh_token and access_token) are not accessible to the javascript client code (big protection against XSRF attacks)
+  - OIDC using client side Code Credential Grant with pkce only
+- **Lightweight**
+- **Simple** :
+  - refresh_token and access_token are auto refreshed in background
+  - with the use of the Service Worker, you do not need to inject the access_token in every fetch, you have only to configure OidcTrustedDomains.js file
+- **No cookies problem** : You can disable silent signin (that internally use an iframe)
+- **Multiple Authentification** :
+  - You can authenticate many times to the same provider with different scope (for exemple you can acquire a new 'payment' scope for a payment)
+  - You can authenticate to multiple different providers inside the same SPA (single page application) website
+- **Flexible** :
+  - Work with Service Worker (more secure) and whithout for older browser (less secure)
+
+<p align="center">
+    <img src="https://github.com/AxaGuilDEv/react-oidc/blob/master/docs/img/schema_pcke_client_side_with_service_worker.png?raw=true"
+     alt="Schema Authorization Code Grant with pcke flow on the using service worker"
+      />
+  <br>
+  The service worker catch <b>access_token</b> and <b>refresh_token</b> that will never be accessible to the client.
+</p>
+
+# Getting Started
+
+```sh
+npm install @axa-fr/react-oidc-context copyfiles --save
+```
+
+If you need a very secure mode where refresh_token and access_token will be hide behind a service worker that will proxify requests.
+
+Add a copy task in order to install and stay up to date an Oidc Service Worker.
+The only file you should edit is "OidcTrustedDomains.js" which will never be erased with following configuration bellow.
+
+```sh
+#package.json
+{
+    "scripts": {
+        "copy": "copyfiles -f ./node_modules/@axa-fr/react-oidc-context/dist/OidcServiceWorker.js ./public && copyfiles -f -s ./node_modules/@axa-fr/react-oidc-context/dist/OidcTrustedDomains.js ./public",
+        "start:server": "react-scripts start",
+        "build:server": "npm run copy && react-scripts build",
+        "prepare": "npm run copy"
+    }
+}
+```
+
+```javascript
+// OidcTrustedDomains.js
+// Add here trusted domains, access tokens will be send to
+const trustedDomains = {
+    default:["http://localhost:4200"]
+};
+```
+
+# Run The Demo
+
+```sh
+git clone https://github.com/AxaGuilDEv/react-oidc.git
+cd react-oidc/packages/context
+npm install
+npm start
+# then navigate to http://localhost:4200
+```
+
+# Examples
+
+## Application startup
+
+The library is router agnostic and use native History API.
+
+The default routes used internally :
+
+- www.your-app.fr/authentication/callback
+
+```javascript
+import React from 'react';
+import { render } from 'react-dom';
+import { BrowserRouter as Router } from 'react-router-dom';
+import { OidcProvider } from '@axa-fr/react-oidc-context';
+import Header from './Layout/Header';
+import Routes from './Router';
+
+// This configuration use hybrid mode
+// ServiceWorker are used if available (more secure) else tokens are given to the client
+// You need to give inside your code the "access_token" when using fetch
+const configuration = {
+  client_id: 'interactive.public.short',
+  redirect_uri: 'http://localhost:4200/authentication/callback',
+  silent_redirect_uri: 'http://localhost:4200/authentication/silent-callback',
+  scope: 'openid profile email api offline_access', // offline_access scope allow your client to retrieve the refresh_token
+  authority: 'https://demo.identityserver.io',
+  service_worker_relative_url:'/OidcServiceWorker.js',
+  service_worker_only:false,
+};
+
+const App = () => (
+    <OidcProvider configuration={configuration} >
+      <Router>
+        <Header />
+        <Routes />
+      </Router>
+    </OidcProvider>
+);
+
+render(<App />, document.getElementById('root'));
+```
+
+
+```javascript
+const propTypes = {
+  loadingComponent: PropTypes.elementType, // you can inject your own loading component
+  sessionLostComponent: PropTypes.elementType, // you can inject your own session lost component
+  authenticating: PropTypes.elementType, // you can inject your own authenticationg component
+  callbackSuccessComponent: PropTypes.elementType, // you can inject your own call back success component
+  callbackErrorComponent: PropTypes.elementType, // you can inject your own call back error component
+  serviceWorkerNotSupportedComponent: PropTypes.elementType, // you can inject your page that explain your require a more modern browser
+  onSessionLost: PropTypes.function, // If set "sessionLostComponent" is not displayed and onSessionLost callback is called instead
+  configuration: PropTypes.shape({
+    client_id: PropTypes.string.isRequired, // oidc client id
+    redirect_uri: PropTypes.string.isRequired, // oidc redirect url
+    silent_redirect_uri: PropTypes.string, // Optional activate silent-signin that use cookies between OIDC server and client javascript to restore sessions
+    silent_signin_timeout: PropTypes.number, // Optional default is 12000 milliseconds
+    scope: PropTypes.string.isRequired, // oidc scope (you need to set "offline_access")
+    authority: PropTypes.string.isRequired,
+    authority_configuration: PropTypes.shape({ // Optional for providers that does not implement OIDC server auto discovery via a .wellknowurl
+      authorization_endpoint: PropTypes.string,
+      token_endpoint: PropTypes.string,
+      userinfo_endpoint: PropTypes.string,
+      end_session_endpoint: PropTypes.string,
+      revocation_endpoint: PropTypes.string,
+    }),
+    refresh_time_before_tokens_expiration_in_second: PropTypes.number,
+    service_worker_relative_url: PropTypes.string,
+    service_worker_only: PropTypes.boolean, // default false
+    extras: StringMap|undefined // ex: {'prompt': 'consent', 'access_type': 'offline'} list of key/value that are send to the oidc server (more info: https://github.com/openid/AppAuth-JS)
+  }).isRequired
+};
+```
+## How to consume
+
+"useOidc" returns all props from the Hook :
+
+```javascript
+import React from 'react';
+import {useOidc} from "./oidc";
+
+export const Home = () => {
+
+    const { login, logout, isAuthenticated} = useOidc();
+    
+    return (
+        <div className="container-fluid mt-3">
+            <div className="card">
+                <div className="card-body">
+                    <h5 className="card-title">Welcome !!!</h5>
+                    <p className="card-text">React Demo Application protected by OpenId Connect</p>
+                    {!isAuthenticated && <button type="button" className="btn btn-primary" onClick={() => login('/profile')}>Login</button>}
+                    {isAuthenticated && <button type="button" className="btn btn-primary" onClick={() => logout()}>logout</button>}
+                </div>
+            </div>
+        </div>
+    )
+};
+
+```
+The Hook method exposes :
+- isAuthenticated : if the user is logged in or not
+- logout: logout function (return a promise)
+- login: login function 'return a promise'
+
+## How to secure a component
+
+"OidcSecure" component trigger authentication in case user is not authenticated. So, the children of that component can be accessible only once you are connected.
+
+```javascript
+import React from 'react';
+import { OidcSecure } from '@axa-fr/react-oidc-context';
+
+const AdminSecure = () => (
+  <OidcSecure>
+    <h1>My sub component</h1>}
+  </OidcSecure>
+);
+
+// adding the oidc user in the props
+export default AdminSecure;
+```
+
+## How to secure a component : HOC method
+
+"withOidcSecure" act the same as "OidcSecure" it also trigger authentication in case user is not authenticated.
+
+```javascript
+import React from 'react';
+import { Switch, Route } from 'react-router-dom';
+import { withOidcSecure } from '@axa-fr/react-oidc-context';
+import Home from '../Pages/Home';
+import Dashboard from '../Pages/Dashboard';
+import Admin from '../Pages/Admin';
+
+const Routes = () => (
+  <Switch>
+    <Route exact path="/" component={Home} />
+    <Route path="/dashboard" component={withOidcSecure(Dashboard)} />
+    <Route path="/admin" component={Admin} />
+    <Route path="/home" component={Home} />
+  </Switch>
+);
+
+export default Routes;
+```
+
+## How to get "Access Token" : Hook method
+
+```javascript
+import { useOidcAccessToken } from '@axa-fr/react-oidc-context';
+
+const DisplayAccessToken = () => {
+    const{ accessToken, accessTokenPayload } = useOidcAccessToken();
+
+    if(!accessToken){
+        return <p>you are not authentified</p>
+    }
+    return (
+        <div className="card text-white bg-info mb-3">
+            <div className="card-body">
+                <h5 className="card-title">Access Token</h5>
+                <p style={{color:'red', "backgroundColor": 'white'}}>Please consider to configure the ServiceWorker in order to protect your application from XSRF attacks. ""access_token" and "refresh_token" will never be accessible from your client side javascript.</p>
+                {<p className="card-text">{JSON.stringify(accessToken)}</p>}
+                {accessTokenPayload != null && <p className="card-text">{JSON.stringify(accessTokenPayload)}</p>}
+            </div>
+        </div>
+    )
+};
+```
+
+## How to get IDToken : Hook method
+
+```javascript
+import { useOidcIdToken } from '@axa-fr/react-oidc-context';
+
+const DisplayIdToken =() => {
+    const{ idToken, idTokenPayload } = useOidcIdToken();
+
+    if(!idToken){
+        return <p>you are not authentified</p>
+    }
+    
+    return (
+        <div className="card text-white bg-info mb-3">
+            <div className="card-body">
+                <h5 className="card-title">ID Token</h5>
+                {<p className="card-text">{JSON.stringify(idToken)}</p>}
+                {idTokenPayload != null && <p className="card-text">{JSON.stringify(idTokenPayload)}</p>}
+            </div>
+        </div>
+    );
+}
+
+```
+
+
+## How to get User Information : Hook method
+
+```javascript
+import { useOidcUser, UserStatus } from '@axa-fr/react-oidc-context';
+
+const DisplayUserInfo = () => {
+  const{ oidcUser, oidcUserLoadingState } = useOidcUser();
+
+  switch (oidcUserLoadingState){
+    case UserStatus.Loading:
+      return <p>User Information are loading</p>;
+    case UserStatus.Unauthenticated:
+      return <p>you are not authenticated</p>;
+    case UserStatus.LoadingError:
+      return <p>Fail to load user information</p>;
+    default:
+      return (
+              <div className="card text-white bg-success mb-3">
+                <div className="card-body">
+                  <h5 className="card-title">User information</h5>
+                  <p className="card-text">{JSON.stringify(oidcUser)}</p>
+                </div>
+              </div>
+      );
+  }
+};
+
+```
+
+## How to get a fetch that inject Access_Token : Hook method
+
+If your are not using the service worker. Fetch function need to send AccessToken.
+This Hook give you a wrapped fetch that add the access token for you.
+
+```javascript
+import React, {useEffect, useState} from 'react';
+import { useOidcFetch, OidcSecure } from '@axa-fr/react-oidc-context';
+
+const DisplayUserInfo = ({ fetch }) => {
+  const [oidcUser, setOidcUser] = useState(null);
+  const [isLoading, setLoading] = useState(true);
+
+  useEffect(() => {
+    const fetchUserInfoAsync = async () => {
+      const res = await fetch("https://demo.duendesoftware.com/connect/userinfo");
+      if (res.status != 200) {
+        return null;
+      }
+      return res.json();
+    };
+    let isMounted = true;
+    fetchUserInfoAsync().then((userInfo) => {
+      if(isMounted) {
+        setLoading(false);
+        setOidcUser(userInfo)
+      }
+    })
+    return  () => {
+      isMounted = false;
+    };
+  },[]);
+
+  if(isLoading){
+    return <>Loading</>;
+  }
+
+  return (
+          <div className="container mt-3">
+            <div className="card text-white bg-success mb-3">
+              <div className="card-body">
+                <h5 className="card-title">User information</h5>
+                {oidcUser != null && <p className="card-text">{JSON.stringify(oidcUser)}</p>}
+              </div>
+            </div>
+          </div>
+  )
+};
+
+export const FetchUserHook= () => {
+  const {fetch} = useOidcFetch();
+  return <OidcSecure><DisplayUserInfo fetch={fetch} /></OidcSecure>
+}
+
+```
+
+## How to get a fetch that inject Access_Token : HOC method
+
+If your are not using the service worker. Fetch function need to send AccessToken.
+This HOC give you a wrapped fetch that add the access token for you.
+
+```javascript
+import React, {useEffect, useState} from 'react';
+import { useOidcFetch, OidcSecure } from '@axa-fr/react-oidc-context';
+
+const DisplayUserInfo = ({ fetch }) => {
+  const [oidcUser, setOidcUser] = useState(null);
+  const [isLoading, setLoading] = useState(true);
+
+  useEffect(() => {
+    const fetchUserInfoAsync = async () => {
+      const res = await fetch("https://demo.duendesoftware.com/connect/userinfo");
+      if (res.status != 200) {
+        return null;
+      }
+      return res.json();
+    };
+    let isMounted = true;
+    fetchUserInfoAsync().then((userInfo) => {
+      if(isMounted) {
+        setLoading(false);
+        setOidcUser(userInfo)
+      }
+    })
+    return  () => {
+      isMounted = false;
+    };
+  },[]);
+
+  if(isLoading){
+    return <>Loading</>;
+  }
+
+  return (
+          <div className="container mt-3">
+            <div className="card text-white bg-success mb-3">
+              <div className="card-body">
+                <h5 className="card-title">User information</h5>
+                {oidcUser != null && <p className="card-text">{JSON.stringify(oidcUser)}</p>}
+              </div>
+            </div>
+          </div>
+  )
+};
+
+const UserInfoWithFetchHoc = withOidcFetch(fetch)(DisplayUserInfo);
+export const FetchUserHoc= () => <OidcSecure><UserInfoWithFetchHoc/></OidcSecure>;
+
+```
+
+
+## Components override
+
+You can inject your own components.
+All components definition receive props "configurationName". Please checkout and the the demo for more complexe exemple.
+
+```javascript
+
+import React from 'react';
+import { render } from 'react-dom';
+import { BrowserRouter as Router } from 'react-router-dom';
+import { OidcProvider } from '@axa-fr/react-oidc-context';
+import Header from './Layout/Header';
+import Routes from './Router';
+
+// This configuration use hybrid mode
+// ServiceWorker are used if available (more secure) else tokens are given to the client
+// You need to give inside your code the "access_token" when using fetch
+const configuration = {
+  client_id: 'interactive.public.short',
+  redirect_uri: 'http://localhost:4200/authentication/callback',
+  silent_redirect_uri: 'http://localhost:4200/authentication/silent-callback',
+  scope: 'openid profile email api offline_access',
+  authority: 'https://demo.identityserver.io',
+  service_worker_relative_url:'/OidcServiceWorker.js',
+  service_worker_only:false,
+};
+
+const Loading = () => <p>Loading</p>
+const AuthenticatingError = () => <p>Authenticating error</p>
+const Authenticating = () => <p>Authenticating</p>
+const SessionLost = () => <p>Session Lost</p>
+const ServiceWorkerNotSupported = () => <p>Not supported</p>
+const CallBackSuccess = () => <p>Success</p>
+
+//const [isSessionLost, setIsSessionLost] = useState(false);
+
+//const onSessionLost = ()=>{
+//  setIsSessionLost(true);
+//}
+
+const App = () => (
+        <OidcProvider configuration={configuration}
+                      loadingComponent={Loading}
+                      authenticatingErrorComponent={AuthenticatingError}
+                      authenticatingComponent={Authenticating}
+                      sessionLostComponent={SessionLost}
+                //onSessionLost={onSessionLost} // If set "sessionLostComponent" is not displayed and onSessionLost callback is called instead
+                      serviceWorkerNotSupportedComponent={ServiceWorkerNotSupported}
+                      callbackSuccessComponent={CallBackSuccess}
+        >
+          {/* isSessionLost && <SessionLost />*/}
+          <Router>
+            <Header />
+            <Routes />
+          </Router>
+        </OidcProvider>
+);
+
+render(<App />, document.getElementById('root'));
+
+```
+
+# How It Works
+
+These components encapsulate the use of "AppAuth-JS" in order to hide workfow complexity.
+Internally, native History API is used to be router library agnostic.
+
+More information about OIDC
+- French: https://medium.com/just-tech-it-now/augmentez-la-s%C3%A9curit%C3%A9-et-la-simplicit%C3%A9-de-votre-syst%C3%A8me-dinformation-avec-oauth-2-0-cf0732d71284
+- English: https://medium.com/just-tech-it-now/increase-the-security-and-simplicity-of-your-information-system-with-openid-connect-fa8c26b99d6d
+
+# Service Worker Support
+
+- Firefox : tested on firefox 98.0.2
+- Chrome/Edge : tested on version upper to 90
+- Opera : tested on version upper to 80
+- Safari : tested on Safari/605.1.15

package/dist/FetchToken.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export declare type Fetch = typeof window.fetch;
+export interface ComponentWithOidcFetchProps {
+    fetch?: Fetch;
+}
+export declare const withOidcFetch: (fetch?: Fetch, configurationName?: string) => (WrappedComponent: any) => (props: ComponentWithOidcFetchProps) => JSX.Element;
+export declare const useOidcFetch: (fetch?: Fetch, configurationName?: string) => {
+    fetch: (url: RequestInfo, options?: RequestInit) => Promise<Response>;
+};
+//# sourceMappingURL=FetchToken.d.ts.map

package/dist/FetchToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FetchToken.d.ts","sourceRoot":"","sources":["../src/oidc/FetchToken.tsx"],"names":[],"mappings":";AAGA,oBAAY,KAAK,GAAG,OAAO,MAAM,CAAC,KAAK,CAAC;AACxC,MAAM,WAAW,2BAA2B;IAC1C,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AA8BD,eAAO,MAAM,aAAa,WAAU,KAAK,oEAE1B,2BAA2B,gBAGvC,CAAC;AAGJ,eAAO,MAAM,YAAY,WAAS,KAAK;iBAlC9B,WAAW,YACP,WAAW;CAuCvB,CAAA"}

package/dist/FetchToken.js

@@ -0,0 +1,107 @@
+"use strict";
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOidcFetch = exports.withOidcFetch = void 0;
+var react_1 = __importDefault(require("react"));
+var oidc_1 = __importDefault(require("./vanilla/oidc"));
+var defaultConfigurationName = "default";
+var fetchWithToken = function (fetch, getAccessTokenInjected) { return function (url, options) {
+    if (options === void 0) { options = { method: 'GET' }; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var headers, optionTmp, accessToken, newOptions;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    headers = new Headers();
+                    optionTmp = __assign({}, options);
+                    if (optionTmp.headers) {
+                        headers = !(optionTmp.headers instanceof Headers)
+                            ? new Headers(optionTmp.headers)
+                            : optionTmp.headers;
+                    }
+                    accessToken = getAccessTokenInjected();
+                    if (!headers.has('Accept')) {
+                        headers.set('Accept', 'application/json');
+                    }
+                    if (accessToken) {
+                        headers.set('Authorization', "Bearer ".concat(accessToken));
+                        if (!optionTmp.credentials) {
+                            optionTmp.credentials = 'same-origin';
+                        }
+                    }
+                    newOptions = __assign(__assign({}, optionTmp), { headers: headers });
+                    return [4 /*yield*/, fetch(url, newOptions)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}; };
+var withOidcFetch = function (fetch, configurationName) {
+    if (fetch === void 0) { fetch = null; }
+    if (configurationName === void 0) { configurationName = defaultConfigurationName; }
+    return function (WrappedComponent) { return function (props) {
+        var newFetch = (0, exports.useOidcFetch)(fetch || props.fetch, configurationName).fetch;
+        return react_1.default.createElement(WrappedComponent, __assign({}, props, { fetch: newFetch }));
+    }; };
+};
+exports.withOidcFetch = withOidcFetch;
+var useOidcFetch = function (fetch, configurationName) {
+    if (fetch === void 0) { fetch = null; }
+    if (configurationName === void 0) { configurationName = defaultConfigurationName; }
+    var previousFetch = fetch || window.fetch;
+    var getOidc = oidc_1.default.get;
+    var getAccessTokenInjected = function () { return getOidc(configurationName).tokens.accessToken; };
+    var newFetch = fetchWithToken(previousFetch, getAccessTokenInjected);
+    return { fetch: newFetch };
+};
+exports.useOidcFetch = useOidcFetch;
+//# sourceMappingURL=FetchToken.js.map

package/dist/FetchToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FetchToken.js","sourceRoot":"","sources":["../src/oidc/FetchToken.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gDAA0B;AAC1B,wDAAkC;AAMlC,IAAM,wBAAwB,GAAG,SAAS,CAAC;AAE3C,IAAM,cAAc,GAAG,UAAC,KAAY,EAAE,sBAA2C,IAAK,OAAA,UAClF,GAAgB,EAChB,OAAwC;IAAxC,wBAAA,EAAA,YAAyB,MAAM,EAAE,KAAK,EAAE;;;;;;oBAEtC,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;oBACtB,SAAS,gBAAQ,OAAO,CAAE,CAAC;oBAEjC,IAAI,SAAS,CAAC,OAAO,EAAE;wBACrB,OAAO,GAAG,CAAC,CAAC,SAAS,CAAC,OAAO,YAAY,OAAO,CAAC;4BAC7C,CAAC,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC;4BAChC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC;qBACzB;oBAEK,WAAW,GAAG,sBAAsB,EAAE,CAAC;oBAC7C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;wBAC1B,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;qBAC3C;oBACD,IAAI,WAAW,EAAE;wBACf,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,iBAAU,WAAW,CAAE,CAAC,CAAC;wBACtD,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE;4BAC1B,SAAS,CAAC,WAAW,GAAG,aAAa,CAAC;yBACvC;qBACF;oBACK,UAAU,yBAAQ,SAAS,KAAE,OAAO,SAAA,GAAE,CAAC;oBACtC,qBAAM,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,EAAA;wBAAnC,sBAAO,SAA4B,EAAC;;;;CACrC,EAzBqF,CAyBrF,CAAC;AAEK,IAAM,aAAa,GAAG,UAAC,KAAgB,EAAE,iBAA0C;IAA5D,sBAAA,EAAA,YAAgB;IAAE,kCAAA,EAAA,4CAA0C;IAAK,OAAA,UAC3F,gBAAgB,IACb,OAAA,UAAC,KAAkC;QAC/B,IAAM,QAAQ,GAAI,IAAA,oBAAY,EAAC,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE,iBAAiB,CAAC,MAAzD,CAAyD;QAC9E,OAAO,8BAAC,gBAAgB,eAAK,KAAK,IAAE,KAAK,EAAE,QAAQ,IAAI,CAAC;IAC1D,CAAC,EAHI,CAGJ;AAL4F,CAK5F,CAAC;AALS,QAAA,aAAa,iBAKtB;AAGG,IAAM,YAAY,GAAE,UAAC,KAAgB,EAAE,iBAA0C;IAA5D,sBAAA,EAAA,YAAgB;IAAE,kCAAA,EAAA,4CAA0C;IACtF,IAAM,aAAa,GAAG,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC;IAC5C,IAAM,OAAO,GAAI,cAAI,CAAC,GAAG,CAAC;IAC1B,IAAM,sBAAsB,GAAG,cAAQ,OAAO,OAAO,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAC/F,IAAM,QAAQ,GAAG,cAAc,CAAC,aAAa,EAAE,sBAAsB,CAAC,CAAC;IACvE,OAAO,EAAE,KAAK,EAAC,QAAQ,EAAE,CAAC;AAC5B,CAAC,CAAA;AANY,QAAA,YAAY,gBAMxB"}

package/dist/OidcProvider.d.ts

@@ -0,0 +1,25 @@
+import { ComponentType, FC, PropsWithChildren } from 'react';
+import { OidcConfiguration } from './vanilla/oidc';
+export declare type oidcContext = {
+    getOidc: Function;
+};
+export declare type OidcProviderProps = {
+    callbackSuccessComponent?: ComponentType<any>;
+    callbackErrorComponent?: ComponentType<any>;
+    sessionLostComponent?: ComponentType<any>;
+    authenticatingComponent?: ComponentType<any>;
+    loadingComponent?: ComponentType<any>;
+    authenticatingErrorComponent?: ComponentType<any>;
+    serviceWorkerNotSupportedComponent?: ComponentType<any>;
+    configurationName?: string;
+    configuration?: OidcConfiguration;
+    children: any;
+    onSessionLost?: Function;
+};
+export declare type OidcSessionProps = {
+    configurationName: string;
+    loadingComponent: PropsWithChildren<any>;
+};
+export declare const OidcProvider: FC<PropsWithChildren<OidcProviderProps>>;
+export default OidcProvider;
+//# sourceMappingURL=OidcProvider.d.ts.map

package/dist/OidcProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OidcProvider.d.ts","sourceRoot":"","sources":["../src/oidc/OidcProvider.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAC,aAAa,EAAE,EAAE,EAAE,iBAAiB,EAAsB,MAAM,OAAO,CAAC;AACvF,OAAa,EAAC,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAMvD,oBAAY,WAAW,GAAG;IACtB,OAAO,EAAE,QAAQ,CAAC;CACrB,CAAC;AAIF,oBAAY,iBAAiB,GAAG;IAC5B,wBAAwB,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAC9C,sBAAsB,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAC5C,oBAAoB,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAC1C,uBAAuB,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAC7C,gBAAgB,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IACtC,4BAA4B,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAClD,kCAAkC,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IACxD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,QAAQ,EAAE,GAAG,CAAC;IACd,aAAa,CAAC,EAAE,QAAQ,CAAC;CAC5B,CAAC;AAEF,oBAAY,gBAAgB,GAAG;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC;CAC5C,CAAC;AAyCF,eAAO,MAAM,YAAY,EAAG,EAAE,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CA2FlE,CAAC;AAEF,eAAe,YAAY,CAAC"}