irismail 0.1.0

package/dist/react/index.js

@@ -0,0 +1,261 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  InputOTP: () => InputOTP,
+  InputOTPGroup: () => InputOTPGroup,
+  InputOTPSeparator: () => InputOTPSeparator,
+  InputOTPSlot: () => InputOTPSlot,
+  useOTP: () => useOTP
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/components/input-otp.tsx
+var React = __toESM(require("react"));
+var import_input_otp = require("input-otp");
+
+// src/utils/constants.ts
+var import_clsx = require("clsx");
+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",
+  {
+    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"
+      }
+    )
+  }
+);
+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 })
+);
+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];
+  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",
+        className
+      ),
+      ...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" }) })
+      ]
+    }
+  );
+});
+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, {}) })
+);
+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
+        };
+      }
+    }
+    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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSeparator,
+  InputOTPSlot,
+  useOTP
+});

package/dist/react/index.mjs

@@ -0,0 +1,15 @@
+import {
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSeparator,
+  InputOTPSlot,
+  useOTP
+} from "../chunk-FTNSOYOW.mjs";
+import "../chunk-QZ7TP4HQ.mjs";
+export {
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSeparator,
+  InputOTPSlot,
+  useOTP
+};

package/dist/server/index.d.mts

@@ -0,0 +1,110 @@
+interface EmailConfig {
+    transport: {
+        host: string;
+        port: number;
+        secure?: boolean;
+        auth: {
+            user: string;
+            pass: string;
+        };
+    };
+    defaults?: {
+        from?: {
+            name: string;
+            address: string;
+        };
+    };
+}
+interface SendEmailOptions {
+    to: string;
+    subject: string;
+    html: string;
+    text?: string;
+    from?: {
+        name: string;
+        address: string;
+    };
+}
+declare class EmailService {
+    private transporter;
+    private config;
+    constructor(config: EmailConfig);
+    /**
+     * Verify SMTP connection configuration
+     */
+    verifyConnection(): Promise<boolean>;
+    /**
+     * Send an email
+     * @param options - Email options (to, subject, html, text, from)
+     * @returns - Result of the send operation
+     */
+    sendEmail(options: SendEmailOptions): Promise<{
+        success: boolean;
+        messageId: any;
+    }>;
+}
+
+interface OTPData {
+    otp: string;
+    timestamp: number;
+}
+declare class OTPService {
+    private secretKey;
+    constructor(secretKey: string);
+    /**
+     * Generate a numeric OTP of specified length
+     * @param length - Length of the OTP (default: 6)
+     * @returns - The generated OTP string
+     */
+    generateOTP(length?: number): string;
+    /**
+     * 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: string, timestamp?: number): string;
+    /**
+     * Decrypt OTP data
+     * @param encryptedData - The encrypted OTP string
+     * @returns - Decrypted OTP data object or null if failed
+     */
+    decryptOTP(encryptedData: string): OTPData | 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: string, encryptedData: string, expiryMinutes?: number): {
+        valid: boolean;
+        message: string;
+    };
+}
+
+/**
+ * Encrypts a string using AES-256-CBC
+ * @param text - The text to encrypt
+ * @param secretKey - The 32-character secret key
+ * @returns - The encrypted value with IV and encrypted data, base64 encoded
+ */
+declare function encrypt(text: string, secretKey: string): string;
+/**
+ * Decrypts a string that was encrypted using the encrypt function
+ * @param encryptedText - The encrypted text (IV:EncryptedData format)
+ * @param secretKey - The 32-character secret key
+ * @returns - The decrypted string
+ */
+declare function decrypt(encryptedText: string, secretKey: string): string;
+
+declare class IrisMailService {
+    email: EmailService;
+    otp: OTPService;
+    constructor(config: {
+        email: EmailConfig;
+        secretKey: string;
+    });
+}
+
+export { type EmailConfig, EmailService, IrisMailService, type OTPData, OTPService, type SendEmailOptions, decrypt, encrypt };

package/dist/server/index.d.ts

@@ -0,0 +1,110 @@
+interface EmailConfig {
+    transport: {
+        host: string;
+        port: number;
+        secure?: boolean;
+        auth: {
+            user: string;
+            pass: string;
+        };
+    };
+    defaults?: {
+        from?: {
+            name: string;
+            address: string;
+        };
+    };
+}
+interface SendEmailOptions {
+    to: string;
+    subject: string;
+    html: string;
+    text?: string;
+    from?: {
+        name: string;
+        address: string;
+    };
+}
+declare class EmailService {
+    private transporter;
+    private config;
+    constructor(config: EmailConfig);
+    /**
+     * Verify SMTP connection configuration
+     */
+    verifyConnection(): Promise<boolean>;
+    /**
+     * Send an email
+     * @param options - Email options (to, subject, html, text, from)
+     * @returns - Result of the send operation
+     */
+    sendEmail(options: SendEmailOptions): Promise<{
+        success: boolean;
+        messageId: any;
+    }>;
+}
+
+interface OTPData {
+    otp: string;
+    timestamp: number;
+}
+declare class OTPService {
+    private secretKey;
+    constructor(secretKey: string);
+    /**
+     * Generate a numeric OTP of specified length
+     * @param length - Length of the OTP (default: 6)
+     * @returns - The generated OTP string
+     */
+    generateOTP(length?: number): string;
+    /**
+     * 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: string, timestamp?: number): string;
+    /**
+     * Decrypt OTP data
+     * @param encryptedData - The encrypted OTP string
+     * @returns - Decrypted OTP data object or null if failed
+     */
+    decryptOTP(encryptedData: string): OTPData | 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: string, encryptedData: string, expiryMinutes?: number): {
+        valid: boolean;
+        message: string;
+    };
+}
+
+/**
+ * Encrypts a string using AES-256-CBC
+ * @param text - The text to encrypt
+ * @param secretKey - The 32-character secret key
+ * @returns - The encrypted value with IV and encrypted data, base64 encoded
+ */
+declare function encrypt(text: string, secretKey: string): string;
+/**
+ * Decrypts a string that was encrypted using the encrypt function
+ * @param encryptedText - The encrypted text (IV:EncryptedData format)
+ * @param secretKey - The 32-character secret key
+ * @returns - The decrypted string
+ */
+declare function decrypt(encryptedText: string, secretKey: string): string;
+
+declare class IrisMailService {
+    email: EmailService;
+    otp: OTPService;
+    constructor(config: {
+        email: EmailConfig;
+        secretKey: string;
+    });
+}
+
+export { type EmailConfig, EmailService, IrisMailService, type OTPData, OTPService, type SendEmailOptions, decrypt, encrypt };