@mohasinac/appkit 2.1.3 → 2.3.0

package/src/utils/number.formatter.ts

@@ -1,107 +0,0 @@
-/**
- * Number Formatting Utilities
- */
-
-export function formatCurrency(
-  amount: number,
-  currency: string = "INR",
-  locale: string = "en-IN",
-): string {
-  return new Intl.NumberFormat(locale, { style: "currency", currency }).format(
-    amount,
-  );
-}
-
-export function formatNumber(
-  num: number,
-  locale: string = "en-IN",
-  options?: { decimals?: number },
-): string {
-  return new Intl.NumberFormat(locale, {
-    minimumFractionDigits: options?.decimals,
-    maximumFractionDigits: options?.decimals,
-  }).format(num);
-}
-
-export function formatPercentage(num: number, decimals: number = 0): string {
-  return `${(num * 100).toFixed(decimals)}%`;
-}
-
-export function formatFileSize(bytes: number): string {
-  if (bytes === 0) return "0 Bytes";
-  const k = 1024;
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-}
-
-export function formatCompactNumber(num: number): string {
-  if (num < 1000) return num.toString();
-  if (num < 1_000_000) return `${(num / 1000).toFixed(1)}K`;
-  if (num < 1_000_000_000) return `${(num / 1_000_000).toFixed(1)}M`;
-  return `${(num / 1_000_000_000).toFixed(1)}B`;
-}
-
-export function formatDecimal(num: number, decimals: number = 2): string {
-  return num.toFixed(decimals);
-}
-
-export function formatOrdinal(num: number): string {
-  const suffixes = ["th", "st", "nd", "rd"];
-  const value = num % 100;
-  return num + (suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0]);
-}
-
-export function parseFormattedNumber(str: string): number {
-  const isNegative = /^-/.test(str) || str.includes("-");
-
-  let cleaned = str.replace(/[^\d,.]/g, "");
-  if (cleaned === "" || cleaned === "0") return 0;
-
-  const lastCommaIndex = cleaned.lastIndexOf(",");
-  const lastDotIndex = cleaned.lastIndexOf(".");
-  const commaCount = (cleaned.match(/,/g) || []).length;
-  const dotCount = (cleaned.match(/\./g) || []).length;
-
-  let decimalSeparator = ".";
-  let thousandsSeparator = ",";
-
-  if (lastCommaIndex > -1 && lastDotIndex > -1) {
-    if (lastCommaIndex > lastDotIndex) {
-      decimalSeparator = ",";
-      thousandsSeparator = ".";
-    }
-  } else if (lastDotIndex > -1 && lastCommaIndex === -1) {
-    const afterDot = cleaned.substring(lastDotIndex + 1);
-    if (dotCount > 1) {
-      cleaned = cleaned.replace(/\./g, "");
-    } else if (afterDot.length > 3) {
-      cleaned = cleaned.replace(/\./g, "");
-    }
-    decimalSeparator = ".";
-    thousandsSeparator = "";
-  } else if (lastCommaIndex > -1 && lastDotIndex === -1) {
-    const afterComma = cleaned.substring(lastCommaIndex + 1);
-    if (commaCount > 1) {
-      cleaned = cleaned.replace(/,/g, "");
-      decimalSeparator = ".";
-      thousandsSeparator = "";
-    } else if (afterComma.length > 3) {
-      cleaned = cleaned.replace(/,/g, "");
-      decimalSeparator = ".";
-      thousandsSeparator = "";
-    } else {
-      decimalSeparator = ",";
-      thousandsSeparator = "";
-    }
-  }
-
-  let result = cleaned;
-  if (thousandsSeparator) {
-    result = result.replace(new RegExp("\\" + thousandsSeparator, "g"), "");
-  }
-  result = result.replace(decimalSeparator, ".");
-
-  const num = parseFloat(result);
-  return isNegative ? -Math.abs(num) : num;
-}

package/src/utils/object.helper.ts

