@nocios/crudify-ui 1.0.38 → 1.0.39

package/dist/index.d.mts

@@ -0,0 +1,47 @@
+export * from '@nocios/crudify-browser';
+export { default as crudify } from '@nocios/crudify-browser';
+import React from 'react';
+
+type BoxScreenType = "login" | "signUp" | "forgotPassword" | "resetPassword" | "checkCode";
+interface CrudifyLoginConfig {
+    publicApiKey?: string;
+    env?: "dev" | "stg" | "prod";
+    appName?: string;
+    logo?: string;
+    colors?: {
+        primaryColor?: string;
+        bgColor?: string;
+        [key: string]: string | undefined;
+    };
+    loginActions?: string[];
+}
+interface CrudifyLoginProps {
+    config?: CrudifyLoginConfig;
+    onNavigate?: (path: string) => void;
+    onLoginSuccess?: (token: string, redirectUrl?: string) => void;
+    onError?: (error: string) => void;
+    initialScreen?: BoxScreenType;
+    redirectUrl?: string;
+    autoReadFromCookies?: boolean;
+    onSubdomainLoginSuccess?: (token: string, config: CrudifyLoginConfig) => void;
+}
+
+declare const CrudifyLogin: React.FC<CrudifyLoginProps>;
+
+declare const getCookie: (name: string) => string | null;
+
+declare class SecureStorage {
+    private readonly encryptionKey;
+    private readonly storage;
+    constructor(storageType?: "localStorage" | "sessionStorage");
+    private generateEncryptionKey;
+    setItem(key: string, value: string, expiryMinutes?: number): void;
+    getItem(key: string): string | null;
+    removeItem(key: string): void;
+    setToken(token: string): void;
+    getToken(): string | null;
+}
+declare const secureSessionStorage: SecureStorage;
+declare const secureLocalStorage: SecureStorage;
+
+export { type BoxScreenType, CrudifyLogin, type CrudifyLoginConfig, type CrudifyLoginProps, getCookie, secureLocalStorage, secureSessionStorage };

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+export * from '@nocios/crudify-browser';
+export { default as crudify } from '@nocios/crudify-browser';
+import React from 'react';
+
+type BoxScreenType = "login" | "signUp" | "forgotPassword" | "resetPassword" | "checkCode";
+interface CrudifyLoginConfig {
+    publicApiKey?: string;
+    env?: "dev" | "stg" | "prod";
+    appName?: string;
+    logo?: string;
+    colors?: {
+        primaryColor?: string;
+        bgColor?: string;
+        [key: string]: string | undefined;
+    };
+    loginActions?: string[];
+}
+interface CrudifyLoginProps {
+    config?: CrudifyLoginConfig;
+    onNavigate?: (path: string) => void;
+    onLoginSuccess?: (token: string, redirectUrl?: string) => void;
+    onError?: (error: string) => void;
+    initialScreen?: BoxScreenType;
+    redirectUrl?: string;
+    autoReadFromCookies?: boolean;
+    onSubdomainLoginSuccess?: (token: string, config: CrudifyLoginConfig) => void;
+}
+
+declare const CrudifyLogin: React.FC<CrudifyLoginProps>;
+
+declare const getCookie: (name: string) => string | null;
+
+declare class SecureStorage {
+    private readonly encryptionKey;
+    private readonly storage;
+    constructor(storageType?: "localStorage" | "sessionStorage");
+    private generateEncryptionKey;
+    setItem(key: string, value: string, expiryMinutes?: number): void;
+    getItem(key: string): string | null;
+    removeItem(key: string): void;
+    setToken(token: string): void;
+    getToken(): string | null;
+}
+declare const secureSessionStorage: SecureStorage;
+declare const secureLocalStorage: SecureStorage;
+
+export { type BoxScreenType, CrudifyLogin, type CrudifyLoginConfig, type CrudifyLoginProps, getCookie, secureLocalStorage, secureSessionStorage };

package/dist/index.mjs

