@frontegg/nextjs 6.7.8 → 6.7.9-alpha.3741489660

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## [6.7.9](https://github.com/frontegg/frontegg-nextjs/compare/v6.7.8...v6.7.9) (2022-12-20)
+
+
+
 ## [6.7.8](https://github.com/frontegg/frontegg-nextjs/compare/v6.7.7...v6.7.8) (2022-12-20)
 
 - Fixed mfa input on mobile 

package/FronteggBaseProvider-5529ded6.js

@@ -0,0 +1,119 @@
+'use client'; 
+ import { __assign, __rest } from 'tslib';
+import { useAuthUserOrNull, useAuthActions, FronteggStoreProvider } from '@frontegg/react-hooks';
+import { fronteggAuthApiRoutes, ContextHolder } from '@frontegg/rest-api';
+import React, { createContext, useEffect, useRef, useCallback, useMemo } from 'react';
+import { AppHolder, initialize } from '@frontegg/js';
+import { createFronteggStore } from '@frontegg/redux-store';
+
+var AppContext = createContext(null);
+
+var createOrGetFronteggApp = function (_a) {
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var options = _a.options, onRedirectTo = _a.onRedirectTo, appName = _a.appName, user = _a.user, tenants = _a.tenants, storeHolder = _a.storeHolder;
+    var _l = (_b = options.session) !== null && _b !== void 0 ? _b : {}, accessToken = _l.accessToken, refreshToken = _l.refreshToken;
+    var contextOptions = __assign(__assign({ requestCredentials: 'include' }, options.contextOptions), { baseUrl: function (path) {
+            if (fronteggAuthApiRoutes.indexOf(path) !== -1 ||
+                path.endsWith('/postlogin') ||
+                path.endsWith('/prelogin') ||
+                path === '/oauth/token') {
+                return options.envAppUrl + "/api";
+            }
+            else {
+                return options.envBaseUrl;
+            }
+        }, clientId: options.envClientId });
+    var tenantsState = tenants
+        ? __assign({ tenantTree: null, subTenants: [], tenants: tenants, loading: false }, (_c = options.authOptions) === null || _c === void 0 ? void 0 : _c.tenantsState) : undefined;
+    var userData = user
+        ? __assign(__assign(__assign({}, user), { accessToken: accessToken !== null && accessToken !== void 0 ? accessToken : '', refreshToken: refreshToken !== null && refreshToken !== void 0 ? refreshToken : undefined }), (_d = options.authOptions) === null || _d === void 0 ? void 0 : _d.user) : null;
+    var authOptions = __assign(__assign({}, options.authOptions), { onRedirectTo: onRedirectTo, isLoading: false, isAuthenticated: !!options.session, hostedLoginBox: (_e = options.hostedLoginBox) !== null && _e !== void 0 ? _e : false, disableSilentRefresh: (_g = (_f = options.authOptions) === null || _f === void 0 ? void 0 : _f.disableSilentRefresh) !== null && _g !== void 0 ? _g : false, user: userData, tenantsState: tenantsState });
+    var sharedStore = createFronteggStore({ context: contextOptions }, storeHolder.current, options.previewMode, authOptions, {
+        auth: authOptions !== null && authOptions !== void 0 ? authOptions : {},
+        audits: (_h = options.auditsOptions) !== null && _h !== void 0 ? _h : {},
+    }, false, options.urlStrategy);
+    var createdApp;
+    try {
+        createdApp = AppHolder.getInstance(appName !== null && appName !== void 0 ? appName : 'default');
+        createdApp.store = sharedStore;
+    }
+    catch (e) {
+        createdApp = initialize(__assign(__assign({}, options), { store: sharedStore, hostedLoginBox: (_j = options.hostedLoginBox) !== null && _j !== void 0 ? _j : false, customLoginBox: (_k = options.customLoginBox) !== null && _k !== void 0 ? _k : false, basename: options.basename, authOptions: authOptions,
+            contextOptions: contextOptions,
+            onRedirectTo: onRedirectTo }), appName !== null && appName !== void 0 ? appName : 'default');
+    }
+    return createdApp;
+};
+
+var ExpireInListener = function () {
+    var user = useAuthUserOrNull();
+    var actions = useAuthActions();
+    useEffect(function () {
+        if (user && (user === null || user === void 0 ? void 0 : user.expiresIn) == null) {
+            actions.setUser(__assign(__assign({}, user), { expiresIn: Math.floor((user['exp'] * 1000 - Date.now()) / 1000) }));
+        }
+    }, [actions, user]);
+    // eslint-disable-next-line react/jsx-no-useless-fragment
+    return React.createElement(React.Fragment, null);
+};
+
+var useRequestAuthorizeSSR = function (_a) {
+    var app = _a.app, accessToken = _a.accessToken, user = _a.user, tenants = _a.tenants, refreshToken = _a.refreshToken;
+    useEffect(function () {
+        app === null || app === void 0 ? void 0 : app.store.dispatch({
+            type: 'auth/requestAuthorizeSSR',
+            payload: {
+                accessToken: accessToken,
+                user: user ? __assign(__assign({}, user), { refreshToken: refreshToken }) : null,
+                tenants: tenants,
+            },
+        });
+    }, [app]);
+};
+
+var Connector = function (_a) {
+    var _b, _c;
+    var router = _a.router, _d = _a.appName, appName = _d === void 0 ? 'default' : _d, user = _a.user, tenants = _a.tenants, props = __rest(_a, ["router", "appName", "user", "tenants"]);
+    var isSSR = typeof window === 'undefined';
+    var _e = (_b = props.session) !== null && _b !== void 0 ? _b : {}, accessToken = _e.accessToken, refreshToken = _e.refreshToken;
+    var baseName = (_c = props.basename) !== null && _c !== void 0 ? _c : '';
+    var storeHolder = useRef({});
+    var onRedirectTo = useCallback(function (_path, opts) {
+        var path = _path;
+        if (path.startsWith(baseName)) {
+            path = path.substring(baseName.length);
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.preserveQueryParams) {
+            path = "" + path + window.location.search;
+        }
+        if ((opts === null || opts === void 0 ? void 0 : opts.refresh) && !isSSR) {
+            // @ts-ignore
+            window.Cypress ? router.push(path) : (window.location.href = path);
+        }
+        else {
+            (opts === null || opts === void 0 ? void 0 : opts.replace) ? router.replace(path) : router.push(path);
+        }
+    }, []);
+    var app = useMemo(function () {
+        return createOrGetFronteggApp({
+            options: __assign(__assign({}, props), { basename: baseName }),
+            user: user,
+            tenants: tenants,
+            onRedirectTo: onRedirectTo,
+            appName: appName,
+            storeHolder: storeHolder,
+        });
+    }, [props]);
+    ContextHolder.setOnRedirectTo(onRedirectTo);
+    useRequestAuthorizeSSR({ app: app, accessToken: accessToken, user: user, tenants: tenants, refreshToken: refreshToken });
+    return (React.createElement(AppContext.Provider, { value: app },
+        React.createElement(FronteggStoreProvider, __assign({}, __assign(__assign({}, props), { app: app })), props.children)));
+};
+var FronteggBaseProvider = function (props) {
+    return (React.createElement(Connector, __assign({}, props, { framework: 'nextjs' }),
+        React.createElement(ExpireInListener, null),
+        props.children));
+};
+
+export { AppContext as A, ExpireInListener as E, FronteggBaseProvider as F };
+//# sourceMappingURL=FronteggBaseProvider-5529ded6.js.map

