irismail 0.1.0 → 0.5.0

package/dist/chunk-FTNSOYOW.mjs

@@ -1,223 +0,0 @@
-// src/react/components/input-otp.tsx
-import * as React from "react";
-import { OTPInput, OTPInputContext } from "input-otp";
-
-// src/utils/constants.ts
-import { clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
-function cn(...inputs) {
-  return twMerge(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
-import { jsx, jsxs } from "react/jsx-runtime";
-var Dot = () => /* @__PURE__ */ jsx(
-  "svg",
-  {
-    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__ */ 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"
-      }
-    )
-  }
-);
-var InputOTP = React.forwardRef(
-  ({ className, containerClassName, ...props }, ref) => /* @__PURE__ */ jsx(
-    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__ */ jsx("div", { ref, className: cn("flex items-center", className), ...props })
-);
-InputOTPGroup.displayName = "InputOTPGroup";
-var InputOTPSlot = React.forwardRef(({ index, className, ...props }, ref) => {
-  const inputOTPContext = React.useContext(OTPInputContext);
-  const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index];
-  return /* @__PURE__ */ 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",
-        className
-      ),
-      ...props,
-      children: [
-        char,
-        hasFakeCaret && /* @__PURE__ */ jsx("div", { className: "pointer-events-none absolute inset-0 flex items-center justify-center", children: /* @__PURE__ */ jsx("div", { className: "h-4 w-px animate-caret-blink bg-foreground duration-1000" }) })
-      ]
-    }
-  );
-});
-InputOTPSlot.displayName = "InputOTPSlot";
-var InputOTPSeparator = React.forwardRef(
-  ({ ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, role: "separator", ...props, children: /* @__PURE__ */ jsx(Dot, {}) })
-);
-InputOTPSeparator.displayName = "InputOTPSeparator";
-
-// src/react/hooks/use-otp.ts
-import { useState, useEffect } from "react";
-function useOTP({ email, onRateLimit }) {
-  const [otpTimeLeft, setOtpTimeLeft] = useState(OTP_DEFAULTS.EXPIRY_MINUTES * 60);
-  const [resendTimeLeft, setResendTimeLeft] = useState(0);
-  const [attemptsLeft, setAttemptsLeft] = useState(OTP_DEFAULTS.MAX_ATTEMPTS);
-  const [isRateLimited, setIsRateLimited] = useState(false);
-  const [rateLimitResetTime, setRateLimitResetTime] = 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
-        };
-      }
-    }
-    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);
-  };
-  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
-  };
-}
-
-export {
-  cn,
-  OTP_DEFAULTS,
-  InputOTP,
-  InputOTPGroup,
-  InputOTPSlot,
-  InputOTPSeparator,
-  useOTP
-};

package/dist/chunk-XGASTZZ6.mjs

@@ -1,180 +0,0 @@
-import {
-  __publicField
-} from "./chunk-QZ7TP4HQ.mjs";
-
-// src/server/email.ts
-import nodemailer from "nodemailer";
-var EmailService = class {
-  constructor(config) {
-    __publicField(this, "transporter");
-    __publicField(this, "config");
-    this.config = config;
-    this.transporter = nodemailer.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;
-    }
-  }
-  /**
-   * Send an email
-   * @param options - Email options (to, subject, html, text, from)
-   * @returns - Result of the send operation
-   */
-  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
-    };
-    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
-import crypto from "crypto";
-var ALGORITHM = "aes-256-cbc";
-function encrypt(text, secretKey) {
-  try {
-    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.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 = crypto.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);
-  }
-};
-
-export {
-  EmailService,
-  encrypt,
-  decrypt,
-  OTPService,
-  IrisMailService
-};