@@ -0,0 +1,1095 @@
+// src/index.ts
+import { default as default2 } from "@nocios/crudify-browser";
+export * from "@nocios/crudify-browser";
+
+// src/components/CrudifyLogin/index.tsx
+import { useState as useState5, useMemo as useMemo2 } from "react";
+import { useTranslation as useTranslation5 } from "react-i18next";
+import { Paper, Box as Box5, Typography as Typography5 } from "@mui/material";
+
+// src/components/CrudifyLogin/Forms/LoginForm.tsx
+import { useTranslation } from "react-i18next";
+import { useState, useEffect, useRef } from "react";
+import { Typography, TextField, Button, Box, CircularProgress, Alert, Link } from "@mui/material";
+
+// src/components/CrudifyLogin/hooks/useCrudifyLogin.ts
+import { useMemo } from "react";
+import crudify from "@nocios/crudify-browser";
+var useCrudifyLogin = (config, _options = {}) => {
+  const crudifyMethods = useMemo(() => {
+    if (!config.publicApiKey) {
+      return null;
+    }
+    return {
+      login: crudify.login,
+      transaction: crudify.transaction
+    };
+  }, [config.publicApiKey, config.env]);
+  return { crudify: crudifyMethods };
+};
+
+// src/components/CrudifyLogin/utils/secureStorage.ts
+import CryptoJS from "crypto-js";
+var SecureStorage = class {
+  constructor(storageType = "sessionStorage") {
+    this.encryptionKey = this.generateEncryptionKey();
+    this.storage = storageType === "localStorage" ? window.localStorage : window.sessionStorage;
+  }
+  generateEncryptionKey() {
+    const browserFingerprint = [
+      navigator.userAgent,
+      navigator.language,
+      (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+      screen.colorDepth,
+      screen.width,
+      screen.height,
+      "crudify-login"
+    ].join("|");
+    return CryptoJS.SHA256(browserFingerprint).toString();
+  }
+  setItem(key, value, expiryMinutes) {
+    try {
+      const encrypted = CryptoJS.AES.encrypt(value, this.encryptionKey).toString();
+      this.storage.setItem(key, encrypted);
+      if (expiryMinutes) {
+        const expiryTime = (/* @__PURE__ */ new Date()).getTime() + expiryMinutes * 60 * 1e3;
+        this.storage.setItem(`${key}_expiry`, expiryTime.toString());
+      }
+    } catch (error) {
+      console.error("Failed to encrypt and store data:", error);
+    }
+  }
+  getItem(key) {
+    try {
+      const expiryKey = `${key}_expiry`;
+      const expiry = this.storage.getItem(expiryKey);
+      if (expiry) {
+        const expiryTime = parseInt(expiry, 10);
+        if ((/* @__PURE__ */ new Date()).getTime() > expiryTime) {
+          this.removeItem(key);
+          return null;
+        }
+      }
+      const encrypted = this.storage.getItem(key);
+      if (!encrypted) return null;
+      const decrypted = CryptoJS.AES.decrypt(encrypted, this.encryptionKey);
+      const result = decrypted.toString(CryptoJS.enc.Utf8);
+      if (!result) {
+        console.warn("Failed to decrypt stored data - may be corrupted");
+        this.removeItem(key);
+        return null;
+      }
+      return result;
+    } catch (error) {
+      console.error("Failed to decrypt data:", error);
+      this.removeItem(key);
+      return null;
+    }
+  }
+  removeItem(key) {
+    this.storage.removeItem(key);
+    this.storage.removeItem(`${key}_expiry`);
+  }
+  setToken(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length === 3) {
+        const payload = JSON.parse(atob(parts[1]));
+        if (payload.exp) {
+          const expiryTime = payload.exp * 1e3;
+          const now = (/* @__PURE__ */ new Date()).getTime();
+          const minutesUntilExpiry = Math.floor((expiryTime - now) / (60 * 1e3));
+          if (minutesUntilExpiry > 0) {
+            this.setItem("authToken", token, minutesUntilExpiry);
+            return;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to parse token expiry, using default expiry");
+    }
+    this.setItem("authToken", token, 24 * 60);
+  }
+  getToken() {
+    const token = this.getItem("authToken");
+    if (token) {
+      try {
+        const parts = token.split(".");
+        if (parts.length === 3) {
+          const payload = JSON.parse(atob(parts[1]));
+          if (payload.exp) {
+            const now = Math.floor(Date.now() / 1e3);
+            if (payload.exp < now) {
+              this.removeItem("authToken");
+              return null;
+            }
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to validate token expiry");
+        this.removeItem("authToken");
+        return null;
+      }
+    }
+    return token;
+  }
+};
+var secureSessionStorage = new SecureStorage("sessionStorage");
+var secureLocalStorage = new SecureStorage("localStorage");
+
+// src/components/CrudifyLogin/Forms/LoginForm.tsx
+import crudify2 from "@nocios/crudify-browser";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var LoginForm = ({
+  config,
+  onNavigate,
+  onLoginSuccess,
+  onError,
+  redirectUrl = "/",
+  onSubdomainLoginSuccess
+}) => {
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [subdomain, setSubdomain] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [errors, setErrors] = useState([]);
+  const [helperTextEmail, setHelperTextEmail] = useState(null);
+  const [helperTextPassword, setHelperTextPassword] = useState(null);
+  const [helperTextSubdomain, setHelperTextSubdomain] = useState(null);
+  const { t } = useTranslation();
+  const usernameInputRef = useRef(null);
+  const hasPublicApiKey = Boolean(config.publicApiKey);
+  const { crudify: crudifyFromHook } = useCrudifyLogin(config, {
+    showErrorNotifications: false,
+    showSuccessNotifications: false
+  });
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      if (usernameInputRef.current) usernameInputRef.current.focus();
+    }, 100);
+    return () => clearTimeout(timer);
+  }, []);
+  const getSafeErrorTranslation = (errorCode) => {
+    const possibleKeys = [
+      `errors.auth.${errorCode}`,
+      `errors.data.${errorCode}`,
+      `errors.system.${errorCode}`,
+      `errors.${errorCode}`,
+      `login.${errorCode.toLowerCase()}`
+    ];
+    for (const key of possibleKeys) {
+      const translated = t(key);
+      if (translated !== key) {
+        return translated;
+      }
+    }
+    return t("error.unknown");
+  };
+  const handleLogin = async () => {
+    if (loading) return;
+    if (!username.trim()) {
+      setHelperTextEmail(t("login.usernameRequired"));
+      return;
+    }
+    if (!password.trim()) {
+      setHelperTextPassword(t("login.passwordRequired"));
+      return;
+    }
+    if (!hasPublicApiKey && !subdomain.trim()) {
+      setHelperTextSubdomain(t("login.subdomainRequired", "Subdomain is required"));
+      return;
+    }
+    setErrors([]);
+    setHelperTextEmail(null);
+    setHelperTextPassword(null);
+    setHelperTextSubdomain(null);
+    setLoading(true);
+    try {
+      let response;
+      if (hasPublicApiKey && crudifyFromHook) {
+        response = await crudifyFromHook.login(username, password);
+      } else {
+        const data = [
+          {
+            operation: "loginWithSubdomain",
+            data: { username, password, subdomain }
+          }
+        ];
+        response = await crudify2.transaction(data);
+      }
+      setLoading(false);
+      if (response.success) {
+        secureSessionStorage.setToken(response.data.token);
+        if (!hasPublicApiKey && onSubdomainLoginSuccess) {
+          const newConfig = {
+            ...config,
+            publicApiKey: response.data.publicApiKey || config.publicApiKey,
+            appName: response.data.appName || config.appName,
+            logo: response.data.logo || config.logo,
+            colors: response.data.colors || config.colors
+          };
+          onSubdomainLoginSuccess(response.data.token, newConfig);
+        } else if (onLoginSuccess) {
+          onLoginSuccess(response.data.token, redirectUrl);
+        }
+      } else {
+        handleLoginError(response);
+      }
+    } catch (error) {
+      setLoading(false);
+      console.error("Login error:", error);
+      setErrors([t("error.unknown")]);
+      if (onError) {
+        onError(typeof error === "string" ? error : t("error.unknown"));
+      }
+    }
+  };
+  const handleLoginError = (response) => {
+    if (response.data?.response) {
+      const { data: errorMessage, status, fieldsWarning } = response.data.response;
+      if (fieldsWarning) {
+        if (fieldsWarning.username) setHelperTextEmail(fieldsWarning.username[0]);
+        if (fieldsWarning.password) setHelperTextPassword(fieldsWarning.password[0]);
+        if (fieldsWarning.subdomain) setHelperTextSubdomain(fieldsWarning.subdomain[0]);
+      } else if (status === "INVALID_CREDENTIALS") {
+        const translatedError = getSafeErrorTranslation(status);
+        setErrors([translatedError]);
+      } else if (status === "TOO_MANY_REQUESTS") {
+        const translatedError = getSafeErrorTranslation(status);
+        setErrors([translatedError]);
+      } else if (status === "SUBDOMAIN_NOT_FOUND") {
+        setHelperTextSubdomain(t("login.subdomainNotFound", "Subdomain not found"));
+      } else if (status) {
+        setErrors([getSafeErrorTranslation(status)]);
+      } else {
+        setErrors([typeof errorMessage === "string" ? errorMessage : t("error.unknown")]);
+      }
+    } else if (response.errors) {
+      const errors2 = response.errors;
+      if (typeof errors2 === "string") {
+        setErrors([errors2]);
+      } else if (typeof errors2 === "object") {
+        const hasUsernameError = errors2.username && errors2.username.length > 0;
+        const hasPasswordError = errors2.password && errors2.password.length > 0;
+        const hasSubdomainError = errors2.subdomain && errors2.subdomain.length > 0;
+        if (hasUsernameError || hasPasswordError || hasSubdomainError) {
+          if (hasUsernameError) setHelperTextEmail(errors2.username[0]);
+          if (hasPasswordError) setHelperTextPassword(errors2.password[0]);
+          if (hasSubdomainError) setHelperTextSubdomain(errors2.subdomain[0]);
+        } else if (errors2._error && errors2._error.length > 0) {
+          const errorMessage = errors2._error[0];
+          if (typeof errorMessage === "string" && errorMessage.match(/^[A-Z_]+$/)) {
+            const translatedError = getSafeErrorTranslation(errorMessage);
+            setErrors([translatedError]);
+          } else setErrors([errorMessage]);
+        } else if (errors2._graphql && errors2._graphql[0] === "INVALID_CREDENTIALS") {
+          setErrors([getSafeErrorTranslation("INVALID_CREDENTIALS")]);
+        } else {
+          setErrors([t("error.unknown")]);
+        }
+      }
+    } else {
+      setErrors([t("error.unknown")]);
+    }
+  };
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    handleLogin();
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !loading) {
+      e.preventDefault();
+      handleLogin();
+    }
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        component: "form",
+        noValidate: true,
+        onSubmit: handleSubmit,
+        onKeyDown: handleKeyDown,
+        sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 },
+        children: [
+          !hasPublicApiKey && /* @__PURE__ */ jsxs(Box, { sx: { mb: 1 }, children: [
+            /* @__PURE__ */ jsx(
+              Typography,
+              {
+                variant: "body2",
+                component: "label",
+                htmlFor: "subdomain",
+                sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+                children: t("login.subdomainLabel", "Subdomain")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              TextField,
+              {
+                fullWidth: true,
+                id: "subdomain",
+                name: "subdomain",
+                type: "text",
+                value: subdomain,
+                disabled: loading,
+                onChange: (e) => setSubdomain(e.target.value),
+                error: !!helperTextSubdomain,
+                helperText: helperTextSubdomain,
+                placeholder: t("login.subdomainPlaceholder", "Enter your subdomain"),
+                required: true
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { sx: { mb: 1 }, children: [
+            /* @__PURE__ */ jsx(
+              Typography,
+              {
+                variant: "body2",
+                component: "label",
+                htmlFor: "email",
+                sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+                children: t("login.usernameOrEmailLabel")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              TextField,
+              {
+                fullWidth: true,
+                id: "email",
+                name: "email",
+                type: "email",
+                value: username,
+                disabled: loading,
+                onChange: (e) => setUsername(e.target.value),
+                error: !!helperTextEmail,
+                helperText: helperTextEmail,
+                autoComplete: "email",
+                placeholder: t("login.usernameOrEmailPlaceholder"),
+                inputRef: usernameInputRef,
+                required: true
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Box, { sx: { mb: 1 }, children: [
+            /* @__PURE__ */ jsx(
+              Typography,
+              {
+                variant: "body2",
+                component: "label",
+                htmlFor: "password",
+                sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+                children: t("login.passwordLabel")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              TextField,
+              {
+                fullWidth: true,
+                id: "password",
+                name: "password",
+                type: "password",
+                value: password,
+                disabled: loading,
+                onChange: (e) => setPassword(e.target.value),
+                error: !!helperTextPassword,
+                helperText: helperTextPassword,
+                autoComplete: "current-password",
+                placeholder: t("login.passwordPlaceholder"),
+                required: true
+              }
+            )
+          ] }),
+          config.loginActions?.includes("forgotPassword") && /* @__PURE__ */ jsx(Box, { sx: { display: "flex", justifyContent: "flex-end", alignItems: "center" }, children: /* @__PURE__ */ jsx(Link, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login/forgotPassword"), variant: "body2", color: "secondary", children: t("login.forgotPasswordLink") }) }),
+          /* @__PURE__ */ jsx(Button, { disabled: loading, type: "submit", fullWidth: true, variant: "contained", color: "primary", sx: { mt: 1, mb: 2 }, children: loading ? /* @__PURE__ */ jsx(CircularProgress, { size: 20 }) : t("login.loginButton") })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(Box, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx(Alert, { variant: "filled", sx: { mt: 2 }, severity: "error", children: /* @__PURE__ */ jsx("div", { children: error }) }, index)) }),
+    config.loginActions?.includes("createUser") && /* @__PURE__ */ jsxs(Typography, { variant: "body2", align: "center", sx: { color: "text.secondary", mt: 3 }, children: [
+      t("login.noAccountPrompt"),
+      " ",
+      /* @__PURE__ */ jsx(Link, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/public/users/create"), fontWeight: "medium", color: "secondary", children: t("login.signUpLink") })
+    ] })
+  ] });
+};
+var LoginForm_default = LoginForm;
+
+// src/components/CrudifyLogin/Forms/ForgotPasswordForm.tsx
+import { useTranslation as useTranslation2 } from "react-i18next";
+import { useState as useState2 } from "react";
+import { Typography as Typography2, TextField as TextField2, Button as Button2, Box as Box2, CircularProgress as CircularProgress2, Alert as Alert2, Link as Link2 } from "@mui/material";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var ForgotPasswordForm = ({ config, onNavigate, onError }) => {
+  const [email, setEmail] = useState2("");
+  const [loading, setLoading] = useState2(false);
+  const [errors, setErrors] = useState2([]);
+  const [helperTextEmail, setHelperTextEmail] = useState2(null);
+  const [emailSent, setEmailSent] = useState2(false);
+  const [codeAlreadyExists, setCodeAlreadyExists] = useState2(false);
+  const { t } = useTranslation2();
+  const { crudify: crudify3 } = useCrudifyLogin(config);
+  const validateEmail = (email2) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email2);
+  };
+  const handleSubmit = async () => {
+    if (loading || !crudify3) return;
+    setErrors([]);
+    setHelperTextEmail(null);
+    if (!email) {
+      setHelperTextEmail(t("forgotPassword.emailRequired"));
+      return;
+    }
+    if (!validateEmail(email)) {
+      setHelperTextEmail(t("forgotPassword.invalidEmail"));
+      return;
+    }
+    setLoading(true);
+    try {
+      const data = [{ operation: "requestPasswordReset", data: { email } }];
+      const response = await crudify3.transaction(data);
+      if (response.success) {
+        if (response.data && response.data.existingCodeValid) {
+          setCodeAlreadyExists(true);
+        } else {
+          setEmailSent(true);
+        }
+      } else {
+        if (response.errors) {
+          if (typeof response.errors === "string") {
+            setErrors([response.errors]);
+          } else if (response.errors.email) {
+            setHelperTextEmail(response.errors.email[0]);
+          } else {
+            setErrors([t("error.unknown")]);
+          }
+        } else {
+          setErrors([t("error.unknown")]);
+        }
+      }
+    } catch (error) {
+      console.error("Forgot password error:", error);
+      setErrors([t("error.unknown")]);
+      if (onError) {
+        onError(typeof error === "string" ? error : t("error.unknown"));
+      }
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleFormSubmit = (e) => {
+    e.preventDefault();
+    handleSubmit();
+  };
+  if (emailSent) {
+    return /* @__PURE__ */ jsxs2(Box2, { sx: { textAlign: "center" }, children: [
+      /* @__PURE__ */ jsx2(Alert2, { severity: "success", sx: { mb: 3 }, children: t("forgotPassword.emailSentMessage") }),
+      /* @__PURE__ */ jsx2(Typography2, { variant: "body2", sx: { mb: 2 }, children: t("forgotPassword.checkEmailInstructions") }),
+      /* @__PURE__ */ jsx2(Link2, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login/checkCode"), variant: "body2", color: "primary", children: t("forgotPassword.enterCodeLink") }),
+      /* @__PURE__ */ jsx2(Box2, { sx: { mt: 2 }, children: /* @__PURE__ */ jsx2(Link2, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login"), variant: "body2", color: "secondary", children: t("common.backToLogin") }) })
+    ] });
+  }
+  if (codeAlreadyExists) {
+    return /* @__PURE__ */ jsxs2(Box2, { sx: { textAlign: "center" }, children: [
+      /* @__PURE__ */ jsx2(Alert2, { severity: "info", sx: { mb: 3 }, children: t("forgotPassword.codeAlreadyExistsMessage") }),
+      /* @__PURE__ */ jsx2(Link2, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login/checkCode"), variant: "body2", color: "primary", children: t("forgotPassword.enterCodeLink") }),
+      /* @__PURE__ */ jsx2(Box2, { sx: { mt: 2 }, children: /* @__PURE__ */ jsx2(Link2, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login"), variant: "body2", color: "secondary", children: t("common.backToLogin") }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsx2(Typography2, { variant: "h5", component: "h1", sx: { mb: 3, textAlign: "center" }, children: t("forgotPassword.title") }),
+    /* @__PURE__ */ jsx2(Typography2, { variant: "body2", sx: { mb: 3, textAlign: "center", color: "text.secondary" }, children: t("forgotPassword.instructions") }),
+    /* @__PURE__ */ jsxs2(Box2, { component: "form", noValidate: true, onSubmit: handleFormSubmit, children: [
+      /* @__PURE__ */ jsxs2(Box2, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx2(
+          Typography2,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "email",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("forgotPassword.emailLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          TextField2,
+          {
+            fullWidth: true,
+            id: "email",
+            name: "email",
+            type: "email",
+            value: email,
+            disabled: loading,
+            onChange: (e) => setEmail(e.target.value),
+            error: !!helperTextEmail,
+            helperText: helperTextEmail,
+            autoComplete: "email",
+            placeholder: t("forgotPassword.emailPlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx2(Button2, { disabled: loading, type: "submit", fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: loading ? /* @__PURE__ */ jsx2(CircularProgress2, { size: 20 }) : t("forgotPassword.sendCodeButton") }),
+      /* @__PURE__ */ jsx2(Box2, { sx: { textAlign: "center" }, children: /* @__PURE__ */ jsx2(Link2, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login"), variant: "body2", color: "secondary", children: t("common.backToLogin") }) })
+    ] }),
+    errors.length > 0 && /* @__PURE__ */ jsx2(Box2, { sx: { mt: 2 }, children: errors.map((error, index) => /* @__PURE__ */ jsx2(Alert2, { variant: "filled", severity: "error", children: error }, index)) })
+  ] });
+};
+var ForgotPasswordForm_default = ForgotPasswordForm;
+
+// src/components/CrudifyLogin/Forms/ResetPasswordForm.tsx
+import { useTranslation as useTranslation3 } from "react-i18next";
+import { useState as useState3, useEffect as useEffect2 } from "react";
+import { Typography as Typography3, TextField as TextField3, Button as Button3, Box as Box3, CircularProgress as CircularProgress3, Alert as Alert3, Link as Link3 } from "@mui/material";
+import { Fragment as Fragment3, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var ResetPasswordForm = ({ config, onNavigate, onError, searchParams }) => {
+  const [newPassword, setNewPassword] = useState3("");
+  const [confirmPassword, setConfirmPassword] = useState3("");
+  const [loading, setLoading] = useState3(false);
+  const [errors, setErrors] = useState3([]);
+  const [helperTextNewPassword, setHelperTextNewPassword] = useState3(null);
+  const [helperTextConfirmPassword, setHelperTextConfirmPassword] = useState3(null);
+  const [email, setEmail] = useState3("");
+  const [code, setCode] = useState3("");
+  const [validatingCode, setValidatingCode] = useState3(true);
+  const [codeValidated, setCodeValidated] = useState3(false);
+  const [resetSuccess, setResetSuccess] = useState3(false);
+  const { t } = useTranslation3();
+  const { crudify: crudify3 } = useCrudifyLogin(config);
+  useEffect2(() => {
+    const validateCode = async (emailToValidate, codeToValidate) => {
+      if (!crudify3) return;
+      try {
+        const data = [
+          {
+            operation: "validatePasswordResetCode",
+            data: { email: emailToValidate, codePassword: codeToValidate }
+          }
+        ];
+        const response = await crudify3.transaction(data);
+        if (response.success) {
+          setCodeValidated(true);
+        } else {
+          setErrors([t("resetPassword.invalidCode")]);
+        }
+      } catch (error) {
+        console.error("Code validation error:", error);
+        setErrors([t("error.unknown")]);
+      } finally {
+        setValidatingCode(false);
+      }
+    };
+    if (searchParams) {
+      const emailParam = searchParams.get("email");
+      const codeParam = searchParams.get("code");
+      if (emailParam && codeParam) {
+        setEmail(emailParam);
+        setCode(codeParam);
+        validateCode(emailParam, codeParam);
+      } else {
+        setValidatingCode(false);
+        setErrors([t("resetPassword.missingParameters")]);
+      }
+    } else {
+      setValidatingCode(false);
+      setErrors([t("resetPassword.missingParameters")]);
+    }
+  }, [searchParams, crudify3, t]);
+  const validatePasswords = () => {
+    setHelperTextNewPassword(null);
+    setHelperTextConfirmPassword(null);
+    if (!newPassword) {
+      setHelperTextNewPassword(t("resetPassword.newPasswordRequired"));
+      return false;
+    }
+    if (newPassword.length < 8) {
+      setHelperTextNewPassword(t("resetPassword.passwordTooShort"));
+      return false;
+    }
+    if (!confirmPassword) {
+      setHelperTextConfirmPassword(t("resetPassword.confirmPasswordRequired"));
+      return false;
+    }
+    if (newPassword !== confirmPassword) {
+      setHelperTextConfirmPassword(t("resetPassword.passwordsDoNotMatch"));
+      return false;
+    }
+    return true;
+  };
+  const handleSubmit = async () => {
+    if (loading || !crudify3) return;
+    setErrors([]);
+    if (!validatePasswords()) return;
+    setLoading(true);
+    try {
+      const data = [
+        {
+          operation: "validateAndResetPassword",
+          data: { email, codePassword: code, newPassword }
+        }
+      ];
+      const response = await crudify3.transaction(data);
+      if (response.success) {
+        setResetSuccess(true);
+      } else {
+        if (response.errors) {
+          if (typeof response.errors === "string") {
+            setErrors([response.errors]);
+          } else {
+            if (response.errors.newPassword) {
+              setHelperTextNewPassword(response.errors.newPassword[0]);
+            }
+            if (response.errors._error) {
+              setErrors(response.errors._error);
+            }
+          }
+        } else {
+          setErrors([t("error.unknown")]);
+        }
+      }
+    } catch (error) {
+      console.error("Reset password error:", error);
+      setErrors([t("error.unknown")]);
+      if (onError) {
+        onError(typeof error === "string" ? error : t("error.unknown"));
+      }
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleFormSubmit = (e) => {
+    e.preventDefault();
+    handleSubmit();
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !loading) {
+      e.preventDefault();
+      handleSubmit();
+    }
+  };
+  if (validatingCode) {
+    return /* @__PURE__ */ jsxs3(Box3, { sx: { textAlign: "center", py: 4 }, children: [
+      /* @__PURE__ */ jsx3(CircularProgress3, { size: 40 }),
+      /* @__PURE__ */ jsx3(Typography3, { variant: "body2", sx: { mt: 2 }, children: t("resetPassword.validatingCode") })
+    ] });
+  }
+  if (resetSuccess) {
+    return /* @__PURE__ */ jsxs3(Box3, { sx: { textAlign: "center" }, children: [
+      /* @__PURE__ */ jsx3(Alert3, { severity: "success", sx: { mb: 3 }, children: t("resetPassword.successMessage") }),
+      /* @__PURE__ */ jsx3(Typography3, { variant: "body2", sx: { mb: 3 }, children: t("resetPassword.successInstructions") }),
+      /* @__PURE__ */ jsx3(Button3, { variant: "contained", color: "primary", onClick: () => onNavigate?.("/login"), fullWidth: true, children: t("resetPassword.goToLoginButton") })
+    ] });
+  }
+  if (!codeValidated) {
+    return /* @__PURE__ */ jsxs3(Box3, { sx: { textAlign: "center" }, children: [
+      /* @__PURE__ */ jsx3(Alert3, { severity: "error", sx: { mb: 3 }, children: t("resetPassword.codeExpiredOrInvalid") }),
+      /* @__PURE__ */ jsxs3(Box3, { sx: { display: "flex", flexDirection: "column", gap: 2 }, children: [
+        /* @__PURE__ */ jsx3(Button3, { variant: "contained", color: "primary", onClick: () => onNavigate?.("/login/forgotPassword"), fullWidth: true, children: t("resetPassword.requestNewCodeButton") }),
+        /* @__PURE__ */ jsx3(Link3, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login"), variant: "body2", color: "secondary", children: t("common.backToLogin") })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+    /* @__PURE__ */ jsx3(Typography3, { variant: "h5", component: "h1", sx: { mb: 3, textAlign: "center" }, children: t("resetPassword.title") }),
+    /* @__PURE__ */ jsx3(Typography3, { variant: "body2", sx: { mb: 3, textAlign: "center", color: "text.secondary" }, children: t("resetPassword.instructions") }),
+    /* @__PURE__ */ jsxs3(Box3, { component: "form", noValidate: true, onSubmit: handleFormSubmit, onKeyDown: handleKeyDown, children: [
+      /* @__PURE__ */ jsxs3(Box3, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx3(
+          Typography3,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "newPassword",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("resetPassword.newPasswordLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          TextField3,
+          {
+            fullWidth: true,
+            id: "newPassword",
+            name: "newPassword",
+            type: "password",
+            value: newPassword,
+            disabled: loading,
+            onChange: (e) => setNewPassword(e.target.value),
+            error: !!helperTextNewPassword,
+            helperText: helperTextNewPassword,
+            autoComplete: "new-password",
+            placeholder: t("resetPassword.newPasswordPlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs3(Box3, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx3(
+          Typography3,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "confirmPassword",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("resetPassword.confirmPasswordLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          TextField3,
+          {
+            fullWidth: true,
+            id: "confirmPassword",
+            name: "confirmPassword",
+            type: "password",
+            value: confirmPassword,
+            disabled: loading,
+            onChange: (e) => setConfirmPassword(e.target.value),
+            error: !!helperTextConfirmPassword,
+            helperText: helperTextConfirmPassword,
+            autoComplete: "new-password",
+            placeholder: t("resetPassword.confirmPasswordPlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx3(Button3, { disabled: loading, type: "submit", fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: loading ? /* @__PURE__ */ jsx3(CircularProgress3, { size: 20 }) : t("resetPassword.resetPasswordButton") }),
+      /* @__PURE__ */ jsx3(Box3, { sx: { textAlign: "center" }, children: /* @__PURE__ */ jsx3(Link3, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login"), variant: "body2", color: "secondary", children: t("common.backToLogin") }) })
+    ] }),
+    errors.length > 0 && /* @__PURE__ */ jsx3(Box3, { sx: { mt: 2 }, children: errors.map((error, index) => /* @__PURE__ */ jsx3(Alert3, { variant: "filled", severity: "error", children: error }, index)) })
+  ] });
+};
+var ResetPasswordForm_default = ResetPasswordForm;
+
+// src/components/CrudifyLogin/Forms/CheckCodeForm.tsx
+import { useTranslation as useTranslation4 } from "react-i18next";
+import { useState as useState4, useEffect as useEffect3 } from "react";
+import { Typography as Typography4, TextField as TextField4, Button as Button4, Box as Box4, CircularProgress as CircularProgress4, Alert as Alert4, Link as Link4 } from "@mui/material";
+import { Fragment as Fragment4, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var CheckCodeForm = ({ config, onNavigate, onError }) => {
+  const [email, setEmail] = useState4("");
+  const [code, setCode] = useState4("");
+  const [loading, setLoading] = useState4(false);
+  const [errors, setErrors] = useState4([]);
+  const [helperTextEmail, setHelperTextEmail] = useState4(null);
+  const [helperTextCode, setHelperTextCode] = useState4(null);
+  const { t } = useTranslation4();
+  const { crudify: crudify3 } = useCrudifyLogin(config);
+  useEffect3(() => {
+    const timer = setTimeout(() => {
+      const emailInput = document.getElementById("email");
+      if (emailInput) emailInput.focus();
+    }, 100);
+    return () => clearTimeout(timer);
+  }, []);
+  const validateEmail = (email2) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email2);
+  };
+  const handleSubmit = async () => {
+    if (loading || !crudify3) return;
+    setErrors([]);
+    setHelperTextEmail(null);
+    setHelperTextCode(null);
+    if (!email) {
+      setHelperTextEmail(t("checkCode.emailRequired"));
+      return;
+    }
+    if (!validateEmail(email)) {
+      setHelperTextEmail(t("checkCode.invalidEmail"));
+      return;
+    }
+    if (!code) {
+      setHelperTextCode(t("checkCode.codeRequired"));
+      return;
+    }
+    setLoading(true);
+    try {
+      const data = [
+        {
+          operation: "validatePasswordResetCode",
+          data: { email, codePassword: code }
+        }
+      ];
+      const response = await crudify3.transaction(data);
+      if (response.success) {
+        const params = new URLSearchParams({ email, code }).toString();
+        onNavigate?.(`/login/resetPassword?${params}`);
+      } else {
+        if (response.errors) {
+          if (typeof response.errors === "string") {
+            setErrors([response.errors]);
+          } else {
+            if (response.errors.email) setHelperTextEmail(response.errors.email[0]);
+            if (response.errors.code) setHelperTextCode(response.errors.code[0]);
+            if (response.errors._error) setErrors(response.errors._error);
+          }
+        } else {
+          setErrors([t("error.unknown")]);
+        }
+      }
+    } catch (error) {
+      console.error("Check code error:", error);
+      setErrors([t("error.unknown")]);
+      if (onError) {
+        onError(typeof error === "string" ? error : t("error.unknown"));
+      }
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleFormSubmit = (e) => {
+    e.preventDefault();
+    handleSubmit();
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !loading) {
+      e.preventDefault();
+      handleSubmit();
+    }
+  };
+  return /* @__PURE__ */ jsxs4(Fragment4, { children: [
+    /* @__PURE__ */ jsx4(Typography4, { variant: "h5", component: "h1", sx: { mb: 3, textAlign: "center" }, children: t("checkCode.title") }),
+    /* @__PURE__ */ jsx4(Typography4, { variant: "body2", sx: { mb: 3, textAlign: "center", color: "text.secondary" }, children: t("checkCode.instructions") }),
+    /* @__PURE__ */ jsxs4(Box4, { component: "form", noValidate: true, onSubmit: handleFormSubmit, onKeyDown: handleKeyDown, children: [
+      /* @__PURE__ */ jsxs4(Box4, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx4(
+          Typography4,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "email",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("checkCode.emailLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          TextField4,
+          {
+            fullWidth: true,
+            id: "email",
+            name: "email",
+            type: "email",
+            value: email,
+            disabled: loading,
+            onChange: (e) => setEmail(e.target.value),
+            error: !!helperTextEmail,
+            helperText: helperTextEmail,
+            autoComplete: "email",
+            placeholder: t("checkCode.emailPlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4(Box4, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx4(
+          Typography4,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "code",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("checkCode.codeLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          TextField4,
+          {
+            fullWidth: true,
+            id: "code",
+            name: "code",
+            type: "text",
+            value: code,
+            disabled: loading,
+            onChange: (e) => setCode(e.target.value),
+            error: !!helperTextCode,
+            helperText: helperTextCode,
+            placeholder: t("checkCode.codePlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx4(Button4, { disabled: loading, type: "submit", fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: loading ? /* @__PURE__ */ jsx4(CircularProgress4, { size: 20 }) : t("checkCode.verifyButton") }),
+      /* @__PURE__ */ jsxs4(Box4, { sx: { textAlign: "center", display: "flex", flexDirection: "column", gap: 1 }, children: [
+        /* @__PURE__ */ jsx4(Link4, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login/forgotPassword"), variant: "body2", color: "primary", children: t("checkCode.resendCodeLink") }),
+        /* @__PURE__ */ jsx4(Link4, { sx: { cursor: "pointer" }, onClick: () => onNavigate?.("/login"), variant: "body2", color: "secondary", children: t("common.backToLogin") })
+      ] })
+    ] }),
+    errors.length > 0 && /* @__PURE__ */ jsx4(Box4, { sx: { mt: 2 }, children: errors.map((error, index) => /* @__PURE__ */ jsx4(Alert4, { variant: "filled", severity: "error", children: error }, index)) })
+  ] });
+};
+var CheckCodeForm_default = CheckCodeForm;
+
+// src/components/CrudifyLogin/utils/cookies.ts
+var getCookie = (name) => {
+  const match = document.cookie.match(new RegExp("(^|;)\\s*" + name + "=([^;]+)"));
+  return match ? match[2] : null;
+};
+
+// src/components/CrudifyLogin/index.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var CrudifyLogin = ({
+  config: providedConfig,
+  onNavigate,
+  onLoginSuccess,
+  onError,
+  onSubdomainLoginSuccess,
+  initialScreen = "login",
+  redirectUrl = "/",
+  autoReadFromCookies = true
+}) => {
+  const { t } = useTranslation5();
+  const [currentScreen, setCurrentScreen] = useState5(initialScreen);
+  const [searchParams, setSearchParams] = useState5();
+  const finalConfig = useMemo2(() => {
+    let cookieConfig = {};
+    if (autoReadFromCookies) {
+      try {
+        const publicApiKeyFromCookie = getCookie("publicApiKey");
+        const envFromCookie = getCookie("environment") || "prod";
+        const appNameFromCookie = getCookie("appName") || "Crudia";
+        const loginActionsFromCookie = (getCookie("loginActions") ?? "").split(",").map((action) => action.trim()).filter(Boolean);
+        let logoValue;
+        let appColorsValue = { primaryColor: "#1066BA" };
+        try {
+          const encodedLogo = getCookie("logo");
+          if (encodedLogo) {
+            const decodedLogo = decodeURIComponent(encodedLogo);
+            if (decodedLogo.startsWith("http")) logoValue = decodedLogo;
+          }
+        } catch (e) {
+          console.warn("Could not decode logo from cookie, using default.", e);
+        }
+        try {
+          const colorsCookie = getCookie("colors");
+          if (colorsCookie) {
+            const decodedColorsString = decodeURIComponent(colorsCookie);
+            const parsedColors = JSON.parse(decodedColorsString);
+            appColorsValue = { ...appColorsValue, ...parsedColors };
+          }
+        } catch (e) {
+          console.error("Failed to parse colors from cookie, using defaults.", e);
+        }
+        cookieConfig = {
+          publicApiKey: publicApiKeyFromCookie || void 0,
+          env: envFromCookie,
+          appName: decodeURIComponent(appNameFromCookie),
+          loginActions: loginActionsFromCookie,
+          logo: logoValue,
+          colors: appColorsValue
+        };
+      } catch (e) {
+        console.error("Error reading configuration from cookies:", e);
+      }
+    }
+    return {
+      publicApiKey: providedConfig?.publicApiKey || cookieConfig.publicApiKey,
+      env: providedConfig?.env || cookieConfig.env || "prod",
+      appName: providedConfig?.appName || cookieConfig.appName || "Crudia",
+      logo: providedConfig?.logo || cookieConfig.logo,
+      colors: { ...cookieConfig.colors, ...providedConfig?.colors },
+      loginActions: providedConfig?.loginActions || cookieConfig.loginActions || []
+    };
+  }, [providedConfig, autoReadFromCookies]);
+  const handleNavigate = (path) => {
+    const [basePath, queryString] = path.split("?");
+    if (queryString) {
+      setSearchParams(new URLSearchParams(queryString));
+    } else {
+      setSearchParams(void 0);
+    }
+    if (basePath.includes("/forgotPassword")) {
+      setCurrentScreen("forgotPassword");
+    } else if (basePath.includes("/checkCode")) {
+      setCurrentScreen("checkCode");
+    } else if (basePath.includes("/resetPassword")) {
+      setCurrentScreen("resetPassword");
+    } else {
+      setCurrentScreen("login");
+    }
+    onNavigate?.(path);
+  };
+  const renderCurrentForm = () => {
+    const commonProps = {
+      config: finalConfig,
+      onNavigate: handleNavigate,
+      onError,
+      redirectUrl
+    };
+    switch (currentScreen) {
+      case "forgotPassword":
+        return /* @__PURE__ */ jsx5(ForgotPasswordForm_default, { ...commonProps });
+      case "checkCode":
+        return /* @__PURE__ */ jsx5(CheckCodeForm_default, { ...commonProps });
+      case "resetPassword":
+        return /* @__PURE__ */ jsx5(ResetPasswordForm_default, { ...commonProps, searchParams });
+      default:
+        return /* @__PURE__ */ jsx5(LoginForm_default, { ...commonProps, onLoginSuccess, onSubdomainLoginSuccess });
+    }
+  };
+  return /* @__PURE__ */ jsx5(
+    Box5,
+    {
+      sx: {
+        display: "flex",
+        justifyContent: "center",
+        alignItems: "center",
+        minHeight: "100vh",
+        padding: 2,
+        backgroundColor: finalConfig.colors?.bgColor || "#f5f5f5"
+      },
+      children: /* @__PURE__ */ jsxs5(
+        Paper,
+        {
+          elevation: 3,
+          sx: {
+            p: 4,
+            width: "100%",
+            maxWidth: 400,
+            display: "flex",
+            flexDirection: "column",
+            background: finalConfig.colors?.bgColor || "#fff"
+          },
+          children: [
+            /* @__PURE__ */ jsx5(Box5, { sx: { display: "flex", justifyContent: "center", mb: 3 }, children: /* @__PURE__ */ jsx5(
+              "img",
+              {
+                src: finalConfig.logo || "/nocios-default.png",
+                alt: t("login.logoAlt"),
+                style: {
+                  width: "100%",
+                  maxWidth: "150px",
+                  height: "auto"
+                },
+                onError: (e) => {
+                  const target = e.target;
+                  target.src = "/nocios-default.png";
+                }
+              }
+            ) }),
+            finalConfig.appName && /* @__PURE__ */ jsx5(
+              Typography5,
+              {
+                variant: "h6",
+                component: "h1",
+                sx: {
+                  textAlign: "center",
+                  mb: 2,
+                  color: finalConfig.colors?.primaryColor || "#1066BA"
+                },
+                children: finalConfig.appName
+              }
+            ),
+            renderCurrentForm()
+          ]
+        }
+      )
+    }
+  );
+};
+var CrudifyLogin_default = CrudifyLogin;
+export {
+  CrudifyLogin_default as CrudifyLogin,
+  default2 as crudify,
+  getCookie,
+  secureLocalStorage,
+  secureSessionStorage
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocios/crudify-ui",
-  "version": "1.0.38",
+  "version": "1.0.39",
   "description": "Biblioteca de componentes UI para Crudify",
   "author": "Nocios",
   "license": "MIT",
@@ -15,7 +15,7 @@
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts",
+    "build": "tsup",
     "start": "vite example",
     "prepublishOnly": "npm run build"
   },

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+  external: ['react', 'react-dom', '@mui/material', '@mui/icons-material']
+})