@mohasinac/appkit 2.3.0 → 2.3.2

package/dist/utils/string.formatter.js

@@ -0,0 +1,155 @@
+/**
+ * String Formatting and Manipulation Utilities
+ */
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+export function capitalizeWords(str) {
+    return str
+        .split(" ")
+        .map((word) => capitalize(word))
+        .join(" ");
+}
+export function truncate(str, maxLength, suffix = "...") {
+    if (str.length <= maxLength)
+        return str;
+    return str.slice(0, maxLength - suffix.length) + suffix;
+}
+export function truncateWords(str, wordCount, suffix = "...") {
+    const words = str.split(" ");
+    if (words.length <= wordCount)
+        return str;
+    return words.slice(0, wordCount).join(" ") + suffix;
+}
+export function stripHtml(html) {
+    return html.replace(/<[^>]*>/g, "");
+}
+/** Escapes HTML special characters to prevent XSS attacks. */
+export function escapeHtml(str) {
+    const map = {
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#x27;",
+        "/": "&#x2F;",
+    };
+    return str.replace(/[&<>"'/]/g, (char) => map[char]);
+}
+export function slugify(str) {
+    return str
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export function maskString(str, visibleStart = 4, visibleEnd = 4, maskChar = "*") {
+    if (str.length <= visibleStart + visibleEnd)
+        return str;
+    const start = str.slice(0, visibleStart);
+    const end = str.slice(-visibleEnd);
+    const masked = maskChar.repeat(str.length - visibleStart - visibleEnd);
+    return start + masked + end;
+}
+export function randomString(length = 10) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const indices = new Uint8Array(length);
+    globalThis.crypto.getRandomValues(indices);
+    return Array.from(indices, (i) => chars[i % chars.length]).join("");
+}
+export function isEmptyString(str) {
+    return !str || str.trim().length === 0;
+}
+function renderProseMirrorNodes(nodes) {
+    return nodes.map(renderProseMirrorNode).join("");
+}
+function renderProseMirrorNode(node) {
+    switch (node.type) {
+        case "doc":
+            return renderProseMirrorNodes(node.content ?? []);
+        case "paragraph": {
+            const inner = renderProseMirrorNodes(node.content ?? []);
+            return inner ? `<p>${inner}</p>` : "<p></p>";
+        }
+        case "text": {
+            let text = escapeHtml(node.text ?? "");
+            if (node.marks) {
+                for (const mark of node.marks) {
+                    if (mark.type === "bold")
+                        text = `<strong>${text}</strong>`;
+                    else if (mark.type === "italic")
+                        text = `<em>${text}</em>`;
+                    else if (mark.type === "underline")
+                        text = `<u>${text}</u>`;
+                    else if (mark.type === "strike")
+                        text = `<s>${text}</s>`;
+                    else if (mark.type === "code")
+                        text = `<code>${text}</code>`;
+                    else if (mark.type === "link") {
+                        const rawHref = String(mark.attrs?.href ?? "#").trim();
+                        const safe = /^(https?:\/\/|mailto:|\/|#)/i.test(rawHref)
+                            ? rawHref
+                            : "#";
+                        const href = safe.replace(/[&"<>]/g, (c) => ({ "&": "&amp;", '"': "&quot;", "<": "&lt;", ">": "&gt;" })[c] ?? c);
+                        text = `<a href="${href}" rel="noopener noreferrer">${text}</a>`;
+                    }
+                }
+            }
+            return text;
+        }
+        case "heading": {
+            const level = node.attrs?.level ?? 2;
+            return `<h${level}>${renderProseMirrorNodes(node.content ?? [])}</h${level}>`;
+        }
+        case "bulletList":
+            return `<ul>${renderProseMirrorNodes(node.content ?? [])}</ul>`;
+        case "orderedList":
+            return `<ol>${renderProseMirrorNodes(node.content ?? [])}</ol>`;
+        case "listItem":
+            return `<li>${renderProseMirrorNodes(node.content ?? [])}</li>`;
+        case "blockquote":
+            return `<blockquote>${renderProseMirrorNodes(node.content ?? [])}</blockquote>`;
+        case "codeBlock":
+            return `<pre><code>${renderProseMirrorNodes(node.content ?? [])}</code></pre>`;
+        case "hardBreak":
+            return "<br>";
+        case "horizontalRule":
+            return "<hr>";
+        default:
+            return renderProseMirrorNodes(node.content ?? []);
+    }
+}
+/**
+ * Converts a ProseMirror/TipTap JSON document string to HTML.
+ * Falls back to returning the value unchanged if it is not a ProseMirror doc.
+ */
+export function proseMirrorToHtml(value) {
+    if (!value)
+        return value;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed?.type === "doc") {
+            return renderProseMirrorNodes(parsed.content ?? []);
+        }
+        return value;
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * Normalizes rich-text-like input into safe HTML-ready markup.
+ * Supports ProseMirror JSON strings, existing HTML, and plain text.
+ */
+export function normalizeRichTextHtml(value) {
+    if (!value)
+        return "";
+    const normalized = proseMirrorToHtml(value).trim();
+    if (!normalized)
+        return "";
+    if (/<\/?[a-z][\s\S]*>/i.test(normalized)) {
+        return normalized;
+    }
+    return `<p>${escapeHtml(normalized).replace(/\r?\n/g, "<br />")}</p>`;
+}

package/dist/utils/type.converter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Data Type Converters
+ */
+export declare function stringToBoolean(value: string): boolean;
+export declare function booleanToString(value: boolean, format?: "yesno" | "truefalse" | "onoff"): string;
+export declare function arrayToObject<T>(arr: T[], keyField: keyof T): Record<string, T>;
+export declare function objectToArray<T>(obj: Record<string, T>): T[];
+export declare function queryStringToObject(queryString: string): Record<string, string>;
+export declare function objectToQueryString(obj: Record<string, unknown>): string;
+export declare function firestoreTimestampToDate(timestamp: {
+    toDate?: () => Date;
+    seconds?: number;
+} | unknown): Date;
+export declare function dateToISOString(date: Date | string): string;

package/dist/utils/type.converter.js

@@ -0,0 +1,61 @@
+/**
+ * Data Type Converters
+ */
+export function stringToBoolean(value) {
+    return ["true", "yes", "1", "on"].includes(value.toLowerCase());
+}
+export function booleanToString(value, format = "truefalse") {
+    const formats = {
+        yesno: { true: "Yes", false: "No" },
+        truefalse: { true: "True", false: "False" },
+        onoff: { true: "On", false: "Off" },
+    };
+    return formats[format][value.toString()];
+}
+export function arrayToObject(arr, keyField) {
+    return arr.reduce((acc, item) => {
+        const key = String(item[keyField]);
+        acc[key] = item;
+        return acc;
+    }, {});
+}
+export function objectToArray(obj) {
+    return Object.values(obj);
+}
+export function queryStringToObject(queryString) {
+    const params = new URLSearchParams(queryString);
+    const result = {};
+    params.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}
+export function objectToQueryString(obj) {
+    const params = new URLSearchParams();
+    Object.entries(obj).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+            params.append(key, String(value));
+        }
+    });
+    return params.toString();
+}
+export function firestoreTimestampToDate(timestamp) {
+    if (timestamp &&
+        typeof timestamp === "object" &&
+        "toDate" in timestamp &&
+        typeof timestamp.toDate === "function") {
+        return timestamp.toDate();
+    }
+    if (timestamp &&
+        typeof timestamp === "object" &&
+        "seconds" in timestamp &&
+        typeof timestamp.seconds === "number") {
+        return new Date(timestamp.seconds * 1000);
+    }
+    return new Date(timestamp);
+}
+export function dateToISOString(date) {
+    return typeof date === "string"
+        ? new Date(date).toISOString()
+        : date.toISOString();
+}

package/dist/validation/ZodSetup.d.ts

@@ -0,0 +1,5 @@
+export interface ZodSetupProps {
+    locale?: string;
+}
+export declare function ZodSetup(_props: ZodSetupProps): null;
+export default ZodSetup;

package/dist/validation/ZodSetup.js

@@ -0,0 +1,11 @@
+"use client";
+import { useEffect } from "react";
+import { setupZodErrorMap } from "./zod-error-map";
+export function ZodSetup(_props) {
+    setupZodErrorMap();
+    useEffect(() => {
+        setupZodErrorMap();
+    }, []);
+    return null;
+}
+export default ZodSetup;

package/dist/validation/email.validator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Email Validation Utilities
+ */
+export declare function isValidEmail(email: string): boolean;
+export declare function isValidEmailDomain(email: string, allowedDomains?: string[]): boolean;
+export declare function normalizeEmail(email: string): string;
+export declare function isDisposableEmail(email: string): boolean;

package/dist/validation/email.validator.js

@@ -0,0 +1,33 @@
+/**
+ * Email Validation Utilities
+ */
+export function isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@.][^\s@]*[^\s@.]\.[^\s@]+$|^[^\s@]+@[^\s@.]\.[^\s@]+$/;
+    if (!emailRegex.test(email))
+        return false;
+    if (email.includes(".."))
+        return false;
+    return true;
+}
+export function isValidEmailDomain(email, allowedDomains) {
+    if (!isValidEmail(email))
+        return false;
+    if (!allowedDomains || allowedDomains.length === 0)
+        return true;
+    const domain = email.split("@")[1].toLowerCase();
+    return allowedDomains.some((allowed) => domain === allowed.toLowerCase());
+}
+export function normalizeEmail(email) {
+    return email.trim().toLowerCase();
+}
+export function isDisposableEmail(email) {
+    const disposableDomains = [
+        "tempmail.com",
+        "10minutemail.com",
+        "guerrillamail.com",
+        "mailinator.com",
+        "throwaway.email",
+    ];
+    const domain = email.split("@")[1]?.toLowerCase();
+    return disposableDomains.includes(domain);
+}

