@unidy.io/sdk 1.1.7 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unidy.io/sdk",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Unidy SDK: API Client, Stencil Components, and React Wrappers",
   "homepage": "https://sdk-demo.unidy.io",
   "type": "module",
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "clean": "rm -rf dist www loader .stencil",
-    "build": "bun run clean && stencil build",
+    "build": "bun run clean && touch src/demo-build.css && stencil build",
     "dev:stencil": "stencil build --dev --watch --serve",
     "dev:css": "tailwindcss -i ./src/demo.css -o ./src/demo-build.css --content './src/**/*.{html}' --watch",
     "dev": "concurrently \"bun run dev:stencil\" \"bun run dev:css\"",

package/dist/cjs/app-globals-DSKjcXX_.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var index = require('./index-B_N5xKgH.js');
-
-const globalScripts = index.appGlobalScript;
-
-exports.globalScripts = globalScripts;
-//# sourceMappingURL=app-globals-DSKjcXX_.js.map
-
-//# sourceMappingURL=app-globals-DSKjcXX_.js.map

package/dist/cjs/app-globals-DSKjcXX_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-globals-DSKjcXX_.js","sources":["@stencil/core/internal/app-globals"],"sourcesContent":["import appGlobalScript from '/Users/coki/Projects/unidy.io/unidy-sdk/packages/sdk/src/globalScript.ts';\nexport const globalScripts = appGlobalScript;\nexport const globalStyles = \"\";\n"],"names":["appGlobalScript"],"mappings":";;;;AACY,MAAC,aAAa,GAAGA;;;;"}

package/dist/cjs/auth-B83pzi0f.js

