@frontegg/nextjs 6.7.9-alpha.3787429476 → 6.7.9-alpha.3787447063

package/CHANGELOG.md

@@ -5,6 +5,7 @@
 
 ### NextJS Wrapper 6.7.9:
 - FR-10166 - update code owners
+- FR-10132 - split cookie and type fixes
 - FR-10106-FR-10103- Make package output both cjs and esm and support useAuthUser for SSR
 
 ## [6.7.8](https://github.com/frontegg/frontegg-nextjs/compare/v6.7.7...v6.7.8) (2022-12-20)

package/CookieManager-c1d6c5b0.js

@@ -0,0 +1,303 @@
+import { __awaiter, __generator, __spreadArray } from 'tslib';
+import cookie from 'cookie';
+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 "".concat(this._cookieName, "-").concat(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 = "".concat(protocol).concat(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("".concat(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();
+
+function chunkString(str, chunkSize) {
+    var numChunks = Math.ceil(str.length / chunkSize);
+    var chunks = [];
+    for (var i = 0; i < numChunks; i++) {
+        var start = i * chunkSize;
+        var end = start + chunkSize;
+        chunks.push(str.substring(start, end < str.length ? end : str.length));
+    }
+    return chunks;
+}
+
+var COOKIE_MAX_LENGTH = 4096;
+var CookieManager = /** @class */ (function () {
+    function CookieManager() {
+        var _this = this;
+        this.getCookieName = function (cookieNumber, cookieName) {
+            return "".concat(cookieName !== null && cookieName !== void 0 ? cookieName : FronteggConfig$1.cookieName, "-").concat(cookieNumber);
+        };
+        this.mapValueChunksToCookies = function (cookieName, valueChunks, options) {
+            return valueChunks.map(function (chunk, index) { return cookie.serialize(_this.getCookieName(index + 1, cookieName), chunk, options); });
+        };
+        this.getCookieStringFromRequest = function (req) {
+            return 'credentials' in req ? req.headers.get('cookie') || '' : req.headers.cookie || '';
+        };
+        this.createEmptySingleCookie = function (cookieName, isSecured, cookieDomain) {
+            return _this.createCookie({ cookieName: cookieName, value: '', expires: new Date(), isSecured: isSecured, cookieDomain: cookieDomain });
+        };
+        this.createEmptyCookies = function (isSecured, cookieDomain, cookiesToRemove) {
+            var allEmptyCookies = [];
+            cookiesToRemove.forEach(function (name) {
+                allEmptyCookies.push.apply(allEmptyCookies, _this.createEmptySingleCookie(name, isSecured, cookieDomain));
+            });
+            return allEmptyCookies;
+        };
+        this.getCookiesToRemove = function (req) {
+            if (!req) {
+                return [];
+            }
+            try {
+                var cookieStr = _this.getCookieStringFromRequest(req);
+                var allCookies = cookieStr && cookie.parse(cookieStr);
+                if (!allCookies) {
+                    return [];
+                }
+                var cookieNumber = 1;
+                var cookieToRemove = [];
+                while (allCookies[_this.getCookieName(cookieNumber)]) {
+                    cookieToRemove.push(_this.getCookieName(cookieNumber));
+                    cookieNumber++;
+                }
+                return cookieToRemove;
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+        };
+        this.modifySetCookieIfUnsecure = function (setCookieValue, isSecured) {
+            if (!setCookieValue) {
+                return setCookieValue;
+            }
+            if (setCookieValue.length > 0) {
+                return setCookieValue.map(function (c) {
+                    var cookie = c.split('; ');
+                    if (isSecured) {
+                        return c;
+                    }
+                    return cookie.filter(function (property) { return property !== 'Secure' && property !== 'SameSite=None'; }).join('; ');
+                });
+            }
+            return setCookieValue;
+        };
+    }
+    CookieManager.prototype.rewriteCookieProperty = function (header, config, property) {
+        var _this = this;
+        if (Array.isArray(header)) {
+            return header.map(function (headerElement) {
+                return _this.rewriteCookieProperty(headerElement, config, property);
+            });
+        }
+        return header.replace(new RegExp('(;\\s*' + property + '=)([^;]+)', 'i'), function (match, prefix, previousValue) {
+            var newValue;
+            if (previousValue in config) {
+                newValue = config[previousValue];
+            }
+            else if ('*' in config) {
+                newValue = config['*'];
+            }
+            else {
+                // no match, return previous value
+                return match;
+            }
+            if (newValue) {
+                // replace value
+                return prefix + newValue;
+            }
+            else {
+                // remove value
+                return '';
+            }
+        });
+    };
+    CookieManager.prototype.createCookie = function (_a) {
+        var cookieName = _a.cookieName, value = _a.value, expires = _a.expires, isSecured = _a.isSecured, _b = _a.cookieDomain, cookieDomain = _b === void 0 ? FronteggConfig$1.cookieDomain : _b, _c = _a.httpOnly, httpOnly = _c === void 0 ? true : _c, _d = _a.path, path = _d === void 0 ? '/' : _d;
+        var options = {
+            expires: expires,
+            httpOnly: httpOnly,
+            domain: cookieDomain,
+            path: path,
+            sameSite: isSecured ? 'none' : undefined,
+            secure: isSecured,
+        };
+        var cookieValue = cookie.serialize(cookieName !== null && cookieName !== void 0 ? cookieName : this.getCookieName(1), value, options);
+        if (cookieValue.length < COOKIE_MAX_LENGTH) {
+            return [cookieValue];
+        }
+        var valueChunks = this.splitValueToChunks(cookieName, value, options);
+        return this.mapValueChunksToCookies(cookieName, valueChunks, options);
+    };
+    CookieManager.prototype.splitValueToChunks = function (cookieName, value, options) {
+        var cookieOptionLength = cookie.serialize(this.getCookieName(1, cookieName), '', options).length;
+        var maxValueLength = COOKIE_MAX_LENGTH - cookieOptionLength;
+        return chunkString(value, maxValueLength);
+    };
+    CookieManager.prototype.getParsedCookieFromRequest = function (req) {
+        if (!req) {
+            return undefined;
+        }
+        var cookieStr = this.getCookieStringFromRequest(req);
+        return this.parseCookie(cookieStr);
+    };
+    CookieManager.prototype.parseCookie = function (cookieStr) {
+        var sealFromCookies = '';
+        var i = 1;
+        while (cookie.parse(cookieStr)[this.getCookieName(i)]) {
+            sealFromCookies += cookie.parse(cookieStr)[this.getCookieName(i)];
+            i++;
+        }
+        return sealFromCookies !== '' ? sealFromCookies : undefined;
+    };
+    CookieManager.prototype.parseCookieFromArray = function (cookies) {
+        var userCookie = cookies.find(function (c) { return c.name === FronteggConfig$1.cookieName; });
+        if (userCookie) {
+            return userCookie.value;
+        }
+        var cookieChunks = cookies.filter(function (c) { return c.name.includes(FronteggConfig$1.cookieName); });
+        if (!cookieChunks) {
+            return undefined;
+        }
+        cookieChunks.sort(function (a, b) {
+            var firstCookieNumber = parseInt(a.name.slice(-1));
+            var secondCookieNumber = parseInt(b.name.slice(-1));
+            return firstCookieNumber > secondCookieNumber ? 1 : -1;
+        });
+        return cookieChunks.map(function (c) { return c.value; }).join('');
+    };
+    CookieManager.prototype.addToCookies = function (newCookies, res) {
+        var _a;
+        var existingSetCookie = (_a = res.getHeader('set-cookie')) !== null && _a !== void 0 ? _a : [];
+        if (typeof existingSetCookie === 'string') {
+            existingSetCookie = [existingSetCookie];
+        }
+        res.setHeader('set-cookie', __spreadArray(__spreadArray([], existingSetCookie, true), newCookies, true));
+    };
+    CookieManager.prototype.removeCookies = function (_a) {
+        var _b;
+        var cookieNames = _a.cookieNames, isSecured = _a.isSecured, cookieDomain = _a.cookieDomain, res = _a.res, req = _a.req;
+        var cookiesToRemove = this.getCookiesToRemove(req);
+        var cookieValue = this.createEmptyCookies(isSecured, cookieDomain, cookieNames !== null && cookieNames !== void 0 ? cookieNames : cookiesToRemove);
+        var existingSetCookie = (_b = res.getHeader('set-cookie')) !== null && _b !== void 0 ? _b : [];
+        if (typeof existingSetCookie === 'string') {
+            existingSetCookie = [existingSetCookie];
+        }
+        res.setHeader('set-cookie', __spreadArray(__spreadArray([], existingSetCookie, true), cookieValue, true));
+    };
+    return CookieManager;
+}());
+var CookieManager$1 = new CookieManager();
+
+export { CookieManager$1 as C, FronteggConfig$1 as F };
+//# sourceMappingURL=CookieManager-c1d6c5b0.js.map

package/CookieManager-c1d6c5b0.js.map

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

package/{FronteggClientProviderNext13-b55f477b.js → FronteggClientProviderNext13-3259fcd9.js}

@@ -18,7 +18,7 @@ var createOrGetFronteggApp = function (_a) {
                 path.endsWith('/postlogin') ||
                 path.endsWith('/prelogin') ||
                 path === '/oauth/token') {
-                return options.envAppUrl + "/api";
+                return "".concat(options.envAppUrl, "/api");
             }
             else {
                 return options.envBaseUrl;
@@ -39,9 +39,7 @@ var createOrGetFronteggApp = function (_a) {
         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');
+        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;
 };
@@ -85,7 +83,7 @@ var Connector = function (_a) {
             path = path.substring(baseName.length);
         }
         if (opts === null || opts === void 0 ? void 0 : opts.preserveQueryParams) {
-            path = "" + path + window.location.search;
+            path = "".concat(path).concat(window.location.search);
         }
         if ((opts === null || opts === void 0 ? void 0 : opts.refresh) && !isSSR) {
             // @ts-ignore
@@ -124,4 +122,4 @@ var FronteggClientProviderNext13 = function (_a) {
 };
 
 export { AppContext as A, FronteggClientProviderNext13 as F };
-//# sourceMappingURL=FronteggClientProviderNext13-b55f477b.js.map
+//# sourceMappingURL=FronteggClientProviderNext13-3259fcd9.js.map

package/FronteggClientProviderNext13-3259fcd9.js.map

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

package/FronteggProviderNoSSR.d.ts

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

package/{api-70f0e81e.js → api-25516652.js}

@@ -1,7 +1,7 @@
 import { __awaiter, __generator } from 'tslib';
 import { fronteggUsersUrl, fronteggTenantsUrl } from '@frontegg/rest-api';
 
-var BASE_URL = process.env['FRONTEGG_BASE_URL'] + "/frontegg";
+var BASE_URL = "".concat(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 });
@@ -35,7 +35,7 @@ var getUsers = function (headers) { return __awaiter(void 0, void 0, void 0, fun
     var res;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, Get({ url: "" + BASE_URL + fronteggUsersUrl, headers: extractHeaders(headers) })];
+            case 0: return [4 /*yield*/, Get({ url: "".concat(BASE_URL).concat(fronteggUsersUrl), headers: extractHeaders(headers) })];
             case 1:
                 res = _a.sent();
                 return [2 /*return*/, parseResponse(res)];
@@ -46,7 +46,7 @@ var getTenants = function (headers) { return __awaiter(void 0, void 0, void 0, f
     var res;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, Get({ url: "" + BASE_URL + fronteggTenantsUrl, headers: extractHeaders(headers) })];
+            case 0: return [4 /*yield*/, Get({ url: "".concat(BASE_URL).concat(fronteggTenantsUrl), headers: extractHeaders(headers) })];
             case 1:
                 res = _a.sent();
                 return [2 /*return*/, parseResponse(res)];
@@ -55,4 +55,4 @@ var getTenants = function (headers) { return __awaiter(void 0, void 0, void 0, f
 }); };
 
 export { getTenants as a, getUsers as g };
-//# sourceMappingURL=api-70f0e81e.js.map
+//# sourceMappingURL=api-25516652.js.map

package/api-25516652.js.map

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

package/client/FronteggAppRouter.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { ParsedUrlQuery } from 'querystring';
-declare type FronteggRouterProps = {
+type FronteggRouterProps = {
     params: ParsedUrlQuery & {
         'frontegg-router'?: string[];
     };

package/client/index.js

@@ -1,31 +1,31 @@
 'use client'; 
- import { __assign, __spreadArrays } from 'tslib';
-import { F as FronteggConfig } from '../FronteggConfig-7ae86562.js';
-import '../api-70f0e81e.js';
-import 'cookie';
+ import { __assign, __spreadArray } from 'tslib';
+import { F as FronteggConfig } from '../CookieManager-c1d6c5b0.js';
+import '../api-25516652.js';
 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 '../FronteggClientProviderNext13-b55f477b.js';
-export { F as FronteggClientProviderNext13 } from '../FronteggClientProviderNext13-b55f477b.js';
+import { A as AppContext } from '../FronteggClientProviderNext13-3259fcd9.js';
+export { F as FronteggClientProviderNext13 } from '../FronteggClientProviderNext13-3259fcd9.js';
 import '@frontegg/js';
 import { authInitialState } from '@frontegg/redux-store';
 import { useRouter, notFound } from 'next/navigation';
+import 'cookie';
 
 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 routesArr = Object.keys(routesObj).reduce(function (p, key) { return __spreadArray(__spreadArray([], p, true), [routesObj[key]], false); }, []);
     var app = useContext(AppContext);
     var replace = useRouter().replace;
     var loginWithRedirect = useLoginWithRedirect();
     var logout = useLoginActions().logout;
-    var pathname = "/" + pathArr.join('/');
+    var pathname = "/".concat(pathArr.join('/'));
     if (!pathname || pathname.startsWith('/_next/data')) {
         var query = searchParams[Object.keys(searchParams)[0]];
-        pathname = "/" + (Array.isArray(query) ? query.join('/') : query);
+        pathname = "/".concat(Array.isArray(query) ? query.join('/') : query);
     }
     if (routesArr.indexOf(pathname) === -1) {
         notFound();
@@ -43,7 +43,7 @@ function FronteggAppRouter(_a) {
         if (app.options.hostedLoginBox) {
             if (pathname === routesObj.loginUrl) {
                 if (searchParams.redirectUrl) {
-                    localStorage.setItem('FRONTEGG_AFTER_AUTH_REDIRECT_URL', "" + window.location.origin + searchParams.redirectUrl);
+                    localStorage.setItem('FRONTEGG_AFTER_AUTH_REDIRECT_URL', "".concat(window.location.origin).concat(searchParams.redirectUrl));
                 }
                 loginWithRedirect();
             }
@@ -51,7 +51,7 @@ function FronteggAppRouter(_a) {
                 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);
+                    window.location.href = "".concat(baseUrl_1, "/oauth/logout?post_logout_redirect_uri=").concat(encodeURIComponent(window.location.origin));
                 });
             }
         }

package/common/CookieManager.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import { CookieSerializeOptions } from 'cookie';
+import { ServerResponse } from 'http';
+import { RequestCookie } from 'next/dist/server/web/spec-extension/cookies';
+import { RequestType } from './types';
+type CreateCookieArguments = {
+    cookieName?: string;
+    value: string;
+    expires: CookieSerializeOptions['expires'];
+    isSecured: CookieSerializeOptions['secure'];
+    cookieDomain?: CookieSerializeOptions['domain'];
+    httpOnly?: CookieSerializeOptions['httpOnly'];
+    path?: CookieSerializeOptions['path'];
+};
+type RemoveCookiesArguments = {
+    cookieNames?: string[];
+    isSecured: boolean;
+    cookieDomain: string;
+    res: ServerResponse;
+    req?: RequestType;
+};
+declare class CookieManager {
+    constructor();
+    getCookieName: (cookieNumber: number, cookieName?: string) => string;
+    rewriteCookieProperty(header: string | string[], config: any, property: string): string | string[];
+    createCookie({ cookieName, value, expires, isSecured, cookieDomain, httpOnly, path, }: CreateCookieArguments): string[];
+    splitValueToChunks(cookieName: string | undefined, value: string, options: CookieSerializeOptions): string[];
+    mapValueChunksToCookies: (cookieName: string | undefined, valueChunks: string[], options: CookieSerializeOptions) => string[];
+    getCookieStringFromRequest: (req: RequestType) => string;
+    getParsedCookieFromRequest(req?: RequestType): string | undefined;
+    parseCookie(cookieStr: string): string | undefined;
+    parseCookieFromArray(cookies: RequestCookie[]): string | undefined;
+    addToCookies(newCookies: string[], res: ServerResponse): void;
+    createEmptySingleCookie: (cookieName: string, isSecured: boolean, cookieDomain: string) => string[];
+    createEmptyCookies: (isSecured: boolean, cookieDomain: string, cookiesToRemove: string[]) => string[];
+    getCookiesToRemove: (req?: RequestType) => string[];
+    removeCookies({ cookieNames, isSecured, cookieDomain, res, req }: RemoveCookiesArguments): void;
+    modifySetCookieIfUnsecure: (setCookieValue: string[] | undefined, isSecured: boolean) => string[] | undefined;
+}
+declare const _default: CookieManager;
+export default _default;

package/common/FronteggConfig.d.ts

@@ -2,10 +2,10 @@ import { AppEnvConfig } from './types';
 import { KeyLike } from 'jose';
 import { AuthPageRoutes } from '@frontegg/redux-store';
 import { FronteggAppOptions } from '@frontegg/types';
-export declare type PasswordsMap = {
+export type PasswordsMap = {
     [id: string]: string;
 };
-export declare type Password = string | PasswordsMap;
+export type Password = string | PasswordsMap;
 export declare function normalizeStringPasswordToMap(password: Password): PasswordsMap;
 declare class FronteggConfig {
     private readonly _cookieName;

package/common/client/createOrGetFronteggApp.d.ts

@@ -1,7 +1,7 @@
 import { FronteggApp } from '@frontegg/js';
 import { AuthState } from '@frontegg/redux-store';
 import { FronteggProviderOptions, MeAndTenantsResponse } from '../types';
-declare type CreateOrGetFronteggAppParams = {
+type CreateOrGetFronteggAppParams = {
     options: FronteggProviderOptions;
     onRedirectTo: AuthState['onRedirectTo'];
     appName?: string;

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

@@ -1,6 +1,6 @@
 import { FronteggApp } from '@frontegg/js';
 import { MeAndTenantsResponse } from '../../types';
-declare type useRequestAuthorizeSSR = {
+type useRequestAuthorizeSSR = {
     app: FronteggApp;
     accessToken?: string;
     refreshToken?: string;

package/common/{utils/createGetSession.d.ts → createGetSession.d.ts}

@@ -1,5 +1,5 @@
-import { FronteggNextJSSession, FronteggUserTokens } from '../types';
-declare type CreateGetSessionParams = {
+import { FronteggNextJSSession, FronteggUserTokens } from './types';
+type CreateGetSessionParams = {
     getCookie: () => string | undefined;
     cookieResolver: (cookie: string) => Promise<FronteggUserTokens | undefined>;
 };

package/common/helpers.d.ts

@@ -1,23 +1,3 @@
-/// <reference types="node" />
-import { CookieSerializeOptions } from 'cookie';
-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;
-    expires: CookieSerializeOptions['expires'];
-    isSecured: CookieSerializeOptions['secure'];
-    cookieDomain?: CookieSerializeOptions['domain'];
-    httpOnly?: CookieSerializeOptions['httpOnly'];
-    path?: CookieSerializeOptions['path'];
-};
-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 createSessionFromAccessToken(output: string): Promise<[string, any, string] | []>;
-export declare const modifySetCookieIfUnsecure: (setCookieValue: string[] | undefined, isSecured: boolean) => string[] | undefined;
 export declare function getTokensFromCookie(cookie?: string): Promise<FronteggUserTokens | undefined>;
-export {};

package/common/index.d.ts

@@ -2,5 +2,6 @@ export { default as FronteggConfig } from './FronteggConfig';
 export * from './types';
 export * from './getMeAndTenants';
 export * from './helpers';
-export * from './utils';
+export * from './createGetSession';
 export * from './consts';
+export { default as CookieManager } from './CookieManager';

package/common/index.js

@@ -1,15 +1,14 @@
-export { F as FronteggConfig } from '../FronteggConfig-7ae86562.js';
-export { b as addToCookies, c as createCookie, e as createSessionFromAccessToken, a as getMeAndTenants, g as getTokensFromCookie, m as modifySetCookieIfUnsecure, p as parseCookieFromArray, d as removeCookies, r as rewriteCookieProperty } from '../helpers-dac4dc7b.js';
-export { g as getCookieFromRequest, p as parseCookie } from '../getCookieFromRequest-624c37b5.js';
-export { c as createGetSession } from '../createGetSession-81b1748e.js';
+export { C as CookieManager, F as FronteggConfig } from '../CookieManager-c1d6c5b0.js';
+export { c as createSessionFromAccessToken, a as getMeAndTenants, g as getTokensFromCookie } from '../helpers-942ef431.js';
+export { c as createGetSession } from '../createGetSession-b2281638.js';
 import 'tslib';
+import 'cookie';
 import 'jose';
-import '../api-70f0e81e.js';
+import '../api-25516652.js';
 import '@frontegg/rest-api';
-import 'cookie';
 import 'iron-session';
 
-var envError = function (varName) { return "@frontegg/nextjs: .env.local must contain " + varName; };
+var envError = function (varName) { return "@frontegg/nextjs: .env.local must contain ".concat(varName); };
 var fronteggErrors = {
     envAppUrl: envError('FRONTEGG_APP_URL'),
     envBaseUrl: envError('FRONTEGG_BASE_URL'),

package/common/types.d.ts

@@ -4,7 +4,7 @@ import { IncomingMessage } from 'http';
 import { ReactNode } from 'react';
 import { AppRouterInstance } from 'next/dist/shared/lib/app-router-context';
 import { NextRouter } from 'next/router';
-export declare type RequestType = IncomingMessage | Request;
+export type RequestType = IncomingMessage | Request;
 export interface AccountEnvironment {
     id: string;
     createdAt: string;

package/common/utils.d.ts

@@ -0,0 +1 @@
+export declare function chunkString(str: string, chunkSize: number): string[];

package/{createGetSession-81b1748e.js → createGetSession-b2281638.js}

@@ -1,6 +1,6 @@
 import { __awaiter, __generator } from 'tslib';
 import { jwtVerify } from 'jose';
-import { F as FronteggConfig } from './FronteggConfig-7ae86562.js';
+import { F as FronteggConfig } from './CookieManager-c1d6c5b0.js';
 
 var createGetSession = function (_a) {
     var getCookie = _a.getCookie, cookieResolver = _a.cookieResolver;
@@ -47,4 +47,4 @@ var createGetSession = function (_a) {
 };
 
 export { createGetSession as c };
-//# sourceMappingURL=createGetSession-81b1748e.js.map
+//# sourceMappingURL=createGetSession-b2281638.js.map

package/createGetSession-b2281638.js.map

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