package/dist/validation/index.d.ts

@@ -0,0 +1,9 @@
+export { paginationQuerySchema, objectIdSchema, urlSchema, mediaUrlSchema, dateStringSchema, passwordSchema, phoneSchema, emailSchema, addressSchema, resetPasswordSchema, sendVerificationSchema, addPhoneSchema, verifyPhoneSchema, deleteAccountSchema, changePasswordSchema, cropDataSchema, trimDataSchema, validateRequestBody, formatZodErrors, } from "./schemas";
+export { zodErrorMap, setupZodErrorMap } from "./zod-error-map";
+export { ZodSetup } from "./ZodSetup";
+export type { ZodSetupProps } from "./ZodSetup";
+export * from "./email.validator";
+export * from "./password.validator";
+export * from "./phone.validator";
+export * from "./url.validator";
+export * from "./input.validator";

package/dist/validation/index.js

@@ -0,0 +1,8 @@
+export { paginationQuerySchema, objectIdSchema, urlSchema, mediaUrlSchema, dateStringSchema, passwordSchema, phoneSchema, emailSchema, addressSchema, resetPasswordSchema, sendVerificationSchema, addPhoneSchema, verifyPhoneSchema, deleteAccountSchema, changePasswordSchema, cropDataSchema, trimDataSchema, validateRequestBody, formatZodErrors, } from "./schemas";
+export { zodErrorMap, setupZodErrorMap } from "./zod-error-map";
+export { ZodSetup } from "./ZodSetup";
+export * from "./email.validator";
+export * from "./password.validator";
+export * from "./phone.validator";
+export * from "./url.validator";
+export * from "./input.validator";