@@ -1,582 +0,0 @@
-'use strict';
-
-var index$1 = require('./index-R2MKLaem.js');
-var i18n = require('./i18n-BoDZ8kd2.js');
-var unidyStore = require('./unidy-store-7AbWnZ6g.js');
-var authStore = require('./auth-store-DPHWWmXf.js');
-var index = require('./index-B_N5xKgH.js');
-var profileStore = require('./profile-store-P_BcYkef.js');
-var componentUtils = require('./component-utils-BpMyeVQo.js');
-var flashStore = require('./flash-store-BuIBuQDx.js');
-
-class InvalidTokenError extends Error {
-}
-InvalidTokenError.prototype.name = "InvalidTokenError";
-function b64DecodeUnicode(str) {
-    return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
-        let code = p.charCodeAt(0).toString(16).toUpperCase();
-        if (code.length < 2) {
-            code = "0" + code;
-        }
-        return "%" + code;
-    }));
-}
-function base64UrlDecode(str) {
-    let output = str.replace(/-/g, "+").replace(/_/g, "/");
-    switch (output.length % 4) {
-        case 0:
-            break;
-        case 2:
-            output += "==";
-            break;
-        case 3:
-            output += "=";
-            break;
-        default:
-            throw new Error("base64 string is not of the correct length");
-    }
-    try {
-        return b64DecodeUnicode(output);
-    }
-    catch (err) {
-        return atob(output);
-    }
-}
-function jwtDecode(token, options) {
-    if (typeof token !== "string") {
-        throw new InvalidTokenError("Invalid token specified: must be a string");
-    }
-    options || (options = {});
-    const pos = options.header === true ? 0 : 1;
-    const part = token.split(".")[pos];
-    if (typeof part !== "string") {
-        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
-    }
-    let decoded;
-    try {
-        decoded = base64UrlDecode(part);
-    }
-    catch (e) {
-        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
-    }
-    try {
-        return JSON.parse(decoded);
-    }
-    catch (e) {
-        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
-    }
-}
-
-const logger = index.createLogger("PasskeyAuth");
-const PASSKEY_ERRORS = {
-    NotSupportedError: "passkey_not_supported",
-    NotAllowedError: "passkey_cancelled",
-    SecurityError: "passkey_security_error",
-    InvalidStateError: "passkey_invalid_state",
-};
-function decodeBase64Url(base64url) {
-    const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
-    return Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
-}
-function buildPublicKeyOptions(options) {
-    return {
-        challenge: Uint8Array.from(atob(options.challenge), (c) => c.charCodeAt(0)),
-        timeout: options.timeout || 60000,
-        rpId: options.rpId,
-        userVerification: options.userVerification || "required",
-        allowCredentials: options.allowCredentials?.map((cred) => ({
-            ...cred,
-            id: decodeBase64Url(cred.id),
-        })),
-    };
-}
-function formatCredentialForServer(credential) {
-    const response = credential.response;
-    return {
-        id: credential.id,
-        rawId: btoa(String.fromCharCode(...new Uint8Array(credential.rawId))),
-        response: {
-            authenticatorData: btoa(String.fromCharCode(...new Uint8Array(response.authenticatorData))),
-            clientDataJSON: btoa(String.fromCharCode(...new Uint8Array(response.clientDataJSON))),
-            signature: btoa(String.fromCharCode(...new Uint8Array(response.signature))),
-        },
-        type: credential.type,
-    };
-}
-function extractAndSetSignInId(tokenResponse) {
-    if (tokenResponse.sid) {
-        authStore.authStore.setSignInId(tokenResponse.sid);
-        return;
-    }
-    // Fallback: extract sid from JWT token payload
-    try {
-        const decoded = jwtDecode(tokenResponse.jwt);
-        if (decoded.sid) {
-            authStore.authStore.setSignInId(decoded.sid);
-        }
-    }
-    catch {
-        // Failed to decode JWT token to extract sid, continue without it
-    }
-}
-function handlePasskeyError(error) {
-    logger.error("Passkey error:", error);
-    let errorMessage = "passkey_error";
-    if (error instanceof DOMException) {
-        errorMessage = PASSKEY_ERRORS[error.name] || "passkey_error";
-    }
-    authStore.authStore.setFieldError("passkey", errorMessage);
-    authStore.authStore.setLoading(false);
-}
-async function authenticateWithPasskey(client, onSuccess) {
-    authStore.authStore.setLoading(true);
-    authStore.authStore.clearErrors();
-    if (!window.PublicKeyCredential) {
-        authStore.authStore.setFieldError("passkey", "passkey_not_supported");
-        authStore.authStore.setLoading(false);
-        return;
-    }
-    try {
-        const [optionsError, options] = await client.auth.getPasskeyOptions(authStore.state.sid || undefined);
-        if (optionsError || !options) {
-            authStore.authStore.setFieldError("passkey", optionsError || "bad_request");
-            authStore.authStore.setLoading(false);
-            return;
-        }
-        const publicKeyOptions = buildPublicKeyOptions(options);
-        const credential = (await navigator.credentials.get({
-            publicKey: publicKeyOptions,
-        }));
-        if (!credential) {
-            authStore.authStore.setFieldError("passkey", "passkey_cancelled");
-            authStore.authStore.setLoading(false);
-            return;
-        }
-        const formattedCredential = formatCredentialForServer(credential);
-        const [verifyError, tkResponse] = await client.auth.authenticateWithPasskey(formattedCredential);
-        const tokenResponse = tkResponse;
-        if (verifyError || !tokenResponse) {
-            authStore.authStore.setGlobalError("auth", verifyError || "authentication_failed");
-            authStore.authStore.setLoading(false);
-            return;
-        }
-        authStore.authStore.setToken(tokenResponse.jwt);
-        extractAndSetSignInId(tokenResponse);
-        onSuccess(tokenResponse);
-    }
-    catch (error) {
-        handlePasskeyError(error);
-    }
-}
-
-class AuthHelpers {
-    client;
-    logger = index.createLogger("AuthHelpers");
-    constructor(client) {
-        this.client = client;
-    }
-    async createSignIn(email, password, sendMagicCode) {
-        if (!email) {
-            throw new Error(i18n.t("errors.required_field", { field: "Email" }));
-        }
-        authStore.authStore.setLoading(true);
-        authStore.authStore.clearErrors();
-        const [error, response] = await this.client.auth.createSignIn(email, password, sendMagicCode);
-        if (error) {
-            this.handleAuthError(error, response, password ? "password" : "email");
-            return;
-        }
-        if (password) {
-            const token = jwtDecode(response.jwt);
-            authStore.authStore.setSignInId(token.sid);
-            authStore.authStore.setToken(response.jwt);
-            authStore.authStore.setLoading(false);
-            authStore.authStore.getRootComponentRef()?.onAuth(response);
-            return;
-        }
-        if (sendMagicCode) {
-            authStore.authStore.setSignInId(response.sid);
-            authStore.authStore.setMagicCodeStep("sent");
-            authStore.authStore.setStep("magic-code");
-            authStore.authStore.setLoading(false);
-            return [error, response];
-        }
-        const signInResponse = response;
-        authStore.authStore.setStep("verification");
-        authStore.authStore.setEmail(email);
-        authStore.authStore.setSignInId(signInResponse.sid);
-        authStore.authStore.setLoginOptions(signInResponse.login_options);
-        authStore.authStore.setLoading(false);
-    }
-    async authenticateWithPassword(password) {
-        if (!authStore.state.sid) {
-            throw new Error(i18n.t("errors.no_sign_in_id"));
-        }
-        if (!password) {
-            throw new Error(i18n.t("errors.required_field", { field: "Password" }));
-        }
-        authStore.authStore.setLoading(true);
-        authStore.authStore.clearErrors();
-        const [error, response] = await this.client.auth.authenticateWithPassword(authStore.state.sid, password);
-        if (error) {
-            this.handleAuthError(error, response, "password");
-        }
-        else {
-            authStore.authStore.setLoading(false);
-            this.handleAuthSuccess(response);
-            return;
-        }
-    }
-    async authenticateWithMagicCode(code) {
-        if (!authStore.state.sid) {
-            throw new Error(i18n.t("errors.no_sign_in_id"));
-        }
-        if (!code) {
-            throw new Error(i18n.t("errors.magic_code_is_missing"));
-        }
-        authStore.authStore.setLoading(true);
-        authStore.authStore.clearErrors();
-        const [error, response] = await this.client.auth.authenticateWithMagicCode(authStore.state.sid, code);
-        if (error) {
-            this.handleAuthError(error, response, "magicCode");
-            return;
-        }
-        this.handleAuthSuccess(response);
-    }
-    authenticateWithPasskey() {
-        return authenticateWithPasskey(this.client, (response) => this.handleAuthSuccess(response));
-    }
-    async logout() {
-        const [error, _] = await this.client.auth.signOut(authStore.state.sid);
-        if (error) {
-            authStore.authStore.setGlobalError("auth", error);
-        }
-        return [error, _];
-    }
-    async refreshToken() {
-        if (authStore.state.step === "missing-fields") {
-            return;
-        }
-        const sid = componentUtils.clearUrlParam("sid");
-        if (sid) {
-            authStore.authStore.setSignInId(sid);
-        }
-        if (!authStore.state.sid) {
-            this.logger.warn("No sign-in ID in the session");
-            return;
-        }
-        const [error, response] = await this.client.auth.refreshToken(authStore.state.sid);
-        if (error) {
-            authStore.authStore.reset();
-            authStore.authStore.setGlobalError("auth", error);
-        }
-        else {
-            authStore.authStore.setToken(response.jwt);
-        }
-    }
-    async sendMagicCode() {
-        if (!authStore.state.sid && authStore.state.step !== "single-login") {
-            throw new Error(i18n.t("errors.no_sign_in_id"));
-        }
-        authStore.authStore.setMagicCodeStep("requested");
-        authStore.authStore.setLoading(true);
-        authStore.authStore.clearErrors();
-        if (authStore.state.step === "single-login") {
-            const [error, response] = await this.createSignIn(authStore.state.email, undefined, true);
-            authStore.authStore.setLoading(false);
-            return [error, response];
-        }
-        const [error, response] = await this.client.auth.sendMagicCode(authStore.state.sid);
-        authStore.authStore.setLoading(false);
-        authStore.authStore.setStep("magic-code");
-        if (!error) {
-            authStore.authStore.setMagicCodeStep("sent");
-            return [null, response];
-        }
-        authStore.authStore.setFieldError("magicCode", error);
-        if (error === "magic_code_recently_created") {
-            authStore.authStore.setMagicCodeStep("sent");
-        }
-        return [error, response];
-    }
-    async sendResetPasswordEmail() {
-        if (!authStore.state.sid) {
-            throw new Error(i18n.t("errors.no_sign_in_id"));
-        }
-        authStore.authStore.setLoading(true);
-        authStore.authStore.setResetPasswordStep("requested");
-        const [error, _] = await this.client.auth.sendResetPasswordEmail(authStore.state.sid, window.location.href);
-        if (error) {
-            authStore.authStore.setFieldError("resetPassword", error);
-        }
-        else {
-            authStore.authStore.setResetPasswordStep("sent");
-            authStore.authStore.clearErrors();
-        }
-        authStore.authStore.setLoading(false);
-    }
-    async resetPassword() {
-        if (!authStore.state.resetPassword.token) {
-            throw new Error("No reset token available");
-        }
-        if (!authStore.state.resetPassword.newPassword) {
-            authStore.authStore.setFieldError("resetPassword", "password_required");
-            return;
-        }
-        if (authStore.state.resetPassword.passwordConfirmation &&
-            authStore.state.resetPassword.newPassword !== authStore.state.resetPassword.passwordConfirmation) {
-            authStore.authStore.setFieldError("resetPassword", "passwords_do_not_match");
-            return;
-        }
-        authStore.authStore.setLoading(true);
-        authStore.authStore.clearErrors();
-        const [error, response] = await this.client.auth.resetPassword(authStore.state.sid, authStore.state.resetPassword.token, authStore.state.resetPassword.newPassword, authStore.state.resetPassword.passwordConfirmation);
-        if (error) {
-            authStore.authStore.setFieldError("resetPassword", error);
-            // TODO: add proper password requirements handling --> for now this is fine
-            if (error === "invalid_password") {
-                authStore.authStore.setFieldError("password", response.error_details?.password.map((p) => i18n.t(`errors.password_requirements.${p}`)).join("\n"));
-            }
-        }
-        else {
-            authStore.authStore.setStep("email");
-            authStore.authStore.updateResetPassword({
-                step: "completed",
-                token: null,
-                newPassword: "",
-                passwordConfirmation: "",
-            });
-            componentUtils.clearUrlParam("reset_password_token");
-            flashStore.Flash.success.addMessage("Password reset successfully");
-        }
-        authStore.authStore.setLoading(false);
-    }
-    async handleResetPasswordRedirect() {
-        const url = new URL(window.location.href);
-        const params = url.searchParams;
-        const resetToken = params.get("reset_password_token");
-        if (!resetToken) {
-            return;
-        }
-        if (authStore.state.sid) {
-            authStore.authStore.setLoading(true);
-            const [error] = await this.client.auth.validateResetPasswordToken(authStore.state.sid, resetToken);
-            if (error) {
-                authStore.authStore.setFieldError("resetPassword", error);
-                authStore.authStore.setStep("reset-password");
-                authStore.authStore.setLoading(false);
-                return;
-            }
-        }
-        authStore.authStore.setResetToken(resetToken);
-        authStore.authStore.setStep("reset-password");
-        authStore.authStore.setLoading(false);
-    }
-    handleSocialAuthRedirect() {
-        const url = new URL(window.location.href);
-        const params = url.searchParams;
-        const error = params.get("error");
-        // Not a social auth redirect (normal page load)
-        if (!error && !params.has("sid")) {
-            return;
-        }
-        // Handle successful social auth redirect
-        if (!error && params.has("sid") && params.has("id_token")) {
-            authStore.authStore.setSignInId(componentUtils.clearUrlParam("sid"));
-            const idToken = componentUtils.clearUrlParam("id_token");
-            if (idToken) {
-                authStore.authStore.setToken(idToken);
-                this.handleAuthSuccess({ jwt: idToken });
-            }
-            else {
-                this.logger.error("No ID token found in the URL on social auth redirect");
-            }
-            return;
-        }
-        // Handle missing required fields
-        if (error !== "missing_required_fields") {
-            this.logger.error("Social auth redirect error:", error);
-            return;
-        }
-        const fieldsFromUrl = componentUtils.clearUrlParam("fields");
-        const sid = componentUtils.clearUrlParam("sid");
-        componentUtils.clearUrlParam("error");
-        if (!fieldsFromUrl || !sid) {
-            return;
-        }
-        try {
-            const fields = JSON.parse(fieldsFromUrl);
-            authStore.authStore.setSignInId(sid);
-            this.handleMissingFields(fields);
-        }
-        catch (e) {
-            this.logger.error("Failed to parse missing fields payload:", e);
-            authStore.authStore.setGlobalError("auth", "invalid_required_fields_payload");
-        }
-    }
-    handleAuthError(error, response, fallbackField) {
-        switch (error) {
-            case "account_not_found":
-                authStore.authStore.setFieldError("email", error);
-                break;
-            case "missing_required_fields": {
-                const { fields, sid } = response;
-                this.handleMissingFields(fields);
-                if (sid) {
-                    authStore.authStore.setSignInId(sid);
-                }
-                break;
-            }
-            default:
-                if (fallbackField === "password") {
-                    authStore.authStore.setFieldError("password", error);
-                }
-                else if (fallbackField === "magicCode") {
-                    authStore.authStore.setFieldError("magicCode", error);
-                }
-                else if (fallbackField === "email") {
-                    authStore.authStore.setFieldError("email", error);
-                }
-                else {
-                    // e.g. "account_locked", "internal_server_error"
-                    authStore.authStore.setGlobalError("auth", error);
-                }
-                break;
-        }
-        authStore.authStore.setLoading(false);
-    }
-    handleMissingFields(fields) {
-        authStore.authStore.setMissingFields(fields);
-        profileStore.state.data = fields;
-        authStore.authStore.setStep("missing-fields");
-        authStore.authStore.setLoading(false);
-    }
-    handleAuthSuccess(response) {
-        authStore.authStore.setToken(response.jwt);
-        authStore.authStore.setLoading(false);
-        authStore.authStore.getRootComponentRef()?.onAuth(response);
-    }
-}
-
-class Auth {
-    static instance;
-    helpers;
-    constructor(client) {
-        this.helpers = new AuthHelpers(client);
-    }
-    static Errors = {
-        email: {
-            NOT_FOUND: "account_not_found",
-        },
-        magicCode: {
-            RECENTLY_CREATED: "magic_code_recently_created",
-            NOT_VALID: "magic_code_not_valid",
-            EXPIRED: "magic_code_expired",
-            USED: "magic_code_used",
-        },
-        password: {
-            INVALID: "invalid_password",
-            NOT_SET: "password_not_set",
-            RESET_PASSWORD_ALREADY_SENT: "reset_password_already_sent",
-        },
-        general: {
-            ACCOUNT_LOCKED: "account_locked",
-            SIGN_IN_EXPIRED: "sign_in_expired",
-        },
-    };
-    static async getInstance() {
-        if (!Auth.isInitialized()) {
-            await unidyStore.waitForConfig();
-            return Auth.initialize(index$1.getUnidyClient());
-        }
-        return Auth.instance;
-    }
-    static async initialize(client) {
-        if (Auth.instance) {
-            return Auth.instance;
-        }
-        Auth.instance = new Auth(client);
-        Auth.instance.helpers.handleSocialAuthRedirect();
-        await Auth.instance.helpers.handleResetPasswordRedirect();
-        if (Auth.instance.isTokenValid(authStore.state.token)) {
-            authStore.authStore.setAuthenticated(true);
-        }
-        return Auth.instance;
-    }
-    static isInitialized() {
-        return !!Auth.instance;
-    }
-    isTokenValid(token) {
-        try {
-            let decoded;
-            if (typeof token === "string") {
-                decoded = jwtDecode(token);
-            }
-            else {
-                decoded = token;
-            }
-            if (!decoded)
-                return false;
-            const currentTime = Date.now() / 1000;
-            return decoded.exp > currentTime;
-        }
-        catch (error) {
-            index.captureException(error);
-            return false;
-        }
-    }
-    async isAuthenticated() {
-        const token = await this.getToken();
-        return typeof token === "string";
-    }
-    async getToken() {
-        const currentToken = authStore.state.token;
-        if (currentToken && this.isTokenValid(currentToken)) {
-            return currentToken;
-        }
-        await this.helpers.refreshToken();
-        if (authStore.state.globalErrors.auth || !authStore.state.token) {
-            return this.createAuthError(i18n.t("errors.refresh_failed"), "REFRESH_FAILED", true);
-        }
-        return authStore.state.token;
-    }
-    async userData() {
-        const token = await this.getToken();
-        if (typeof token !== "string") {
-            return null;
-        }
-        if (!token) {
-            return null;
-        }
-        try {
-            return jwtDecode(token);
-        }
-        catch (error) {
-            index.captureException(error);
-            return null;
-        }
-    }
-    async logout() {
-        const [error, _] = await this.helpers.logout();
-        if (error) {
-            return this.createAuthError(i18n.t("errors.sign_out_failed", { reason: error }), "SIGN_OUT_FAILED", false);
-        }
-        authStore.authStore.reset();
-        return true;
-    }
-    getEmail() {
-        return authStore.state.email;
-    }
-    createAuthError(message, code, requiresReauth = false) {
-        const error = new Error(message);
-        error.code = code;
-        error.requiresReauth = requiresReauth;
-        return error;
-    }
-}
-
-exports.Auth = Auth;
-//# sourceMappingURL=auth-B83pzi0f.js.map
-
-//# sourceMappingURL=auth-B83pzi0f.js.map