@plitzi/sdk-auth 0.30.19

package/dist/AuthContext.d.ts

@@ -0,0 +1,3 @@
+import { AuthContextValue } from '@plitzi/sdk-shared';
+export declare const AuthContext: import('react').Context<AuthContextValue>;
+export default AuthContext;

package/dist/AuthContext.mjs

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+var t = e({});
+t.displayName = "AuthContext";
+//#endregion
+export { t as default };

package/dist/AuthContextProvider.d.ts

@@ -0,0 +1,12 @@
+import { Environment, Server } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type AuthContextProviderProps = {
+    children?: ReactNode;
+    isHydrating?: boolean;
+    previewMode?: boolean;
+    offlineMode?: boolean;
+    server: Server;
+    environment?: Environment;
+};
+declare const AuthContextProvider: ({ previewMode, isHydrating, children, server, environment }: AuthContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default AuthContextProvider;

package/dist/AuthContextProvider.mjs

@@ -0,0 +1,98 @@
+import e from "./hooks/useAuth/index.mjs";
+import t from "./AuthContext.mjs";
+import { useMemo as n } from "react";
+import { QueryBuilderEvaluator as r } from "@plitzi/plitzi-ui/QueryBuilder";
+import i from "@plitzi/sdk-navigation/hooks/useNavigation";
+import { processTwig as a } from "@plitzi/sdk-shared/helpers/twigWrapper";
+import { createStoreHook as o } from "@plitzi/sdk-store/createStore";
+import { jsx as s } from "react/jsx-runtime";
+//#region src/AuthContextProvider.tsx
+var c = ({ previewMode: c = !0, isHydrating: l = !1, children: u, server: d, environment: f = "production" }) => {
+	let { useStore: p } = o(), [[{ userProvider: m, loginUrl: h, userUrl: g, refreshUrl: _, logoutUrl: v, tokenStorage: y = "localStorage", detailsPath: b = "details", tokenPath: x = "access_token", expirationTimePath: S = "expire_at" }, C]] = p(["schema.settings", "schema.variables"]), { queryParams: w, hostname: T } = i({ server: d }), E = n(() => ({
+		queryParams: w,
+		hostname: T,
+		environment: f
+	}), [
+		w,
+		T,
+		f
+	]), D = n(() => Array.isArray(C) ? C.reduce((e, t) => {
+		let { name: n, value: i, subValues: a } = t;
+		if (!Array.isArray(a) || a.length === 0) return {
+			...e,
+			[n]: i
+		};
+		let o = a.find((e) => r(e.when, E));
+		return o ? {
+			...e,
+			[n]: o.value
+		} : {
+			...e,
+			[n]: i
+		};
+	}, {}) : {}, [C, E]), O = n(() => {
+		try {
+			return JSON.parse(a(JSON.stringify({
+				loginUrl: h,
+				userUrl: g,
+				refreshUrl: _,
+				logoutUrl: v,
+				detailsPath: b,
+				tokenPath: x,
+				expirationTimePath: S
+			}), D));
+		} catch {
+			return {
+				loginUrl: h,
+				userUrl: g,
+				refreshUrl: _,
+				logoutUrl: v,
+				detailsPath: b,
+				tokenPath: x,
+				expirationTimePath: S
+			};
+		}
+	}, [
+		h,
+		g,
+		_,
+		v,
+		b,
+		x,
+		S,
+		D
+	]), { manager: k, loading: A, authenticated: j } = e({
+		server: d,
+		isHydrating: l,
+		tokenStorage: y,
+		provider: m,
+		loginUrl: O.loginUrl,
+		userUrl: O.userUrl,
+		refreshUrl: O.refreshUrl,
+		logoutUrl: O.logoutUrl,
+		detailsPath: O.detailsPath,
+		tokenPath: O.tokenPath,
+		expirationTimePath: O.expirationTimePath
+	});
+	return /* @__PURE__ */ s(t, {
+		value: n(() => ({
+			manager: k,
+			login: k.login.bind(k),
+			refresh: k.refresh.bind(k),
+			can: k.can.bind(k),
+			logout: k.logout.bind(k),
+			authenticated: j || !c,
+			user: k.getProvider() ? {
+				details: k.getProvider()?.user,
+				accessToken: k.getProvider()?.token?.accessToken
+			} : void 0
+		}), [
+			k,
+			j,
+			c
+		]),
+		children: !A && u
+	});
+};
+//#endregion
+export { c as default };

package/dist/AuthManager.d.ts

@@ -0,0 +1,24 @@
+import { default as Auth0Provider } from './providers/Auth0Provider';
+import { default as BasicAuthProvider } from './providers/BasicAuthProvider';
+import { default as AuthProvider, AuthEventListener, AuthProviderWithCache } from './AuthProvider';
+import { TokenResult } from '@plitzi/sdk-shared';
+declare const providers: {
+    auth0: typeof Auth0Provider;
+    basic: typeof BasicAuthProvider;
+};
+export type Providers = keyof typeof providers;
+export declare class AuthManager<U = Record<string, unknown>, T extends Providers = 'basic'> {
+    private providerType;
+    private provider?;
+    constructor(providerType: Providers | undefined, listeners: AuthEventListener | AuthEventListener[], ...args: ConstructorParameters<(typeof providers)[T]>);
+    getProviderType(): Providers;
+    getProvider(): AuthProviderWithCache<U> | undefined;
+    init(user?: U, skipAuth?: boolean): Promise<void> | undefined;
+    login(...args: Parameters<AuthProvider['login']>): Promise<TokenResult | undefined>;
+    refresh(): Promise<TokenResult | undefined>;
+    getUser(): Promise<U | undefined> | undefined;
+    can(permission: string): boolean;
+    logout(): Promise<void>;
+    on(listener: AuthEventListener): (() => void) | undefined;
+}
+export {};

package/dist/AuthManager.mjs

@@ -0,0 +1,42 @@
+import e from "./providers/Auth0Provider.mjs";
+import t from "./providers/BasicAuthProvider.mjs";
+//#region src/AuthManager.ts
+var n = {
+	auth0: e,
+	basic: t
+}, r = class {
+	providerType = "basic";
+	provider = void 0;
+	constructor(e = "basic", t, ...r) {
+		this.providerType = e, n[e] && (this.provider = new n[e](...r), this.provider.on(t));
+	}
+	getProviderType() {
+		return this.providerType;
+	}
+	getProvider() {
+		return this.provider;
+	}
+	init(e, t) {
+		return this.provider?.init(e, t);
+	}
+	login(...e) {
+		return this.provider?.login(...e) ?? Promise.resolve(void 0);
+	}
+	refresh() {
+		return this.provider?.refresh() ?? Promise.resolve(void 0);
+	}
+	getUser() {
+		return this.provider?.getUser();
+	}
+	can(e) {
+		return this.provider?.can(e) ?? !1;
+	}
+	logout() {
+		return this.provider?.logout() ?? Promise.resolve();
+	}
+	on(e) {
+		return this.provider?.on(e);
+	}
+};
+//#endregion
+export { r as AuthManager };

package/dist/AuthProvider.d.ts

@@ -0,0 +1,54 @@
+import { Schema, TokenResult } from '@plitzi/sdk-shared';
+export type AuthProviderCache<U = Record<string, unknown>> = {
+    token?: TokenResult;
+    user?: U;
+};
+export type AuthState = 'init' | 'initLoading' | 'authenticating' | 'authenticated' | 'guest';
+export type AuthEvent = {
+    type: 'state';
+    state: AuthState;
+} | {
+    type: 'login';
+    token: TokenResult;
+} | {
+    type: 'logout';
+} | {
+    type: 'expired';
+};
+export type AuthEventListener = (event: AuthEvent) => void;
+export type AuthProviderWithCache<U> = AuthProvider<U> & Readonly<AuthProviderCache<U>>;
+export type AuthProviderProps = {
+    enableRefresh?: boolean;
+    tokenStorage?: Schema['settings']['tokenStorage'];
+};
+declare abstract class AuthProvider<U = Record<string, unknown>> {
+    abstract readonly name: string;
+    protected cache?: AuthProviderCache<U>;
+    protected enableRefresh: boolean;
+    protected tokenStorage: Schema['settings']['tokenStorage'];
+    protected state: AuthState;
+    private listeners;
+    constructor({ enableRefresh, tokenStorage }?: AuthProviderProps);
+    abstract init(user?: U, skipAuth?: boolean): Promise<void>;
+    abstract login(...args: unknown[]): Promise<TokenResult | undefined>;
+    abstract getUser(): Promise<U | undefined>;
+    abstract refresh(): Promise<TokenResult | undefined>;
+    abstract can(permission: string): boolean;
+    abstract logout(): Promise<void>;
+    protected internalRefresh(token?: TokenResult): void;
+    protected internalGetUser(user?: U): void;
+    protected internalLogin(user?: U, token?: TokenResult): void;
+    protected internalLogout(): void;
+    protected isExpired(): boolean;
+    protected setCache<T extends keyof AuthProviderCache>(cacheKey: T | undefined, cache: AuthProviderCache<U>[T]): void;
+    protected clearCache(cacheKey?: keyof AuthProviderCache<U>): void;
+    on(listeners: AuthEventListener | AuthEventListener[]): () => void;
+    protected emit(event: AuthEvent): void;
+    protected setState(state: AuthState): void;
+    getState(): AuthState;
+    protected request<T>(input: RequestInfo, init?: RequestInit): Promise<{
+        data?: T;
+        status: number;
+    }>;
+}
+export default AuthProvider;

package/dist/AuthProvider.mjs

@@ -0,0 +1,90 @@
+//#region src/AuthProvider.ts
+var e = class {
+	cache;
+	enableRefresh = !1;
+	tokenStorage = "localStorage";
+	state = "init";
+	listeners = /* @__PURE__ */ new Set();
+	constructor({ enableRefresh: e = !1, tokenStorage: t = "localStorage" } = {}) {
+		this.enableRefresh = e, this.tokenStorage = t;
+		try {
+			let e = null;
+			t === "localStorage" ? e = localStorage.getItem("user_state") : t === "sessionStorage" && (e = sessionStorage.getItem("user_state")), e && this.setCache("token", JSON.parse(e));
+		} catch {}
+		return new Proxy(this, { get: (e, n, r) => {
+			if (n in e) return Reflect.get(e, n, r);
+			if (!(e.cache && n in e.cache && n === "token" && t === "") && e.cache && n in e.cache) return e.cache[n];
+		} });
+	}
+	internalRefresh(e) {
+		e || (this.setState("guest"), this.setCache(void 0, void 0)), this.setCache("token", e);
+	}
+	internalGetUser(e) {
+		this.setCache("user", e), e ? this.setState("authenticated") : (this.setState("guest"), this.isExpired() && this.clearCache());
+	}
+	internalLogin(e, t) {
+		this.setCache("user", e), this.setCache("token", t), e ? this.setState("authenticated") : this.setState("guest");
+	}
+	internalLogout() {
+		this.clearCache(), this.setState("guest"), this.emit({ type: "logout" });
+	}
+	isExpired() {
+		return !this.cache || !this.cache.token || !this.cache.token.expiresAt || Date.now() >= this.cache.token.expiresAt;
+	}
+	setCache(e, t) {
+		if (!e) {
+			this.cache = t, typeof localStorage < "u" && this.tokenStorage === "localStorage" && this.cache.token ? localStorage.setItem("user_state", JSON.stringify(this.cache.token)) : typeof sessionStorage < "u" && this.tokenStorage === "sessionStorage" && this.cache.token && sessionStorage.setItem("user_state", JSON.stringify(this.cache.token));
+			return;
+		}
+		this.cache ||= {}, this.cache[e] = t, this.cache.token && (typeof localStorage < "u" && this.tokenStorage === "localStorage" ? localStorage.setItem("user_state", JSON.stringify(this.cache.token)) : typeof sessionStorage < "u" && this.tokenStorage === "sessionStorage" && sessionStorage.setItem("user_state", JSON.stringify(this.cache.token)));
+	}
+	clearCache(e) {
+		if (e && this.cache) {
+			delete this.cache[e], e === "token" && (typeof localStorage < "u" && this.tokenStorage === "localStorage" ? localStorage.removeItem("user_state") : typeof sessionStorage < "u" && this.tokenStorage === "sessionStorage" && sessionStorage.removeItem("user_state"));
+			return;
+		}
+		typeof localStorage < "u" && this.tokenStorage === "localStorage" ? localStorage.removeItem("user_state") : typeof sessionStorage < "u" && this.tokenStorage === "sessionStorage" && sessionStorage.removeItem("user_state"), this.cache = void 0;
+	}
+	on(e) {
+		return Array.isArray(e) ? (e.forEach((e) => this.listeners.add(e)), () => e.forEach((e) => this.listeners.delete(e))) : (this.listeners.add(e), () => this.listeners.delete(e));
+	}
+	emit(e) {
+		for (let t of this.listeners) t(e);
+	}
+	setState(e) {
+		this.state !== e && (this.state = e, this.emit({
+			type: "state",
+			state: e
+		}));
+	}
+	getState() {
+		return this.state;
+	}
+	async request(e, t) {
+		let n;
+		try {
+			n = await fetch(e, t);
+		} catch {
+			return Promise.resolve({
+				data: void 0,
+				status: 500
+			});
+		}
+		if (!n.ok) return Promise.resolve({
+			data: void 0,
+			status: n.status
+		});
+		let r;
+		try {
+			r = await n.json();
+		} catch {
+			r = void 0;
+		}
+		return {
+			data: r,
+			status: n.status
+		};
+	}
+};
+//#endregion
+export { e as default };

package/dist/hooks/useAuth/index.d.ts

@@ -0,0 +1,3 @@
+import { default as useAuth } from './useAuth';
+export * from './useAuth';
+export default useAuth;

package/dist/hooks/useAuth/index.mjs

@@ -0,0 +1,5 @@
+import e from "./useAuth.mjs";
+//#region src/hooks/useAuth/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/hooks/useAuth/useAuth.d.ts

@@ -0,0 +1,28 @@
+import { AuthManager } from '../../AuthManager';
+import { Schema, Server } from '@plitzi/sdk-shared';
+export type UseAuthProps = {
+    server?: Server;
+    isHydrating?: boolean;
+    tokenStorage?: Schema['settings']['tokenStorage'];
+    provider?: Schema['settings']['userProvider'];
+    loginUrl?: Schema['settings']['loginUrl'];
+    userUrl?: Schema['settings']['userUrl'];
+    refreshUrl?: Schema['settings']['refreshUrl'];
+    logoutUrl?: Schema['settings']['logoutUrl'];
+    detailsPath?: Schema['settings']['detailsPath'];
+    tokenPath?: Schema['settings']['tokenPath'];
+    expirationTimePath?: Schema['settings']['expirationTimePath'];
+};
+declare const useAuth: ({ server, isHydrating, tokenStorage, provider, loginUrl, userUrl, refreshUrl, logoutUrl, detailsPath, tokenPath, expirationTimePath }: UseAuthProps) => {
+    manager: AuthManager<{
+        id: number;
+        username: string;
+        email: string;
+        verified: boolean;
+        permissions: string[];
+        roles: string[];
+    }, "basic">;
+    loading: boolean;
+    authenticated: boolean;
+};
+export default useAuth;

package/dist/hooks/useAuth/useAuth.mjs

@@ -0,0 +1,59 @@
+import { AuthManager as e } from "../../AuthManager.mjs";
+import { useCallback as t, useEffect as n, useMemo as r, useState as i } from "react";
+//#region src/hooks/useAuth/useAuth.ts
+var a = ({ server: a, isHydrating: o = !1, tokenStorage: s = "localStorage", provider: c = "", loginUrl: l = "", userUrl: u = "", refreshUrl: d = "", logoutUrl: f = "", detailsPath: p = "details", tokenPath: m = "access_token", expirationTimePath: h = "expire_at" }) => {
+	let g = typeof window > "u" || o || !!a?.user && a.authenticated, [_, v] = i(!!u && !g), [y, b] = i(!1), x = t((e) => {
+		e.type === "state" && (v(e.state === "initLoading"), b(e.state === "authenticated"));
+	}, []), S = r(() => {
+		let t = {};
+		c === "basic" && (t = {
+			tokenStorage: s,
+			loginUrl: l,
+			userUrl: u,
+			refreshUrl: d,
+			logoutUrl: f,
+			detailsPath: p,
+			tokenPath: m,
+			expirationTimePath: h,
+			isSSR: g
+		});
+		let n = new e(c, x, t);
+		return n.init(a?.authenticated ? a.user?.details : void 0, a?.skipAuth), n;
+	}, [
+		c,
+		x,
+		a?.authenticated,
+		a?.user?.details,
+		a?.skipAuth,
+		s,
+		l,
+		u,
+		d,
+		f,
+		p,
+		m,
+		h,
+		g
+	]);
+	return n(() => {
+		let e = S.getProvider();
+		if (!e || !e.token?.expiresAt) return;
+		let t = Math.floor(Date.now() / 1e3);
+		if (e.token.expiresAt) {
+			let n = setTimeout(() => {
+				S.logout();
+			}, Math.abs(t - e.token.expiresAt) * 1e3);
+			return () => clearTimeout(n);
+		}
+	}, [S, y]), r(() => ({
+		manager: S,
+		loading: _,
+		authenticated: y
+	}), [
+		S,
+		_,
+		y
+	]);
+};
+//#endregion
+export { a as default };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { default as AuthContext } from './AuthContext';
+import { default as AuthContextProvider } from './AuthContextProvider';
+import { default as useAuth } from './hooks/useAuth';
+export * from './hooks/useAuth';
+export * from './AuthContext';
+export * from './AuthProvider';
+export * from './AuthManager';
+export { useAuth, AuthContext, AuthContextProvider };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { AuthManager as e } from "./AuthManager.mjs";
+import t from "./hooks/useAuth/index.mjs";
+import n from "./AuthContext.mjs";
+import r from "./AuthContextProvider.mjs";
+export { n as AuthContext, r as AuthContextProvider, e as AuthManager, t as useAuth };

package/dist/providers/Auth0Provider.d.ts

@@ -0,0 +1,22 @@
+import { default as AuthProvider, AuthProviderProps } from '../AuthProvider';
+import { Schema, TokenResult } from '@plitzi/sdk-shared';
+export type Auth0ProviderProps = AuthProviderProps & {
+    tokenStorage?: Schema['settings']['tokenStorage'];
+    loginUrl?: string;
+    userUrl?: string;
+    refreshUrl?: string;
+    logoutUrl?: string;
+    detailsPath?: string;
+    tokenPath?: string;
+    expirationTimePath?: string;
+};
+declare class Auth0Provider<T = Record<string, unknown>> extends AuthProvider<T> {
+    readonly name = "auth0";
+    init(): Promise<void>;
+    login(...args: unknown[]): Promise<TokenResult | undefined>;
+    getUser(): Promise<T | undefined>;
+    refresh(): Promise<TokenResult | undefined>;
+    can(permission: string): boolean;
+    logout(): Promise<void>;
+}
+export default Auth0Provider;

package/dist/providers/Auth0Provider.mjs

@@ -0,0 +1,25 @@
+import e from "../AuthProvider.mjs";
+//#region src/providers/Auth0Provider.ts
+var t = class extends e {
+	name = "auth0";
+	init() {
+		throw Error("Method not implemented.");
+	}
+	login(...e) {
+		throw console.log(e), Error("Method not implemented.");
+	}
+	getUser() {
+		throw Error("Method not implemented.");
+	}
+	refresh() {
+		throw Error("Method not implemented.");
+	}
+	can(e) {
+		throw console.log(e), Error("Method not implemented.");
+	}
+	logout() {
+		throw Error("Method not implemented.");
+	}
+};
+//#endregion
+export { t as default };

package/dist/providers/BasicAuthProvider.d.ts

@@ -0,0 +1,39 @@
+import { default as AuthProvider, AuthProviderProps } from '../AuthProvider';
+import { Schema, TokenResult } from '@plitzi/sdk-shared';
+export type BasicAuthProviderProps = AuthProviderProps & {
+    tokenStorage?: Schema['settings']['tokenStorage'];
+    loginUrl?: string;
+    userUrl?: string;
+    refreshUrl?: string;
+    logoutUrl?: string;
+    detailsPath?: string;
+    tokenPath?: string;
+    refreshTokenPath?: string;
+    expirationTimePath?: string;
+    isSSR?: boolean;
+};
+declare class BasicAuthProvider<T = Record<string, unknown>> extends AuthProvider<T> {
+    readonly name = "basic";
+    protected baseUrl?: string;
+    protected options: {
+        tokenStorage: Exclude<Schema['settings']['tokenStorage'], undefined>;
+        loginUrl: string;
+        userUrl: string;
+        refreshUrl: string;
+        logoutUrl: string;
+        detailsPath: string;
+        tokenPath: string;
+        refreshTokenPath: string;
+        expirationTimePath: string;
+        isSSR: boolean;
+    };
+    constructor({ tokenStorage, enableRefresh, loginUrl, userUrl, refreshUrl, logoutUrl, detailsPath, tokenPath, refreshTokenPath, expirationTimePath, isSSR }?: BasicAuthProviderProps);
+    init(user?: T, skipAuth?: boolean): Promise<void>;
+    login(authParams: Record<string, string>): Promise<TokenResult | undefined>;
+    getUser(): Promise<T | undefined>;
+    refresh(): Promise<TokenResult | undefined>;
+    can(permission: string): boolean;
+    logout(): Promise<void>;
+    private getTokenFromResponse;
+}
+export default BasicAuthProvider;

package/dist/providers/BasicAuthProvider.mjs

@@ -0,0 +1,94 @@
+import e from "../AuthProvider.mjs";
+import { get as t } from "@plitzi/plitzi-ui/helpers";
+//#region src/providers/BasicAuthProvider.ts
+var n = class extends e {
+	name = "basic";
+	baseUrl;
+	options;
+	constructor({ tokenStorage: e = "localStorage", enableRefresh: t = !0, loginUrl: n = "", userUrl: r = "", refreshUrl: i = "", logoutUrl: a = "", detailsPath: o = "", tokenPath: s = "", refreshTokenPath: c = "", expirationTimePath: l = "", isSSR: u = !1 } = {}) {
+		super({
+			enableRefresh: t,
+			tokenStorage: e
+		}), this.options = {
+			tokenStorage: e,
+			loginUrl: n,
+			userUrl: r,
+			refreshUrl: i,
+			logoutUrl: a,
+			detailsPath: o,
+			tokenPath: s,
+			refreshTokenPath: c,
+			expirationTimePath: l,
+			isSSR: u
+		};
+	}
+	async init(e, t) {
+		if (t) {
+			this.setState("guest");
+			return;
+		}
+		if (this.setState("initLoading"), !this.options.isSSR) {
+			await this.getUser();
+			return;
+		}
+		e ? super.internalGetUser(e) : this.setState("guest");
+	}
+	async login(e) {
+		let { username: n = "", password: r = "" } = e;
+		super.setState("authenticating");
+		let i = await this.request(this.options.loginUrl, {
+			credentials: "include",
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				username: n,
+				password: r
+			})
+		}), a = this.getTokenFromResponse(i);
+		return super.internalLogin(t(i.data, this.options.detailsPath), a), a;
+	}
+	async getUser() {
+		if (this.cache?.user && this.state !== "init") return this.cache.user;
+		if (!this.options.userUrl) {
+			super.internalGetUser(void 0);
+			return;
+		}
+		let e = await this.request(this.options.userUrl, {
+			method: "GET",
+			credentials: "include",
+			headers: { "Content-Type": "application/json" }
+		});
+		return super.internalGetUser(t(e.data, this.options.detailsPath)), e.data;
+	}
+	async refresh() {
+		let e = await this.request(this.options.refreshUrl, {
+			method: "POST",
+			credentials: "include",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ refreshToken: this.cache?.token?.refreshToken ?? "" })
+		}), t = this.getTokenFromResponse(e);
+		return super.internalRefresh(t), t;
+	}
+	can(e) {
+		return this.cache?.user ? t(this.cache.user, "permissions", []).includes(e) : !1;
+	}
+	async logout() {
+		await this.request(this.options.logoutUrl, {
+			method: "POST",
+			credentials: "include",
+			headers: { "Content-Type": "application/json" }
+		}), super.internalLogout();
+	}
+	getTokenFromResponse(e) {
+		if (e.status >= 400) return;
+		let n = {
+			errors: t(e.data, "errors", {}),
+			accessToken: t(e.data, this.options.tokenPath, ""),
+			refreshToken: t(e.data, this.options.refreshTokenPath, ""),
+			expiresAt: t(e.data, this.options.expirationTimePath, 0)
+		};
+		return e.data && !("errors" in e.data) && delete n.errors, n;
+	}
+};
+//#endregion
+export { n as default };