package/dist/validation/input.validator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * General Input Validation Utilities
+ */
+export declare function isRequired(value: unknown): boolean;
+export declare function minLength(value: string, min: number): boolean;
+export declare function maxLength(value: string, max: number): boolean;
+export declare function exactLength(value: string, length: number): boolean;
+export declare function isNumeric(value: string): boolean;
+export declare function inRange(value: number, min: number, max: number): boolean;
+export declare function matchesPattern(value: string, pattern: RegExp): boolean;
+export declare function isInList<T>(value: T, list: T[]): boolean;

package/dist/validation/input.validator.js

@@ -0,0 +1,33 @@
+/**
+ * General Input Validation Utilities
+ */
+export function isRequired(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
+export function minLength(value, min) {
+    return value.length >= min;
+}
+export function maxLength(value, max) {
+    return value.length <= max;
+}
+export function exactLength(value, length) {
+    return value.length === length;
+}
+export function isNumeric(value) {
+    return !isNaN(Number(value)) && !isNaN(parseFloat(value));
+}
+export function inRange(value, min, max) {
+    return value >= min && value <= max;
+}
+export function matchesPattern(value, pattern) {
+    return pattern.test(value);
+}
+export function isInList(value, list) {
+    return list.includes(value);
+}

package/dist/validation/password.validator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Password Validation Utilities
+ */
+export interface PasswordStrength {
+    score: number;
+    level: "too-weak" | "weak" | "fair" | "good" | "strong";
+    feedback: string[];
+}
+export interface PasswordRequirements {
+    minLength: number;
+    requireUppercase: boolean;
+    requireLowercase: boolean;
+    requireNumbers: boolean;
+    requireSpecialChars: boolean;
+}
+export declare function meetsPasswordRequirements(password: string, requirements?: PasswordRequirements): {
+    valid: boolean;
+    missing: string[];
+};
+export declare function calculatePasswordStrength(password: string): PasswordStrength;
+export declare function isCommonPassword(password: string): boolean;

package/dist/validation/password.validator.js

@@ -0,0 +1,77 @@
+/**
+ * Password Validation Utilities
+ */
+const DEFAULT_REQUIREMENTS = {
+    minLength: 8,
+    requireUppercase: true,
+    requireLowercase: true,
+    requireNumbers: true,
+    requireSpecialChars: true,
+};
+export function meetsPasswordRequirements(password, requirements = DEFAULT_REQUIREMENTS) {
+    const missing = [];
+    if (password.length < requirements.minLength)
+        missing.push(`At least ${requirements.minLength} characters`);
+    if (requirements.requireUppercase && !/[A-Z]/.test(password))
+        missing.push("One uppercase letter");
+    if (requirements.requireLowercase && !/[a-z]/.test(password))
+        missing.push("One lowercase letter");
+    if (requirements.requireNumbers && !/\d/.test(password))
+        missing.push("One number");
+    if (requirements.requireSpecialChars &&
+        !/[!@#$%^&*(),.?":{}|<>]/.test(password))
+        missing.push("One special character");
+    return { valid: missing.length === 0, missing };
+}
+export function calculatePasswordStrength(password) {
+    let score = 0;
+    const feedback = [];
+    if (password.length >= 8)
+        score++;
+    if (password.length >= 12)
+        score++;
+    if (password.length < 8)
+        feedback.push("Password is too short");
+    if (/[a-z]/.test(password) && /[A-Z]/.test(password))
+        score++;
+    if (/\d/.test(password))
+        score++;
+    if (/[!@#$%^&*(),.?":{}|<>]/.test(password))
+        score++;
+    if (/(.)\1{2,}/.test(password)) {
+        score = Math.max(0, score - 1);
+        feedback.push("Avoid repeated characters");
+    }
+    if (/^(?:password|123456|qwerty)/i.test(password)) {
+        score = 0;
+        feedback.push("Avoid common passwords");
+    }
+    score = Math.min(4, Math.max(0, score));
+    const levels = ["too-weak", "weak", "fair", "good", "strong"];
+    return { score, level: levels[score], feedback };
+}
+export function isCommonPassword(password) {
+    const commonPasswords = [
+        "password",
+        "123456",
+        "123456789",
+        "qwerty",
+        "abc123",
+        "monkey",
+        "1234567",
+        "letmein",
+        "trustno1",
+        "dragon",
+        "baseball",
+        "iloveyou",
+        "master",
+        "sunshine",
+        "ashley",
+        "bailey",
+        "passw0rd",
+        "shadow",
+        "123123",
+        "654321",
+    ];
+    return commonPasswords.includes(password.toLowerCase());
+}

package/dist/validation/phone.validator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Phone Number Validation Utilities
+ */
+export declare function isValidPhone(phone: string): boolean;
+export declare function normalizePhone(phone: string): string;
+export declare function formatPhone(phone: string, countryCode?: string): string;
+export declare function extractCountryCode(phone: string): string | null;
+export declare function isValidMobile(phone: string, phonePrefix?: string): boolean;
+export declare function isValidIndianPincode(pincode: string): boolean;

package/dist/validation/phone.validator.js

@@ -0,0 +1,41 @@
+/**
+ * Phone Number Validation Utilities
+ */
+import { getDefaultCountry, getDefaultPhonePrefix, } from "../core/baseline-resolver";
+export function isValidPhone(phone) {
+    const phoneRegex = /^\+?[\d\s-()]+$/;
+    const cleaned = phone.replace(/[\s-()]/g, "");
+    return phoneRegex.test(phone) && cleaned.length >= 10 && cleaned.length <= 15;
+}
+export function normalizePhone(phone) {
+    return phone.replace(/[\s-()]/g, "");
+}
+export function formatPhone(phone, countryCode) {
+    const resolved = countryCode ?? getDefaultCountry();
+    const cleaned = normalizePhone(phone);
+    if (resolved === "US" && cleaned.length === 10) {
+        return `(${cleaned.slice(0, 3)}) ${cleaned.slice(3, 6)}-${cleaned.slice(6)}`;
+    }
+    if (cleaned.startsWith("+"))
+        return cleaned;
+    return `+${cleaned}`;
+}
+export function extractCountryCode(phone) {
+    const cleaned = normalizePhone(phone);
+    if (!cleaned.startsWith("+"))
+        return null;
+    const match = cleaned.match(/^\+(\d{1,3})/);
+    return match ? `+${match[1]}` : null;
+}
+export function isValidMobile(phone, phonePrefix) {
+    const resolved = phonePrefix ?? getDefaultPhonePrefix();
+    const cleaned = normalizePhone(phone).replace(new RegExp(`^\\${resolved}`), "");
+    // For +91 (India), validate 10-digit mobile starting with 6-9
+    if (resolved === "+91")
+        return /^[6-9]\d{9}$/.test(cleaned);
+    // Generic: 10-15 digit number
+    return cleaned.length >= 10 && cleaned.length <= 15;
+}
+export function isValidIndianPincode(pincode) {
+    return /^\d{6}$/.test(pincode.trim());
+}