@@ -1,111 +0,0 @@
-/**
- * Object Data Helpers
- *
- * Generic helpers for object data operations — no external dependencies.
- */
-
-export function deepMerge<T extends Record<string, unknown>>(
-  target: T,
-  source: Partial<T>,
-): T {
-  const output = { ...target };
-  Object.keys(source).forEach((key) => {
-    const sourceValue = source[key as keyof T];
-    const targetValue = target[key as keyof T];
-    if (
-      sourceValue &&
-      typeof sourceValue === "object" &&
-      !Array.isArray(sourceValue) &&
-      targetValue &&
-      typeof targetValue === "object" &&
-      !Array.isArray(targetValue)
-    ) {
-      output[key as keyof T] = deepMerge(
-        targetValue as Record<string, unknown>,
-        sourceValue as Partial<Record<string, unknown>>,
-      ) as T[keyof T];
-    } else {
-      output[key as keyof T] = sourceValue as T[keyof T];
-    }
-  });
-  return output;
-}
-
-export function pick<T extends Record<string, unknown>, K extends keyof T>(
-  obj: T,
-  keys: K[],
-): Pick<T, K> {
-  const result = {} as Pick<T, K>;
-  keys.forEach((key) => {
-    if (key in obj) result[key] = obj[key];
-  });
-  return result;
-}
-
-export function omit<T extends Record<string, unknown>, K extends keyof T>(
-  obj: T,
-  keys: K[],
-): Omit<T, K> {
-  const result = { ...obj };
-  keys.forEach((key) => {
-    delete result[key];
-  });
-  return result as Omit<T, K>;
-}
-
-export function isEmptyObject(obj: Record<string, unknown>): boolean {
-  return Object.keys(obj).length === 0;
-}
-
-export function deepClone<T>(obj: T): T {
-  if (obj === null || typeof obj !== "object") return obj;
-  if (Array.isArray(obj))
-    return obj.map((item) => deepClone(item)) as unknown as T;
-  const cloned = {} as T;
-  const objectRecord = obj as Record<string, unknown>;
-  Object.keys(objectRecord).forEach((key) => {
-    cloned[key as keyof T] = deepClone(objectRecord[key]) as T[keyof T];
-  });
-  return cloned;
-}
-
-export function isEqual(obj1: unknown, obj2: unknown): boolean {
-  if (obj1 === obj2) return true;
-  if (
-    typeof obj1 !== "object" ||
-    typeof obj2 !== "object" ||
-    obj1 === null ||
-    obj2 === null
-  ) {
-    return false;
-  }
-  const first = obj1 as Record<string, unknown>;
-  const second = obj2 as Record<string, unknown>;
-  const keys1 = Object.keys(first);
-  const keys2 = Object.keys(second);
-  if (keys1.length !== keys2.length) return false;
-  return keys1.every((key) => isEqual(first[key], second[key]));
-}
-
-export function cleanObject<T extends Record<string, unknown>>(
-  obj: T,
-  options: {
-    removeEmpty?: boolean;
-    removeNull?: boolean;
-    removeUndefined?: boolean;
-  } = {},
-): Partial<T> {
-  const {
-    removeEmpty = true,
-    removeNull = true,
-    removeUndefined = true,
-  } = options;
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    const shouldRemove =
-      (removeUndefined && value === undefined) ||
-      (removeNull && value === null) ||
-      (removeEmpty && value === "");
-    if (!shouldRemove) acc[key as keyof T] = value as T[keyof T];
-    return acc;
-  }, {} as Partial<T>);
-}

package/src/utils/pagination.helper.ts

@@ -1,46 +0,0 @@
-/**
- * Pagination Helper
- *
- * Generic helpers for pagination metadata calculations.
- */
-
-export interface PaginationOptions {
-  page: number;
-  perPage: number;
-  total: number;
-}
-
-export interface PaginationResult {
-  currentPage: number;
-  perPage: number;
-  total: number;
-  totalPages: number;
-  hasNextPage: boolean;
-  hasPrevPage: boolean;
-  nextPage: number | null;
-  prevPage: number | null;
-  startIndex: number;
-  endIndex: number;
-}
-
-export function calculatePagination(
-  options: PaginationOptions,
-): PaginationResult {
-  const { page, perPage, total } = options;
-  const totalPages = Math.ceil(total / perPage);
-  const currentPage = Math.max(1, Math.min(page, totalPages));
-  const startIndex = (currentPage - 1) * perPage;
-  const endIndex = Math.min(startIndex + perPage, total);
-  return {
-    currentPage,
-    perPage,
-    total,
-    totalPages,
-    hasNextPage: currentPage < totalPages,
-    hasPrevPage: currentPage > 1,
-    nextPage: currentPage < totalPages ? currentPage + 1 : null,
-    prevPage: currentPage > 1 ? currentPage - 1 : null,
-    startIndex,
-    endIndex,
-  };
-}

package/src/utils/sorting.helper.ts

@@ -1,21 +0,0 @@
-/**
- * Sorting Helper
- *
- * Generic helpers for sorting operations.
- */
-
-export type SortOrder = "asc" | "desc";
-
-export function sort<T>(
-  array: T[],
-  key: keyof T,
-  order: SortOrder = "asc",
-): T[] {
-  return [...array].sort((a, b) => {
-    const aVal = a[key];
-    const bVal = b[key];
-    if (aVal < bVal) return order === "asc" ? -1 : 1;
-    if (aVal > bVal) return order === "asc" ? 1 : -1;
-    return 0;
-  });
-}

package/src/utils/string.formatter.ts

