irismail 0.1.0 → 0.5.0

package/dist/index.js

@@ -32,193 +32,54 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  EmailService: () => EmailService,
   InputOTP: () => InputOTP,
   InputOTPGroup: () => InputOTPGroup,
   InputOTPSeparator: () => InputOTPSeparator,
   InputOTPSlot: () => InputOTPSlot,
-  IrisMailService: () => IrisMailService,
-  OTPService: () => OTPService,
-  OTP_DEFAULTS: () => OTP_DEFAULTS,
-  cn: () => cn,
-  decrypt: () => decrypt,
-  encrypt: () => encrypt,
-  useOTP: () => useOTP
+  IrisMail: () => IrisMail,
+  OTP: () => OTP,
+  cn: () => cn
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/server/email.ts
 var import_nodemailer = __toESM(require("nodemailer"));
-var EmailService = class {
+var IrisMail = class {
   constructor(config) {
     __publicField(this, "transporter");
-    __publicField(this, "config");
-    this.config = config;
-    this.transporter = import_nodemailer.default.createTransport(config.transport);
-  }
-  /**
-   * Verify SMTP connection configuration
-   */
-  async verifyConnection() {
-    try {
-      await this.transporter.verify();
-      return true;
-    } catch (error) {
-      console.error("SMTP connection verification failed:", error);
-      return false;
-    }
+    this.transporter = import_nodemailer.default.createTransport({
+      host: "smtp.gmail.com",
+      port: 587,
+      secure: false,
+      // true for 465, false for other ports
+      auth: config.auth
+    });
   }
   /**
    * Send an email
-   * @param options - Email options (to, subject, html, text, from)
-   * @returns - Result of the send operation
+   * @param options - Email options (from, to, subject, html)
+   * @returns Promise with success status and messageId
    */
-  async sendEmail(options) {
-    const from = options.from || this.config.defaults?.from;
-    if (!from) {
-      throw new Error("From address is required either in options or config defaults");
-    }
-    const mailOptions = {
-      from: {
-        name: from.name,
-        address: from.address
-      },
-      to: options.to,
-      subject: options.subject,
-      html: options.html,
-      text: options.text || options.html.replace(/<[^>]*>/g, "")
-      // Simple HTML to text fallback
+  async sendMail(options) {
+    const { from, to, subject, html } = options;
+    const text = html.replace(/<[^>]*>/g, "");
+    const info = await this.transporter.sendMail({
+      from,
+      to,
+      subject,
+      html,
+      text
+    });
+    return {
+      success: true,
+      messageId: info.messageId
     };
-    try {
-      const info = await this.transporter.sendMail(mailOptions);
-      return {
-        success: true,
-        messageId: info.messageId
-      };
-    } catch (error) {
-      console.error("Error sending email:", error);
-      throw error;
-    }
-  }
-};
-
-// src/server/crypto.ts
-var import_crypto = __toESM(require("crypto"));
-var ALGORITHM = "aes-256-cbc";
-function encrypt(text, secretKey) {
-  try {
-    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
-    const iv = import_crypto.default.randomBytes(16);
-    const cipher = import_crypto.default.createCipheriv(ALGORITHM, key, iv);
-    let encrypted = cipher.update(text, "utf8", "base64");
-    encrypted += cipher.final("base64");
-    return iv.toString("hex") + ":" + encrypted;
-  } catch (error) {
-    console.error("Encryption error:", error);
-    throw new Error("Failed to encrypt data");
-  }
-}
-function decrypt(encryptedText, secretKey) {
-  try {
-    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
-    const parts = encryptedText.split(":");
-    if (parts.length !== 2) {
-      throw new Error("Invalid encrypted text format");
-    }
-    const iv = Buffer.from(parts[0], "hex");
-    const encrypted = parts[1];
-    const decipher = import_crypto.default.createDecipheriv(ALGORITHM, key, iv);
-    let decrypted = decipher.update(encrypted, "base64", "utf8");
-    decrypted += decipher.final("utf8");
-    return decrypted;
-  } catch (error) {
-    console.error("Decryption error:", error);
-    throw new Error("Failed to decrypt data");
-  }
-}
-
-// src/server/otp.ts
-var OTPService = class {
-  constructor(secretKey) {
-    __publicField(this, "secretKey");
-    if (!secretKey) {
-      throw new Error("OTPService: secretKey is required");
-    }
-    this.secretKey = secretKey;
-  }
-  /**
-   * Generate a numeric OTP of specified length
-   * @param length - Length of the OTP (default: 6)
-   * @returns - The generated OTP string
-   */
-  generateOTP(length = 6) {
-    const min = Math.pow(10, length - 1);
-    const max = Math.pow(10, length) - 1;
-    return Math.floor(min + Math.random() * (max - min + 1)).toString();
-  }
-  /**
-   * Encrypt OTP data for secure storage/transmission
-   * @param otp - The OTP string
-   * @param timestamp - The timestamp when OTP was generated (default: now)
-   * @returns - Encrypted OTP data string
-   */
-  encryptOTP(otp, timestamp = Date.now()) {
-    const data = JSON.stringify({ otp, timestamp });
-    return encrypt(data, this.secretKey);
-  }
-  /**
-   * Decrypt OTP data
-   * @param encryptedData - The encrypted OTP string
-   * @returns - Decrypted OTP data object or null if failed
-   */
-  decryptOTP(encryptedData) {
-    try {
-      const decryptedData = decrypt(encryptedData, this.secretKey);
-      return JSON.parse(decryptedData);
-    } catch (error) {
-      console.error("Error decrypting OTP data:", error);
-      return null;
-    }
-  }
-  /**
-   * Verify an OTP against encrypted data
-   * @param inputOtp - The OTP provided by the user
-   * @param encryptedData - The encrypted OTP data
-   * @param expiryMinutes - Expiry time in minutes (default: 5)
-   * @returns - Object containing valid status and message
-   */
-  verifyOTP(inputOtp, encryptedData, expiryMinutes = 5) {
-    const data = this.decryptOTP(encryptedData);
-    if (!data) {
-      return { valid: false, message: "Invalid OTP data" };
-    }
-    const { otp, timestamp } = data;
-    const currentTime = Date.now();
-    const otpAge = currentTime - timestamp;
-    const expiryTime = expiryMinutes * 60 * 1e3;
-    if (otpAge > expiryTime) {
-      return { valid: false, message: "OTP has expired" };
-    }
-    if (otp !== inputOtp) {
-      return { valid: false, message: "Incorrect OTP" };
-    }
-    return { valid: true, message: "OTP verified successfully" };
-  }
-};
-
-// src/server/index.ts
-var IrisMailService = class {
-  constructor(config) {
-    __publicField(this, "email");
-    __publicField(this, "otp");
-    this.email = new EmailService(config.email);
-    this.otp = new OTPService(config.secretKey);
   }
 };
 
 // src/react/components/input-otp.tsx
-var React = __toESM(require("react"));
 var import_input_otp = require("input-otp");
+var React = __toESM(require("react"));
 
 // src/utils/constants.ts
 var import_clsx = require("clsx");
@@ -226,221 +87,121 @@ var import_tailwind_merge = require("tailwind-merge");
 function cn(...inputs) {
   return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
 }
-var OTP_DEFAULTS = {
-  LENGTH: 6,
-  EXPIRY_MINUTES: 5,
-  RESEND_COOLDOWN_SECONDS: 120,
-  // 2 minutes
-  MAX_ATTEMPTS: 5,
-  RATE_LIMIT_RESET_HOURS: 1
-};
 
 // src/react/components/input-otp.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-var Dot = () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-  "svg",
+var InputOTPStyleContext = React.createContext({});
+var InputOTP = React.forwardRef(({ className, containerClassName, error, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InputOTPStyleContext.Provider, { value: { error }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+  import_input_otp.OTPInput,
   {
-    width: "15",
-    height: "15",
-    viewBox: "0 0 15 15",
-    fill: "none",
-    xmlns: "http://www.w3.org/2000/svg",
-    className: "h-4 w-4",
-    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-      "path",
-      {
-        d: "M7.5 7.5C7.5 8.32843 6.82843 9 6 9C5.17157 9 4.5 8.32843 4.5 7.5C4.5 6.67157 5.17157 6 6 6C6.82843 6 7.5 6.67157 7.5 7.5Z",
-        fill: "currentColor",
-        fillRule: "evenodd",
-        clipRule: "evenodd"
-      }
-    )
+    ref,
+    containerClassName: cn(
+      "flex items-center gap-2 has-[:disabled]:opacity-50",
+      containerClassName
+    ),
+    className: cn("disabled:cursor-not-allowed", className),
+    ...props
   }
-);
-var InputOTP = React.forwardRef(
-  ({ className, containerClassName, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    import_input_otp.OTPInput,
-    {
-      ref,
-      containerClassName: cn("flex items-center gap-2 has-[:disabled]:opacity-50", containerClassName),
-      className: cn("disabled:cursor-not-allowed", className),
-      ...props
-    }
-  )
-);
+) }));
 InputOTP.displayName = "InputOTP";
-var InputOTPGroup = React.forwardRef(
-  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref, className: cn("flex items-center", className), ...props })
-);
+var InputOTPGroup = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+  "div",
+  {
+    ref,
+    className: cn("flex items-center gap-2", className),
+    ...props
+  }
+));
 InputOTPGroup.displayName = "InputOTPGroup";
 var InputOTPSlot = React.forwardRef(({ index, className, ...props }, ref) => {
   const inputOTPContext = React.useContext(import_input_otp.OTPInputContext);
-  const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index];
+  const { error } = React.useContext(InputOTPStyleContext);
+  const slot = inputOTPContext.slots[index];
+  const { char, hasFakeCaret, isActive } = slot;
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
     "div",
     {
       ref,
       className: cn(
-        "relative flex h-10 w-10 items-center justify-center border-y border-r border-input text-sm transition-all first:rounded-l-md first:border-l last:rounded-r-md",
-        isActive && "z-10 ring-2 ring-ring ring-offset-background",
+        // Base styles
+        "relative flex h-12 w-10 items-center justify-center",
+        "border-2 rounded-lg",
+        "font-mono text-lg font-medium",
+        "transition-all duration-150",
+        // Default state
+        "border-zinc-700 bg-zinc-900 text-white",
+        // Filled state
+        char && "border-zinc-500",
+        // Active/focus state
+        isActive && "ring-2 ring-offset-2 ring-offset-zinc-950 ring-indigo-500 border-indigo-500",
+        // Error state
+        error && "border-red-500/70 bg-red-500/10",
+        error && isActive && "ring-red-500",
         className
       ),
+      "data-active": isActive,
+      "data-filled": Boolean(char),
       ...props,
       children: [
         char,
-        hasFakeCaret && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "pointer-events-none absolute inset-0 flex items-center justify-center", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "h-4 w-px animate-caret-blink bg-foreground duration-1000" }) })
+        hasFakeCaret && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "pointer-events-none absolute inset-0 flex items-center justify-center", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "h-5 w-0.5 animate-caret-blink rounded-full bg-indigo-400" }) })
       ]
     }
   );
 });
 InputOTPSlot.displayName = "InputOTPSlot";