package/FronteggBaseProvider-5529ded6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FronteggBaseProvider-5529ded6.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/FronteggClientProviderNext13-65bb4cd0.js

@@ -0,0 +1,19 @@
+'use client'; 
+ import { __rest, __assign } from 'tslib';
+import { F as FronteggBaseProvider } from './FronteggBaseProvider-5529ded6.js';
+import '@frontegg/js';
+import '@frontegg/redux-store';
+import '@frontegg/rest-api';
+import React from 'react';
+import '@frontegg/react-hooks';
+import { useRouter } from 'next/navigation';
+
+var FronteggClientProviderNext13 = function (_a) {
+    var children = _a.children, basename = _a.basename, props = __rest(_a, ["children", "basename"]);
+    var router = useRouter();
+    var basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+    return (React.createElement(FronteggBaseProvider, __assign({ router: router, basename: basename !== null && basename !== void 0 ? basename : basePath }, props), children));
+};
+
+export { FronteggClientProviderNext13 as F };
+//# sourceMappingURL=FronteggClientProviderNext13-65bb4cd0.js.map

package/FronteggClientProviderNext13-65bb4cd0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FronteggClientProviderNext13-65bb4cd0.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/FronteggConfig-7ae86562.js

@@ -0,0 +1,123 @@
+import { __awaiter, __generator } from 'tslib';
+import { importJWK } from 'jose';
+
+function normalizeStringPasswordToMap(password) {
+    return typeof password === 'string' ? { 1: password } : password;
+}
+var FronteggConfig = /** @class */ (function () {
+    function FronteggConfig() {
+        var _a, _b, _c;
+        this.authRoutes = {};
+        this.fronteggAppOptions = {};
+        this._clientId = (_a = process.env['FRONTEGG_CLIENT_ID']) !== null && _a !== void 0 ? _a : '';
+        this._cookieName = (_b = process.env['FRONTEGG_COOKIE_NAME']) !== null && _b !== void 0 ? _b : "fe_next_session";
+        this._password = (_c = process.env['FRONTEGG_ENCRYPTION_PASSWORD']) !== null && _c !== void 0 ? _c : '';
+        this._passwordsAsMap = normalizeStringPasswordToMap(this._password);
+    }
+    Object.defineProperty(FronteggConfig.prototype, "cookieName", {
+        get: function () {
+            return this._cookieName + "-" + this._clientId.replace(/-/g, '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "password", {
+        get: function () {
+            return this._password;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "clientId", {
+        get: function () {
+            return this._clientId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "baseUrlHost", {
+        get: function () {
+            var _a;
+            return new URL((_a = process.env['FRONTEGG_BASE_URL']) !== null && _a !== void 0 ? _a : '').hostname;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FronteggConfig.prototype.getEnvAppUrl = function () {
+        var url = undefined;
+        if (process.env['FRONTEGG_APP_URL']) {
+            url = process.env['FRONTEGG_APP_URL'];
+        }
+        else if (process.env['VERCEL'] && process.env['VERCEL_URL']) {
+            url = process.env['VERCEL_URL'];
+        }
+        if (url && !url.startsWith('http')) {
+            var protocol = url.startsWith('localhost') ? 'http://' : 'https://';
+            url = "" + protocol + url;
+        }
+        return url;
+    };
+    Object.defineProperty(FronteggConfig.prototype, "appUrl", {
+        get: function () {
+            var _a;
+            return (_a = this.getEnvAppUrl()) !== null && _a !== void 0 ? _a : 'http://localhost:3000';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "appEnvConfig", {
+        get: function () {
+            return {
+                envAppUrl: this.getEnvAppUrl(),
+                envBaseUrl: process.env['FRONTEGG_BASE_URL'],
+                envClientId: process.env['FRONTEGG_CLIENT_ID'],
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "cookieDomain", {
+        get: function () {
+            var _a;
+            return new URL((_a = this.getEnvAppUrl()) !== null && _a !== void 0 ? _a : '').hostname.replace(/:(\d)+$/, '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FronteggConfig.prototype.getJwtPublicKey = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, data, publicKey, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this._jwtPublicKey) return [3 /*break*/, 4];
+                        return [4 /*yield*/, fetch(process.env['FRONTEGG_BASE_URL'] + "/.well-known/jwks.json")];
+                    case 1:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        data = _b.sent();
+                        publicKey = data.keys.find(function (key) { return key.kty === 'RSA'; });
+                        _a = this;
+                        return [4 /*yield*/, importJWK(publicKey)];
+                    case 3:
+                        _a._jwtPublicKey = _b.sent();
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, this._jwtPublicKey];
+                }
+            });
+        });
+    };
+    Object.defineProperty(FronteggConfig.prototype, "passwordsAsMap", {
+        get: function () {
+            return this._passwordsAsMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return FronteggConfig;
+}());
+var FronteggConfig$1 = new FronteggConfig();
+
+export { FronteggConfig$1 as F };
+//# sourceMappingURL=FronteggConfig-7ae86562.js.map

package/FronteggConfig-7ae86562.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FronteggConfig-7ae86562.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/FronteggProvider.d.ts

@@ -1,12 +1,3 @@
-import { FC, ReactNode } from 'react';
-import { FronteggAppOptions } from '@frontegg/types';
-import { MeAndTenants, FronteggNextJSSession } from './types';
-export declare type FronteggProviderProps = Omit<FronteggAppOptions, 'contextOptions'> & MeAndTenants & {
-    children?: ReactNode;
-    session?: FronteggNextJSSession;
-    envAppUrl: string;
-    envBaseUrl: string;
-    envClientId: string;
-    contextOptions?: Omit<FronteggAppOptions['contextOptions'], 'baseUrl'>;
-};
-export declare const FronteggProvider: FC<FronteggProviderProps>;
+import { FC } from 'react';
+import { FronteggProviderProps } from './common';
+export declare const FronteggProvider: FC<Omit<FronteggProviderProps, 'router'>>;

package/FronteggProviderNoSSR.d.ts

@@ -1,6 +1,4 @@
-import { FC, ReactNode } from 'react';
 import { FronteggAppOptions } from '@frontegg/types';
-export declare type FronteggProviderNoSSRProps = FronteggAppOptions & {
-    children?: ReactNode;
-};
+import { FC, PropsWithChildren } from 'react';
+export declare type FronteggProviderNoSSRProps = PropsWithChildren<FronteggAppOptions>;
 export declare const FronteggProviderNoSSR: FC<FronteggProviderNoSSRProps>;

package/README.md

@@ -228,6 +228,57 @@ export const getServerSideProps: GetServerSideProps = withSSRSession(
 );
 ```
 
+## Next.js 13
+### wrapping your application
+```ts
+// app/layout.tsx
+import { FronteggAppProvider } from '@frontegg/nextjs/server';
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <FronteggAppProvider hostedLoginBox>
+      <html>
+        <head></head>
+        <body>{children}</body>
+      </html>
+    </FronteggAppProvider>
+  );
+}
+```
+
+### routing
+```ts
+// app/[...frontegg-router]/page.tsx
+export { FronteggAppRouter as default } from '@frontegg/nextjs/client';
+```
+
+### server component
+```ts
+// app/ServerComponent.tsx
+import { getUserSession } from '@frontegg/nextjs/server';
+
+export const ServerComponent = async () => {
+  const userSession = await getUserSession();
+  return (
+    <div>
+      user session server side: {JSON.stringify(userSession)}
+    </div>
+  );
+};
+```
+
+### client component
+```ts
+// app/ClientComponent.tsx
+'use client';
+import { useAuthUserOrNull } from '@frontegg/nextjs';
+
+export const ClientComponent = () => {
+  const user = useAuthUserOrNull();
+  return <div>user session client side: {JSON.stringify(user)}</div>;
+};
+```
+
 ## Next.js middlewares usage
 
 To prevent access unauthenticated user to all routes, use [Next.js middlewares](https://nextjs.org/docs/advanced-features/middleware).
@@ -238,16 +289,17 @@ To prevent access unauthenticated user to all routes, use [Next.js middlewares](
 // /middleware.ts
 import { NextResponse } from "next/server";
 import type { NextRequest } from "next/server";
-import { getSession } from '@frontegg/nextjs';
+import { getSession } from '@frontegg/nextjs/edge';
 
 export const middleware = async (request: NextRequest) => {
   const session = await getSession(request);
+  const isAuthRoute = [...your auth routes]
 
   console.log("middleware session", session);
-  
-  if(!session){
+
+  if(!session && isAuthRoute){
     // redirect unauthenticated user to /account/login page
-    return NextResponse.redirect(new URL('/account/login', req.url))
+    return NextResponse.redirect(new URL('/account/login', request))
   }
   
   return NextResponse.next();

package/api-70f0e81e.js

@@ -0,0 +1,58 @@
+import { __awaiter, __generator } from 'tslib';
+import { fronteggUsersUrl, fronteggTenantsUrl } from '@frontegg/rest-api';
+
+var BASE_URL = process.env['FRONTEGG_BASE_URL'] + "/frontegg";
+var Get = function (_a) {
+    var url = _a.url, _b = _a.credentials, credentials = _b === void 0 ? 'include' : _b, headers = _a.headers;
+    return fetch(url, { method: 'GET', credentials: credentials, headers: headers });
+};
+var extractHeaders = function (headers) { return ({
+    'accept-encoding': headers['accept-encoding'],
+    'accept-language': headers['accept-language'],
+    cookie: headers['cookie'],
+    accept: headers['accept'],
+    'user-agent': headers['user-agent'],
+    // connection: headers['connection'],
+    'cache-control': headers['cache-control'],
+    Authorization: headers['Authorization'],
+}); };
+var parseResponse = function (res) { return __awaiter(void 0, void 0, void 0, function () {
+    var resText;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!res.ok) {
+                    return [2 /*return*/, undefined];
+                }
+                return [4 /*yield*/, res.text()];
+            case 1:
+                resText = _a.sent();
+                return [2 /*return*/, JSON.parse(resText)];
+        }
+    });
+}); };
+var getUsers = function (headers) { return __awaiter(void 0, void 0, void 0, function () {
+    var res;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, Get({ url: "" + BASE_URL + fronteggUsersUrl, headers: extractHeaders(headers) })];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, parseResponse(res)];
+        }
+    });
+}); };
+var getTenants = function (headers) { return __awaiter(void 0, void 0, void 0, function () {
+    var res;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, Get({ url: "" + BASE_URL + fronteggTenantsUrl, headers: extractHeaders(headers) })];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, parseResponse(res)];
+        }
+    });
+}); };
+
+export { getTenants as a, getUsers as g };
+//# sourceMappingURL=api-70f0e81e.js.map

package/api-70f0e81e.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-70f0e81e.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/client/FronteggAppRouter.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { ParsedUrlQuery } from 'querystring';
+declare type FronteggRouterProps = {
+    params: ParsedUrlQuery & {
+        'frontegg-router'?: string[];
+    };
+    searchParams: ParsedUrlQuery;
+};
+export declare function FronteggAppRouter({ params: { 'frontegg-router': pathArr }, searchParams }: FronteggRouterProps): string;
+export {};

package/client/FronteggClientProviderNext13.d.ts

@@ -0,0 +1,3 @@
+import { FronteggProviderProps } from '../common';
+import { FC } from 'react';
+export declare const FronteggClientProviderNext13: FC<Omit<FronteggProviderProps, 'router'>>;

package/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FronteggAppRouter';
+export * from './FronteggClientProviderNext13';

package/client/index.js

@@ -0,0 +1,63 @@
+'use client'; 
+ import { __assign, __spreadArrays } from 'tslib';
+import { F as FronteggConfig } from '../FronteggConfig-7ae86562.js';
+import '../api-70f0e81e.js';
+import 'cookie';
+import 'iron-session';
+import 'jose';
+import { useLoginWithRedirect, useLoginActions } from '@frontegg/react-hooks';
+import '@frontegg/rest-api';
+import { useContext, useEffect } from 'react';
+import { A as AppContext } from '../FronteggBaseProvider-5529ded6.js';
+import '@frontegg/js';
+import { authInitialState } from '@frontegg/redux-store';
+import { useRouter, notFound } from 'next/navigation';
+export { F as FronteggClientProviderNext13 } from '../FronteggClientProviderNext13-65bb4cd0.js';
+
+function FronteggAppRouter(_a) {
+    var _b = _a.params["frontegg-router"], pathArr = _b === void 0 ? [] : _b, searchParams = _a.searchParams;
+    var routesObj = __assign(__assign({}, authInitialState.routes), FronteggConfig.authRoutes);
+    var routesArr = Object.keys(routesObj).reduce(function (p, key) { return __spreadArrays(p, [routesObj[key]]); }, []);
+    var app = useContext(AppContext);
+    var replace = useRouter().replace;
+    var loginWithRedirect = useLoginWithRedirect();
+    var logout = useLoginActions().logout;
+    var pathname = "/" + pathArr.join('/');
+    if (!pathname || pathname.startsWith('/_next/data')) {
+        var query = searchParams[Object.keys(searchParams)[0]];
+        pathname = "/" + (Array.isArray(query) ? query.join('/') : query);
+    }
+    if (routesArr.indexOf(pathname) === -1) {
+        notFound();
+    }
+    if (FronteggConfig.fronteggAppOptions.hostedLoginBox &&
+        routesObj.loginUrl !== pathname &&
+        routesObj.logoutUrl !== pathname &&
+        routesObj.hostedLoginRedirectUrl !== pathname) {
+        notFound();
+    }
+    useEffect(function () {
+        if (!app) {
+            return;
+        }
+        if (app.options.hostedLoginBox) {
+            if (pathname === routesObj.loginUrl) {
+                if (searchParams.redirectUrl) {
+                    localStorage.setItem('FRONTEGG_AFTER_AUTH_REDIRECT_URL', "" + window.location.origin + searchParams.redirectUrl);
+                }
+                loginWithRedirect();
+            }
+            else if (pathname === routesObj.logoutUrl) {
+                var _baseUrl = app.options.contextOptions.baseUrl;
+                var baseUrl_1 = typeof _baseUrl === 'string' ? _baseUrl : _baseUrl('');
+                logout(function () {
+                    window.location.href = baseUrl_1 + "/oauth/logout?post_logout_redirect_uri=" + encodeURIComponent(window.location.origin);
+                });
+            }
+        }
+    }, [app, searchParams, loginWithRedirect, logout, replace]);
+    return '';
+}
+
+export { FronteggAppRouter };
+//# sourceMappingURL=index.js.map

package/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/{FronteggConfig.d.ts → common/FronteggConfig.d.ts}

@@ -1,7 +1,7 @@
+import { AppEnvConfig } from './types';
 import { KeyLike } from 'jose';
 import { AuthPageRoutes } from '@frontegg/redux-store';
 import { FronteggAppOptions } from '@frontegg/types';
-import { AppEnvConfig } from './types';
 export declare type PasswordsMap = {
     [id: string]: string;
 };

package/common/client/ExpireInListener.d.ts

@@ -0,0 +1 @@
+export declare const ExpireInListener: () => JSX.Element;

package/common/client/FronteggBaseProvider.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { FronteggProviderProps } from '../types';
+export declare const FronteggBaseProvider: FC<FronteggProviderProps>;

package/common/client/createOrGetFronteggApp.d.ts

@@ -0,0 +1,11 @@
+import { FronteggApp } from '@frontegg/js';
+import { AuthState } from '@frontegg/redux-store';
+import { FronteggProviderOptions, MeAndTenantsResponse } from '../types';
+declare type CreateOrGetFronteggAppParams = {
+    options: FronteggProviderOptions;
+    onRedirectTo: AuthState['onRedirectTo'];
+    appName?: string;
+    storeHolder: any;
+} & MeAndTenantsResponse;
+export declare const createOrGetFronteggApp: ({ options, onRedirectTo, appName, user, tenants, storeHolder, }: CreateOrGetFronteggAppParams) => FronteggApp;
+export {};

package/common/client/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useRequestAuthorizeSSR';

package/common/client/hooks/useRequestAuthorizeSSR.d.ts

@@ -0,0 +1,9 @@
+import { FronteggApp } from '@frontegg/js';
+import { MeAndTenantsResponse } from '../../types';
+declare type useRequestAuthorizeSSR = {
+    app: FronteggApp;
+    accessToken?: string;
+    refreshToken?: string;
+} & MeAndTenantsResponse;
+export declare const useRequestAuthorizeSSR: ({ app, accessToken, user, tenants, refreshToken }: useRequestAuthorizeSSR) => void;
+export {};

package/common/client/index.d.ts

@@ -0,0 +1,4 @@
+export * from './FronteggBaseProvider';
+export { default as AppContext } from './AppContext';
+export * from './createOrGetFronteggApp';
+export * from './ExpireInListener';

package/common/getMeAndTenants.d.ts

@@ -0,0 +1,2 @@
+import { MeAndTenantsResponse } from './types';
+export declare function getMeAndTenants(reqHeaders?: Record<string, string | string[] | null | undefined>, accessToken?: string): Promise<MeAndTenantsResponse>;

package/{helpers.d.ts → common/helpers.d.ts}

@@ -1,9 +1,9 @@
 /// <reference types="node" />
-import { ServerResponse } from 'http';
 import { CookieSerializeOptions } from 'cookie';
-import { NextPageContext } from 'next/dist/shared/lib/utils';
-import { FronteggNextJSSession, MeAndTenants } from './types';
-export declare function refreshToken(ctx: NextPageContext): Promise<FronteggNextJSSession | null>;
+import { ServerResponse } from 'http';
+import { RequestCookie } from 'next/dist/server/web/spec-extension/cookies';
+import { FronteggUserTokens } from './types';
+export declare function rewriteCookieProperty(header: string | string[], config: any, property: string): string | string[];
 declare type CreateCookieArguments = {
     cookieName?: string;
     session: string;
@@ -13,13 +13,11 @@ declare type CreateCookieArguments = {
     httpOnly?: CookieSerializeOptions['httpOnly'];
     path?: CookieSerializeOptions['path'];
 };
-export declare function createCookie({ cookieName, session, expires, isSecured, cookieDomain, httpOnly, path }: CreateCookieArguments): string[];
-export declare function parseCookie(cookieStr: string): string | undefined;
+export declare function createCookie({ cookieName, session, expires, isSecured, cookieDomain, httpOnly, path, }: CreateCookieArguments): string[];
+export declare function parseCookieFromArray(cookies: RequestCookie[]): string | undefined;
 export declare function addToCookies(newCookies: string[], res: ServerResponse): void;
 export declare function removeCookies(cookieName: string, isSecured: boolean, cookieDomain: string, res: ServerResponse): void;
-export declare function compress(input: string): Promise<string>;
-export declare function uncompress(input: string): Promise<string>;
 export declare function createSessionFromAccessToken(output: string): Promise<[string, any, string] | []>;
 export declare const modifySetCookieIfUnsecure: (setCookieValue: string[] | undefined, isSecured: boolean) => string[] | undefined;
-export declare function meAndTenants(ctx: NextPageContext, accessToken?: string): Promise<MeAndTenants>;
+export declare function getTokensFromCookie(cookie?: string): Promise<FronteggUserTokens | undefined>;
 export {};

package/common/index.d.ts

@@ -0,0 +1,6 @@
+export { default as FronteggConfig } from './FronteggConfig';
+export * from './types';
+export * from './getMeAndTenants';
+export * from './helpers';
+export * from './utils';
+export * from './consts';