@@ -1,178 +0,0 @@
-/**
- * String Formatting and Manipulation Utilities
- */
-
-export function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}
-
-export function capitalizeWords(str: string): string {
-  return str
-    .split(" ")
-    .map((word) => capitalize(word))
-    .join(" ");
-}
-
-export function truncate(
-  str: string,
-  maxLength: number,
-  suffix: string = "...",
-): string {
-  if (str.length <= maxLength) return str;
-  return str.slice(0, maxLength - suffix.length) + suffix;
-}
-
-export function truncateWords(
-  str: string,
-  wordCount: number,
-  suffix: string = "...",
-): string {
-  const words = str.split(" ");
-  if (words.length <= wordCount) return str;
-  return words.slice(0, wordCount).join(" ") + suffix;
-}
-
-export function stripHtml(html: string): string {
-  return html.replace(/<[^>]*>/g, "");
-}
-
-/** Escapes HTML special characters to prevent XSS attacks. */
-export function escapeHtml(str: string): string {
-  const map: Record<string, string> = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#x27;",
-    "/": "&#x2F;",
-  };
-  return str.replace(/[&<>"'/]/g, (char) => map[char]);
-}
-
-export function slugify(str: string): string {
-  return str
-    .toLowerCase()
-    .trim()
-    .replace(/[^\w\s-]/g, "")
-    .replace(/[\s_-]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-export function maskString(
-  str: string,
-  visibleStart: number = 4,
-  visibleEnd: number = 4,
-  maskChar: string = "*",
-): string {
-  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: number = 10): string {
-  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: string | null | undefined): boolean {
-  return !str || str.trim().length === 0;
-}
-
-// ─── ProseMirror / TipTap JSON → HTML ────────────────────────────────────────
-
-interface ProseMirrorMark {
-  type: string;
-  attrs?: Record<string, string | number | boolean | null>;
-}
-
-interface ProseMirrorNode {
-  type: string;
-  text?: string;
-  attrs?: Record<string, string | number | boolean | null>;
-  marks?: ProseMirrorMark[];
-  content?: ProseMirrorNode[];
-}
-
-function renderProseMirrorNodes(nodes: ProseMirrorNode[]): string {
-  return nodes.map(renderProseMirrorNode).join("");
-}
-
-function renderProseMirrorNode(node: ProseMirrorNode): string {
-  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 as number) ?? 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: string): string {
-  if (!value) return value;
-  try {
-    const parsed = JSON.parse(value) as ProseMirrorNode;
-    if (parsed?.type === "doc") {
-      return renderProseMirrorNodes(parsed.content ?? []);
-    }
-    return value;
-  } catch {
-    return value;
-  }
-}

package/src/utils/type.converter.ts

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

package/src/validation/email.validator.ts

@@ -1,37 +0,0 @@
-/**
- * Email Validation Utilities
- */
-
-export function isValidEmail(email: string): boolean {
-  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: string,
-  allowedDomains?: string[],
-): boolean {
-  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: string): string {
-  return email.trim().toLowerCase();
-}
-
-export function isDisposableEmail(email: string): boolean {
-  const disposableDomains = [
-    "tempmail.com",
-    "10minutemail.com",
-    "guerrillamail.com",
-    "mailinator.com",
-    "throwaway.email",
-  ];
-  const domain = email.split("@")[1]?.toLowerCase();
-  return disposableDomains.includes(domain);
-}

package/src/validation/index.ts

@@ -1,17 +0,0 @@
-export {
-  paginationQuerySchema,
-  objectIdSchema,
-  urlSchema,
-  mediaUrlSchema,
-  dateStringSchema,
-  passwordSchema,
-  phoneSchema,
-  emailSchema,
-  addressSchema,
-} from "./schemas";
-export { zodErrorMap, setupZodErrorMap } from "./zod-error-map";
-export * from "./email.validator";
-export * from "./password.validator";
-export * from "./phone.validator";
-export * from "./url.validator";
-export * from "./input.validator";

package/src/validation/input.validator.ts

@@ -1,38 +0,0 @@
-/**
- * General Input Validation Utilities
- */
-
-export function isRequired(value: unknown): boolean {
-  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: string, min: number): boolean {
-  return value.length >= min;
-}
-
-export function maxLength(value: string, max: number): boolean {
-  return value.length <= max;
-}
-
-export function exactLength(value: string, length: number): boolean {
-  return value.length === length;
-}
-
-export function isNumeric(value: string): boolean {
-  return !isNaN(Number(value)) && !isNaN(parseFloat(value));
-}
-
-export function inRange(value: number, min: number, max: number): boolean {
-  return value >= min && value <= max;
-}
-
-export function matchesPattern(value: string, pattern: RegExp): boolean {
-  return pattern.test(value);
-}
-
-export function isInList<T>(value: T, list: T[]): boolean {
-  return list.includes(value);
-}