@alliumcloud/avatar-sso-internal 2.5.5-dev.0

package/dist/main.js

@@ -0,0 +1,1109 @@
+import * as c from "./config";
+import CustomStorage from "./lib/CustomStorage";
+import { isBrowser } from "./lib/utils";
+export { default as CustomStorage } from "./lib/CustomStorage";
+export default class SSO {
+    constructor(config) {
+        this.config = config;
+        this.serviceType = "AVATAR_SSO";
+        this.ssoClientUrl = c.ssoClientUrl;
+        this.ssoServerUrl = c.ssoServerUrl;
+        this.dbId = "local-user";
+        this.callbacks = new Set();
+        this.cb = (payload) => {
+            for (const cb of this.callbacks)
+                cb(payload);
+        };
+        this.register = async (payload) => {
+            const { redirectUri, type, ...body } = payload;
+            const queryParams = this.emailVerificationQuery({ redirectUri, type });
+            const res = await fetch(`${this.ssoServerUrl}/users/signup${queryParams}`, {
+                method: "POST",
+                body: JSON.stringify(body),
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-sdk-key": this.sdkKey,
+                },
+            });
+            const json = (await res.json());
+            if (!res?.ok || !json.success)
+                throw new Error(json.message ?? "SSO-SDK: Local register failed.");
+            this.cb({
+                type: c.actions.local_register,
+                payload: json.data,
+            });
+            return json.data;
+        };
+        this.localLogin = async (payload) => {
+            if (!(payload instanceof Object))
+                return;
+            const { redirectUri, type, ...body } = payload;
+            const queryParams = this.emailVerificationQuery({ redirectUri, type });
+            const res = await fetch(`${this.ssoServerUrl}/users/signin${queryParams}`, {
+                method: "POST",
+                body: JSON.stringify(body),
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-sdk-key": this.sdkKey,
+                },
+            });
+            const json = await res.json();
+            if (!res?.ok || !json.success)
+                throw new Error(json.message ?? "SSO-SDK: Local login failed.");
+            this.cb({
+                type: c.actions.local_login,
+                payload: null,
+            });
+        };
+        this.ssoLogin = async (redirectUrl) => {
+            if (redirectUrl instanceof Object)
+                return;
+            this.throwIfNotBrowser();
+            const r = `${this.ssoClientUrl}/sso?sdkKey=${this.sdkKey}&redirectUri=${redirectUrl}`;
+            window.location.href = r;
+        };
+        /**
+         * Login function that triggers both local and SSO login flows. If the payload is a string, it will trigger the SSO login flow with the payload as the redirect URL. If the payload is an object, it will trigger the local login flow with the payload as the login data.
+         * @param payload just redirect URL string for SSO login or LocalLoginPayload for local login
+         * @returns
+         */
+        this.login = async (payload) => {
+            await Promise.all([this.localLogin(payload), this.ssoLogin(payload)]);
+        };
+        this.decodeJwtPayload = (token) => {
+            try {
+                const payload = token.split(".")[1];
+                if (!payload)
+                    return null;
+                const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+                return JSON.parse(atob(base64));
+            }
+            catch {
+                return null;
+            }
+        };
+        /**
+         * - it throws.
+         */
+        this.autoRefresh = async () => {
+            const existingUser = await this.getLocalUser().catch(() => null);
+            if (!existingUser)
+                return null;
+            const { accessToken, refreshToken } = existingUser.tokens;
+            const decodedRT = this.decodeJwtPayload(refreshToken);
+            const decodedAT = this.decodeJwtPayload(accessToken);
+            const date = new Date();
+            const isValidRefToken = decodedRT?.exp && decodedAT?.exp && date.getTime() < decodedRT.exp * 1000;
+            if (!isValidRefToken) {
+                await this.db.reset();
+                throw new Error(`SSO-SDK: Session cleared. Please login again.`);
+            }
+            else {
+                date.setMinutes(date.getMinutes() + 5); // check if it expires in the next 5 minutes
+                const shouldRefresh = decodedAT?.exp && date.getTime() > decodedAT.exp * 1000;
+                if (!shouldRefresh)
+                    return existingUser.tokens;
+                return await this.refresh();
+            }
+        };
+        this.localExchange = async (email, token) => {
+            if (!email || !token)
+                return;
+            const res = await fetch(`${this.ssoServerUrl}/users/verify`, {
+                method: "POST",
+                body: JSON.stringify({
+                    token,
+                    email,
+                }),
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-sdk-key": this.sdkKey,
+                },
+            });
+            const verifyRes = await res.json();
+            if (!res.ok || !verifyRes.success)
+                throw new Error(verifyRes.message ?? `SSO-SDK: Local exchange failed.`);
+            const profileRes = await fetch(`${this.ssoServerUrl}/users/profile`, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${verifyRes.data.tokens.accessToken}`,
+                    "x-sdk-key": this.sdkKey,
+                },
+            });
+            const profileJson = await profileRes.json();
+            if (!profileRes.ok || !profileJson.success)
+                throw new Error(profileJson.message ?? `SSO-SDK: Profile fetch failed.`);
+            await this.db.open();
+            await this.db.delete(this.dbId);
+            await this.db.create({
+                ...profileJson.data,
+                userId: profileJson.data.id,
+                tokens: verifyRes.data.tokens,
+                id: this.dbId,
+            });
+            this.cb({
+                type: c.actions.local_exchange,
+                payload: profileJson.data,
+            });
+            return { ...profileJson.data, tokens: verifyRes.data.tokens };
+        };
+        this.verifyOtp = async (payload) => {
+            await this.db.reset();
+            const email = payload.email.trim().toLowerCase();
+            const otpCode = payload.otpCode.trim();
+            if (!email || !otpCode)
+                throw new Error(`SSO-SDK: Invalid OTP payload.`);
+            const res = await this.localExchange(email, otpCode);
+            if (!res)
+                throw new Error(`SSO-SDK: OTP verification failed.`);
+            return res;
+        };
+        this.ssoExchange = async (email, token) => {
+            if (email || !token)
+                return;
+            const res = await fetch(`${this.ssoServerUrl}/sso/exchange`, {
+                method: "POST",
+                body: JSON.stringify({
+                    token,
+                    sdkKey: this.sdkKey,
+                }),
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-sdk-key": this.sdkKey,
+                },
+            });
+            const data = await res.json();
+            if (!res.ok)
+                throw new Error(data.message ?? `SSO-SDK: SSO exchange failed.`);
+            const profileRes = await fetch(`${this.ssoServerUrl}/users/profile`, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${data.data.tokens.accessToken}`,
+                    "x-sdk-key": this.sdkKey,
+                },
+            });
+            const profileJson = await profileRes.json();
+            if (!profileRes.ok || !profileJson.success)
+                throw new Error(profileJson.message ?? `SSO-SDK: Profile fetch failed.`);
+            await this.db.open();
+            await this.db.delete(this.dbId);
+            await this.db.create({
+                ...profileJson.data,
+                userId: profileJson.data.id,
+                tokens: data.data.tokens,
+                id: this.dbId,
+            });
+            this.cb({
+                type: c.actions.sso_exchange,
+                payload: profileJson.data,
+            });
+            return { ...profileJson.data, tokens: data.data.tokens };
+        };
+        /**
+         * - this will just skip the exchange returning null if the query params are not correct and won't throw an error.
+         */
+        this.exchange = async () => {
+            this.throwIfNotBrowser();
+            const url = new URL(window.location.href);
+            const email = url.searchParams.get("email");
+            const token = url.searchParams.get("token");
+            const isExchanging = !!(email && token);
+            if (isExchanging) {
+                url.searchParams.delete("email");
+                url.searchParams.delete("token");
+                window.history.replaceState({}, "", url);
+            }
+            const tokenReused = await this.autoRefresh().catch((e) => {
+                if (/session cleared/i.test(e?.message ?? "") && !isExchanging) {
+                    this.cb({
+                        type: c.actions.session_cleared,
+                        payload: null,
+                    });
+                }
+                if (!isExchanging)
+                    throw new Error(e?.message ?? `SSO-SDK: Auto refresh failed.`);
+                return null;
+            });
+            if (tokenReused && isExchanging)
+                throw new Error(`SSO-SDK: User already logged in.`);
+            if (!isExchanging)
+                return null;
+            await this.db.reset(); // reset the db before exchange to avoid conflicts
+            const sanitizedEmail = email
+                ? email.trim().toLowerCase().replace(/\s+/g, "+")
+                : null;
+            const res = await Promise.all([
+                this.localExchange(sanitizedEmail, token),
+                this.ssoExchange(sanitizedEmail, token),
+            ]).then((r) => r.find((r2) => !!r2));
+            if (!res)
+                throw new Error(`SSO-SDK: Exchange failed.`);
+            return res;
+        };
+        this.fetchProfile = async () => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/users/profile`, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const pRes = await res.json();
+            if (!res?.ok || !pRes.success)
+                throw new Error(pRes.message ?? `SSO-SDK: Profile fetch failed.`);
+            this.cb({
+                type: c.actions.profile_fetch,
+                payload: pRes.data,
+            });
+            return pRes.data;
+        };
+        this.refresh = async () => {
+            const dbUser = (await this.db.getById(this.dbId));
+            if (!dbUser)
+                throw new Error(`SSO-SDK: No user found in IndexedDB.`);
+            const res = await fetch(`${this.ssoServerUrl}/users/refresh`, {
+                method: "POST",
+                body: JSON.stringify({
+                    token: dbUser.tokens.refreshToken,
+                }),
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-sdk-key": this.sdkKey,
+                },
+            });
+            const refTokeRes = await res.json();
+            if (!res.ok || !refTokeRes.success) {
+                this.db.delete(this.dbId);
+                this.cb({
+                    type: c.actions.session_cleared,
+                    payload: null,
+                });
+                throw new Error(refTokeRes.message ?? `SSO-SDK: Refresh failed.`);
+            }
+            await this.db.update(this.dbId, {
+                ...dbUser,
+                tokens: {
+                    accessToken: refTokeRes.data.accessToken,
+                    refreshToken: refTokeRes.data.refreshToken,
+                },
+            });
+            this.cb({
+                type: c.actions.refresh,
+                payload: refTokeRes.data,
+            });
+            return refTokeRes.data;
+        };
+        this.localLogout = async (redirectUrl) => {
+            if (redirectUrl)
+                return;
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/users/logout`, {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const json = await res.json();
+            if (!res?.ok || !json.success)
+                throw new Error(json.message ?? `SSO-SDK: Local logout failed.`);
+            await this.db.delete(this.dbId);
+            this.cb({
+                type: c.actions.local_logout,
+                payload: null,
+            });
+            return true;
+        };
+        this.ssoLogout = async (redirectUrl) => {
+            if (!redirectUrl)
+                return;
+            this.throwIfNotBrowser();
+            const url = this.validatedUrl(redirectUrl);
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/users/logout`, {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const json = await res.json();
+            if (!res?.ok || !json.success)
+                throw new Error(json.message ?? `SSO-SDK: Logout failed.`);
+            await this.db.delete(this.dbId);
+            const goToUrl = `${this.ssoClientUrl}/logout?redirectUri=${url}`;
+            location.href = goToUrl;
+            this.cb({
+                type: c.actions.logout,
+                payload: null,
+            });
+            return true;
+        };
+        /**
+         * - If a redirect URL is provided, it will trigger the SSO logout flow and redirect the user to the provided URL after logout.
+         * - If no redirect URL is provided, it will trigger the local logout flow and clear the user data from IndexedDB.
+         */
+        this.logout = async (redirectUrl) => {
+            const res = await Promise.all([
+                this.localLogout(redirectUrl),
+                this.ssoLogout(redirectUrl),
+            ]).then((r) => r.find((r) => r !== undefined));
+            if (!res)
+                throw new Error("SSO-SDK: Logout failed.");
+            this.cb({
+                type: c.actions.session_cleared,
+                payload: null,
+            });
+            return res;
+        };
+        this.onEvents = (cb) => {
+            this.callbacks.add(cb);
+            return () => this.callbacks.delete(cb);
+        };
+        this.withRefresh = async (api) => {
+            await this.db.open();
+            const dbUser = (await this.db.getById(this.dbId));
+            if (!dbUser)
+                throw new Error(`SSO-SDK: No user found in IndexedDB.`);
+            const r = await api(dbUser.tokens.accessToken);
+            if (r.status !== 401)
+                return r;
+            const resToken = await this.refresh();
+            const nR = await api(resToken.accessToken);
+            return nR;
+        };
+        this.profileUpdate = async (payload) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/users/profile`, {
+                    method: "PATCH",
+                    body: JSON.stringify(payload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const pRes = await res.json();
+            if (!res?.ok || !pRes.success)
+                throw new Error(pRes.message ?? `SSO-SDK: Profile update failed.`);
+            const { id, ...rest } = pRes.data;
+            await this.db.update(this.dbId, {
+                ...rest,
+                userId: id,
+            });
+            this.cb({
+                type: c.actions.profile_update,
+                payload: pRes.data,
+            });
+            return pRes.data;
+        };
+        this.avatarUpdate = async (file) => {
+            const photoURL = await this.fileUpload(file);
+            if (!photoURL)
+                throw new Error(`SSO-SDK: File upload failed.`);
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/users/profile/avatar`, {
+                    method: "PUT",
+                    body: JSON.stringify({
+                        photoURL,
+                    }),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const pRes = await res.json();
+            if (!res?.ok || !pRes.success)
+                throw new Error(pRes.message ?? `SSO-SDK: Profile update failed.`);
+            const { id, ...rest } = pRes.data;
+            await this.db.update(this.dbId, {
+                ...rest,
+                userId: id,
+            });
+            this.cb({
+                type: c.actions.profile_photo_update,
+                payload: pRes.data,
+            });
+            return pRes.data;
+        };
+        this.fileUpload = async (file) => {
+            const { type } = file;
+            const url = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/uploads/url?fileType=${type}`, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const json = await url.json();
+            if (!url?.ok || !json.success)
+                throw new Error(json.message ?? `SSO-SDK: could not get upload url.`);
+            const upload = await fetch(json.data.url, {
+                method: json.data.method,
+                body: file,
+                headers: json.data.headers,
+            });
+            if (!upload.ok)
+                throw new Error(`SSO-SDK: could not upload file.`);
+            const { origin, pathname } = new URL(json.data.url);
+            return `${origin}${pathname}`;
+        };
+        this.clothAdd = async (payload) => {
+            const thumb = await this.fileUpload(payload.thumb);
+            if (!thumb)
+                throw new Error(`SSO-SDK: File upload failed.`);
+            const jsonPayload = {
+                ...payload,
+                thumb,
+            };
+            await this.db.open();
+            const dbUser = (await this.db.getById(this.dbId));
+            if (!dbUser)
+                throw new Error(`SSO-SDK: No user found in IndexedDB.`);
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings`, {
+                    method: "POST",
+                    body: JSON.stringify(jsonPayload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT || dbUser.tokens.accessToken}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const bodyRes = await res.json();
+            if (!res?.ok || !bodyRes.success)
+                throw new Error(bodyRes.message ?? `SSO-SDK: Cloth add failed.`);
+            const { data } = bodyRes;
+            this.cb({
+                type: c.actions.cloth_add,
+                payload: data,
+            });
+            return data;
+        };
+        this.clothGetAll = async (options) => {
+            const queryParams = new URLSearchParams({
+                skip: Math.ceil(options?.skip ?? 0).toString(),
+                limit: Math.ceil(options?.limit ?? 10).toString(),
+                sort: options?.sort ?? "asc",
+            });
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings?${queryParams.toString()}`, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const clothRes = await res.json();
+            if (!res?.ok || !clothRes.success)
+                throw new Error(clothRes.message ?? `SSO-SDK: Get all cloths failed.`);
+            this.cb({
+                type: c.actions.cloth_fetch_all,
+                payload: clothRes.data,
+            });
+            return clothRes.data;
+        };
+        this.clothGetById = async (clothId) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/${clothId}`, {
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const clothRes = await res.json();
+            if (!res?.ok || !clothRes.success)
+                throw new Error(clothRes.message ?? `SSO-SDK: Get cloth by id failed.`);
+            this.cb({
+                type: c.actions.cloth_fetch,
+                payload: clothRes.data,
+            });
+            return clothRes.data;
+        };
+        this.clothUpdate = async (clothId, payload) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/${clothId}`, {
+                    method: "PATCH",
+                    body: JSON.stringify(payload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const clothRes = await res.json();
+            if (!res?.ok || !clothRes.success)
+                throw new Error(clothRes.message ?? `SSO-SDK: Cloth update failed.`);
+            const { data } = clothRes;
+            this.cb({
+                type: c.actions.cloth_update,
+                payload: data,
+            });
+            return data;
+        };
+        this.clothDelete = async (clothId) => {
+            await this.db.open();
+            const dbUser = (await this.db.getById(this.dbId));
+            if (!dbUser)
+                throw new Error(`SSO-SDK: No user found in IndexedDB.`);
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/${clothId}`, {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT || dbUser.tokens.accessToken}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const clothRes = await res.json();
+            if (!res?.ok || !clothRes.success)
+                throw new Error(clothRes.message ?? `SSO-SDK: Cloth delete failed.`);
+            this.cb({
+                type: c.actions.cloth_delete,
+                payload: clothRes.data,
+            });
+            return clothRes.data;
+        };
+        // materials
+        this.materialAdd = async (payload) => {
+            const thumb = await this.fileUpload(payload.thumb);
+            if (!thumb)
+                throw new Error(`SSO-SDK: File upload failed.`);
+            const jsonPayload = {
+                ...payload,
+                thumb: thumb,
+            };
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/materials`, {
+                    method: "POST",
+                    body: JSON.stringify(jsonPayload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const materialRes = await res.json();
+            if (!res?.ok || !materialRes.success)
+                throw new Error(materialRes.message ?? `SSO-SDK: Material add failed.`);
+            const { data } = materialRes;
+            this.cb({
+                type: c.actions.material_add,
+                payload: data,
+            });
+            return data;
+        };
+        this.materialGetAll = async (options) => {
+            const params = new URLSearchParams({
+                skip: options?.skip?.toString() || "0",
+                limit: options?.limit?.toString() || "10",
+                sort: options?.sort || "asc",
+            });
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/materials?${params}`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const materialRes = await res.json();
+            if (!res?.ok || !materialRes.success)
+                throw new Error(materialRes.message ?? `SSO-SDK: Material fetch all failed.`);
+            const { data } = materialRes;
+            this.cb({
+                type: c.actions.material_fetch_all,
+                payload: data,
+            });
+            return data;
+        };
+        this.materialGetById = async (materialId) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/materials/${materialId}`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const materialRes = await res.json();
+            if (!res?.ok || !materialRes.success)
+                throw new Error(materialRes.message ?? `SSO-SDK: Material fetch by id failed.`);
+            const { data } = materialRes;
+            this.cb({
+                type: c.actions.material_fetch,
+                payload: data,
+            });
+            return data;
+        };
+        this.materialUpdate = async (materialId, payload) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/materials/${materialId}`, {
+                    method: "PATCH",
+                    body: JSON.stringify(payload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const materialRes = await res.json();
+            if (!res?.ok || !materialRes.success)
+                throw new Error(materialRes.message ?? `SSO-SDK: Material update failed.`);
+            const { data } = materialRes;
+            this.cb({
+                type: c.actions.material_update,
+                payload: data,
+            });
+            return data;
+        };
+        this.materialDelete = async (materialId) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/clothings/materials/${materialId}`, {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const materialRes = await res.json();
+            if (!res?.ok || !materialRes.success)
+                throw new Error(materialRes.message ?? `SSO-SDK: Material delete failed.`);
+            const { data } = materialRes;
+            this.cb({
+                type: c.actions.material_delete,
+                payload: data,
+            });
+            return data;
+        };
+        // skulls
+        this.skullAdd = async (payload) => {
+            const preview = await this.fileUpload(payload.filePreview);
+            const model = await this.fileUpload(payload.file3d);
+            if (!preview || !model)
+                throw new Error(`SSO-SDK: File upload failed.`);
+            const jsonPayload = {
+                ...payload,
+                previewUrl: preview,
+                url3d: model,
+            };
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls`, {
+                    method: "POST",
+                    body: JSON.stringify(jsonPayload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull add failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_add,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullUpdate = async (skullId, payload) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/${skullId}`, {
+                    method: "PATCH",
+                    body: JSON.stringify(payload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = (await res.json());
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull update failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_update,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullGetAll = async () => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull get all failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_fetch_all,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullGetById = async (skullId) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/${skullId}`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull get by id failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_fetch,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullDelete = async (skullId) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/${skullId}`, {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull delete failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_delete,
+                payload: data,
+            });
+            return data;
+        };
+        // skull material
+        this.skullMaterialAdd = async (payload) => {
+            const { file3d, previewFile, ...rest } = payload;
+            const preview = await this.fileUpload(previewFile);
+            const model = await this.fileUpload(file3d);
+            if (!preview || !model)
+                throw new Error(`SSO-SDK: File upload failed.`);
+            const jsonPayload = {
+                ...rest,
+                previewUrl: preview,
+                url3d: model,
+            };
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/materials`, {
+                    method: "POST",
+                    body: JSON.stringify(jsonPayload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull material add failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_material_add,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullMaterialGetAll = async () => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/materials`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull materials get all failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_material_fetch_all,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullMaterialGetById = async (id) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/materials/${id}`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull material get by id failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_material_fetch,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullMaterialUpdate = async (id, payload) => {
+            const { file3d, previewFile, ...rest } = payload;
+            const preview = previewFile && (await this.fileUpload(previewFile));
+            const model = file3d && (await this.fileUpload(file3d));
+            const jsonPayload = {
+                ...rest,
+                previewUrl: preview,
+                url3d: model,
+            };
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/materials/${id}`, {
+                    method: "PATCH",
+                    body: JSON.stringify(jsonPayload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull material update failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_material_update,
+                payload: data,
+            });
+            return data;
+        };
+        this.skullMaterialDelete = async (id) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/skulls/materials/${id}`, {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const skullRes = await res.json();
+            if (!res?.ok || !skullRes.success)
+                throw new Error(skullRes.message ?? "SSO-SDK: Skull material delete failed.");
+            const { data } = skullRes;
+            this.cb({
+                type: c.actions.skull_material_delete,
+                payload: data,
+            });
+            return data;
+        };
+        // body
+        this.bodyAdd = async (payload) => {
+            const { file3d, previewFile, ...rest } = payload;
+            const preview = await this.fileUpload(previewFile);
+            const model = await this.fileUpload(file3d);
+            if (!preview || !model)
+                throw new Error(`SSO-SDK: File upload failed.`);
+            const jsonPayload = {
+                ...rest,
+                previewUrl: preview,
+                url3d: model,
+            };
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/bodies`, {
+                    method: "POST",
+                    body: JSON.stringify(jsonPayload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const bodyRes = await res.json();
+            if (!res?.ok || !bodyRes.success)
+                throw new Error(bodyRes.message ?? "SSO-SDK: Body add failed.");
+            const { data } = bodyRes;
+            this.cb({
+                type: c.actions.body_add,
+                payload: data,
+            });
+            return data;
+        };
+        this.bodyGetAll = async () => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/bodies`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const bodyRes = await res.json();
+            if (!res?.ok || !bodyRes.success)
+                throw new Error(bodyRes.message ?? "SSO-SDK: Body add failed.");
+            const { data } = bodyRes;
+            this.cb({
+                type: c.actions.body_fetch_all,
+                payload: data,
+            });
+            return data;
+        };
+        this.bodyGetById = async (id) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/bodies/${id}`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const bodyRes = await res.json();
+            if (!res?.ok || !bodyRes.success)
+                throw new Error(bodyRes.message ?? "SSO-SDK: Body add failed.");
+            const { data } = bodyRes;
+            this.cb({
+                type: c.actions.body_fetch,
+                payload: data,
+            });
+            return data;
+        };
+        this.bodyUpdate = async (id, payload) => {
+            const { file3d, previewFile, ...rest } = payload;
+            const preview = previewFile && (await this.fileUpload(previewFile));
+            const model = file3d && (await this.fileUpload(file3d));
+            const jsonPayload = {
+                ...rest,
+                previewUrl: preview,
+                url3d: model,
+            };
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/bodies/${id}`, {
+                    method: "PATCH",
+                    body: JSON.stringify(jsonPayload),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const bodyRes = await res.json();
+            if (!res?.ok || !bodyRes.success)
+                throw new Error(bodyRes.message ?? "SSO-SDK: Body add failed.");
+            const { data } = bodyRes;
+            this.cb({
+                type: c.actions.body_update,
+                payload: data,
+            });
+            return data;
+        };
+        this.bodyDelete = async (id) => {
+            const res = await this.withRefresh(async (aT) => {
+                return await fetch(`${this.ssoServerUrl}/bodies/${id}`, {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${aT}`,
+                        "x-sdk-key": this.sdkKey,
+                    },
+                });
+            });
+            const bodyRes = await res.json();
+            if (!res?.ok || !bodyRes.success)
+                throw new Error(bodyRes.message ?? "SSO-SDK: Body add failed.");
+            const { data } = bodyRes;
+            this.cb({
+                type: c.actions.body_delete,
+                payload: data,
+            });
+            return data;
+        };
+        this.validatedUrl = (url) => {
+            try {
+                return new URL(url).href;
+            }
+            catch {
+                throw new Error(`SSO-SDK: Invalid URL.`);
+            }
+        };
+        this.emailVerificationQuery = ({ redirectUri, type, }) => {
+            const params = new URLSearchParams();
+            if (redirectUri)
+                params.set("redirectUri", this.validatedUrl(redirectUri));
+            if (type)
+                params.set("type", type);
+            const query = params.toString();
+            return query ? `?${query}` : "";
+        };
+        this.throwIfNotBrowser = () => {
+            if (!isBrowser())
+                throw new Error("SSO-SDK: Not in browser.");
+        };
+        /**
+         * get user from indexedDB without validating tokens.
+         */
+        this.getLocalUser = async () => {
+            const dbUser = (await this.db.getById(this.dbId));
+            if (!dbUser)
+                throw new Error(`SSO-SDK: No user found in IndexedDB.`);
+            return dbUser;
+        };
+        this.sdkKey = config.sdkKey ?? "no-sdk-key";
+        this.db = config.storage instanceof CustomStorage ? config.storage : c.db;
+        this.ssoClientUrl = config.clientUrl ?? c.ssoClientUrl;
+        this.ssoServerUrl = config.serverUrl ?? c.ssoServerUrl;
+    }
+}
+//# sourceMappingURL=main.js.map