-var InputOTPSeparator = React.forwardRef(
-  ({ ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref, role: "separator", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Dot, {}) })
-);
+var InputOTPSeparator = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+  "div",
+  {
+    ref,
+    role: "separator",
+    className: cn("flex items-center justify-center text-zinc-500", className),
+    ...props,
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "w-3 h-0.5 bg-zinc-600 rounded-full" })
+  }
+));
 InputOTPSeparator.displayName = "InputOTPSeparator";
-
-// src/react/hooks/use-otp.ts
-var import_react = require("react");
-function useOTP({ email, onRateLimit }) {
-  const [otpTimeLeft, setOtpTimeLeft] = (0, import_react.useState)(OTP_DEFAULTS.EXPIRY_MINUTES * 60);
-  const [resendTimeLeft, setResendTimeLeft] = (0, import_react.useState)(0);
-  const [attemptsLeft, setAttemptsLeft] = (0, import_react.useState)(OTP_DEFAULTS.MAX_ATTEMPTS);
-  const [isRateLimited, setIsRateLimited] = (0, import_react.useState)(false);
-  const [rateLimitResetTime, setRateLimitResetTime] = (0, import_react.useState)(null);
-  const getStorageKey = (prefix) => `${prefix}_${email}`;
-  const getStoredData = (key) => {
-    if (typeof window === "undefined") return null;
-    const data = sessionStorage.getItem(key);
-    return data ? JSON.parse(data) : null;
-  };
-  const setStoredData = (key, data) => {
-    if (typeof window !== "undefined") {
-      sessionStorage.setItem(key, JSON.stringify(data));
-    }
-  };
-  const removeStoredData = (key) => {
-    if (typeof window !== "undefined") {
-      sessionStorage.removeItem(key);
-    }
-  };
-  const checkRateLimit = () => {
-    const key = getStorageKey("rate_limit");
-    const data = getStoredData(key);
-    if (!data) {
-      setAttemptsLeft(OTP_DEFAULTS.MAX_ATTEMPTS);
-      setIsRateLimited(false);
-      return { limited: false, attemptsLeft: OTP_DEFAULTS.MAX_ATTEMPTS };
-    }
-    const currentTime = Date.now();
-    const resetTime = OTP_DEFAULTS.RATE_LIMIT_RESET_HOURS * 60 * 60 * 1e3;
-    if (currentTime - data.firstAttemptTime > resetTime) {
-      removeStoredData(key);
-      setAttemptsLeft(OTP_DEFAULTS.MAX_ATTEMPTS);
-      setIsRateLimited(false);
-      return { limited: false, attemptsLeft: OTP_DEFAULTS.MAX_ATTEMPTS };
-    }
-    const attempts = OTP_DEFAULTS.MAX_ATTEMPTS - data.attempts;
-    const limited = data.attempts >= OTP_DEFAULTS.MAX_ATTEMPTS;
-    const limitResetTime = data.firstAttemptTime + resetTime;
-    setAttemptsLeft(Math.max(0, attempts));
-    setIsRateLimited(limited);
-    setRateLimitResetTime(limited ? limitResetTime : null);
-    if (limited && onRateLimit) {
-      onRateLimit(limitResetTime);
-    }
-    return { limited, attemptsLeft: Math.max(0, attempts), resetTime: limited ? limitResetTime : void 0 };
-  };
-  const updateRateLimit = () => {
-    const key = getStorageKey("rate_limit");
-    const data = getStoredData(key);
-    const currentTime = Date.now();
-    let newData;
-    if (!data) {
-      newData = {
-        attempts: 1,
-        firstAttemptTime: currentTime,
-        lastAttemptTime: currentTime
-      };
-    } else {
-      const resetTime = OTP_DEFAULTS.RATE_LIMIT_RESET_HOURS * 60 * 60 * 1e3;
-      if (currentTime - data.firstAttemptTime > resetTime) {
-        newData = {
-          attempts: 1,
-          firstAttemptTime: currentTime,
-          lastAttemptTime: currentTime
-        };
-      } else {
-        newData = {
-          ...data,
-          attempts: data.attempts + 1,
-          lastAttemptTime: currentTime
-        };
+var OTP = React.forwardRef(
+  ({
+    length = 6,
+    value,
+    onChange,
+    onComplete,
+    disabled,
+    error,
+    autoFocus,
+    name,
+    className,
+    pattern = "^[0-9]*$"
+  }, ref) => {
+    const slotIndices = Array.from({ length }, (_, i) => i);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      InputOTP,
+      {
+        ref,
+        maxLength: length,
+        value,
+        onChange,
+        onComplete,
+        disabled,
+        error,
+        autoFocus,
+        name,
+        pattern,
+        containerClassName: className,
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InputOTPGroup, { children: slotIndices.map((index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InputOTPSlot, { index }, index)) })
       }
-    }
-    setStoredData(key, newData);
-    checkRateLimit();
-    return newData;
-  };
-  const checkResendCooldown = () => {
-    const key = getStorageKey("last_sent");
-    const lastSentTime = getStoredData(key);
-    if (!lastSentTime) {
-      setResendTimeLeft(0);
-      return { canResend: true, timeLeft: 0 };
-    }
-    const currentTime = Date.now();
-    const timeSinceLastSent = currentTime - lastSentTime;
-    const cooldown = OTP_DEFAULTS.RESEND_COOLDOWN_SECONDS * 1e3;
-    const canResend = timeSinceLastSent >= cooldown;
-    const timeLeft = canResend ? 0 : Math.ceil((cooldown - timeSinceLastSent) / 1e3);
-    setResendTimeLeft(timeLeft);
-    return { canResend, timeLeft };
-  };
-  const recordSentOTP = () => {
-    const key = getStorageKey("last_sent");
-    setStoredData(key, Date.now());
-    updateRateLimit();
-    setOtpTimeLeft(OTP_DEFAULTS.EXPIRY_MINUTES * 60);
-    setResendTimeLeft(OTP_DEFAULTS.RESEND_COOLDOWN_SECONDS);
-  };
-  (0, import_react.useEffect)(() => {
-    checkRateLimit();
-    checkResendCooldown();
-    const timer = setInterval(() => {
-      setOtpTimeLeft((prev) => Math.max(0, prev - 1));
-      const { timeLeft } = checkResendCooldown();
-      setResendTimeLeft(timeLeft);
-    }, 1e3);
-    return () => clearInterval(timer);
-  }, [email]);
-  const formatTime = (seconds) => {
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return `${mins}:${secs.toString().padStart(2, "0")}`;
-  };
-  return {
-    otpTimeLeft,
-    resendTimeLeft,
-    attemptsLeft,
-    isRateLimited,
-    rateLimitResetTime,
-    formatTime,
-    recordSentOTP,
-    checkRateLimit
-  };
-}
+    );
+  }
+);
+OTP.displayName = "OTP";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  EmailService,
   InputOTP,
   InputOTPGroup,
   InputOTPSeparator,
   InputOTPSlot,
-  IrisMailService,
-  OTPService,
-  OTP_DEFAULTS,
-  cn,
-  decrypt,
-  encrypt,
-  useOTP
+  IrisMail,
+  OTP,
+  cn
 });

package/dist/index.mjs

@@ -3,29 +3,19 @@ import {
   InputOTPGroup,
   InputOTPSeparator,
   InputOTPSlot,
-  OTP_DEFAULTS,
-  cn,
-  useOTP
-} from "./chunk-FTNSOYOW.mjs";
+  OTP,
+  cn
+} from "./chunk-IQG3OBQL.mjs";
 import {
-  EmailService,
-  IrisMailService,
-  OTPService,
-  decrypt,
-  encrypt
-} from "./chunk-XGASTZZ6.mjs";
+  IrisMail
+} from "./chunk-64MVNASE.mjs";
 import "./chunk-QZ7TP4HQ.mjs";
 export {
-  EmailService,
   InputOTP,
   InputOTPGroup,
   InputOTPSeparator,
   InputOTPSlot,
-  IrisMailService,
-  OTPService,
-  OTP_DEFAULTS,
-  cn,
-  decrypt,
-  encrypt,
-  useOTP
+  IrisMail,
+  OTP,
+  cn
 };