@umituz/react-native-subscription 2.27.115 → 2.27.116

package/src/shared/utils/stringUtils.format.ts

@@ -0,0 +1,84 @@
+/**
+ * String Utilities - Formatting
+ * String formatting and display functions
+ */
+
+/**
+ * Truncate string to specified length and add ellipsis
+ */
+export function truncate(str: string, maxLength: number, suffix: string = "..."): string {
+  if (!str || str.length <= maxLength) return str;
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+
+/**
+ * Format bytes as human readable string
+ */
+export function formatBytes(bytes: number, decimals: number = 2): string {
+  if (bytes === 0) return "0 Bytes";
+
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  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(dm)) + " " + sizes[i];
+}
+
+/**
+ * Format a list of items as a comma-separated string with "and" for the last item
+ */
+export function formatList(items: string[], conjunction: string = "and"): string {
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0] ?? "";
+  if (items.length === 2) return items.join(` ${conjunction} `);
+
+  const lastItem = items[items.length - 1];
+  return `${items.slice(0, -1).join(", ")} ${conjunction} ${lastItem ?? ""}`;
+}
+
+/**
+ * Pluralize a word based on count
+ */
+export function pluralize(count: number, singular: string, plural?: string): string {
+  if (count === 1) return singular;
+  return plural || singular + "s";
+}
+
+/**
+ * Format number as ordinal (1st, 2nd, 3rd, etc.)
+ */
+export function formatOrdinal(num: number): string {
+  const suffixes = ["th", "st", "nd", "rd"];
+  const value = num % 100;
+  const suffix = suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0];
+  return `${num}${suffix}`;
+}
+
+/**
+ * Mask sensitive data (e.g., credit card, email)
+ */
+export function maskString(str: string, visibleChars: number = 4, maskChar: string = "*"): string {
+  if (!str) return "";
+  if (str.length <= visibleChars * 2) return maskChar.repeat(str.length);
+
+  const start = str.substring(0, visibleChars);
+  const end = str.substring(str.length - visibleChars);
+  const middleLength = str.length - visibleChars * 2;
+
+  return `${start}${maskChar.repeat(middleLength)}${end}`;
+}
+
+/**
+ * Extract initials from a name
+ */
+export function getInitials(name: string, maxInitials: number = 2): string {
+  if (!name) return "";
+  return name
+    .split(" ")
+    .filter((word) => word.length > 0)
+    .map((word) => word.charAt(0).toUpperCase())
+    .slice(0, maxInitials)
+    .join("");
+}

package/src/shared/utils/stringUtils.generate.ts

@@ -0,0 +1,47 @@
+/**
+ * String Utilities - Generate Functions
+ * String generation and encoding functions
+ */
+
+/**
+ * Generate a random string of specified length
+ */
+export function randomString(
+  length: number,
+  charset: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+): string {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+}
+
+/**
+ * Generate a random ID
+ */
+export function randomId(prefix: string = ""): string {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 9);
+  return prefix ? `${prefix}_${timestamp}${random}` : `${timestamp}${random}`;
+}
+
+/**
+ * Convert a string to base64
+ */
+export function toBase64(str: string): string {
+  if (typeof btoa !== "undefined") {
+    return btoa(str);
+  }
+  return Buffer.from(str).toString("base64");
+}
+
+/**
+ * Decode a base64 string
+ */
+export function fromBase64(base64: string): string {
+  if (typeof atob !== "undefined") {
+    return atob(base64);
+  }
+  return Buffer.from(base64, "base64").toString();
+}

package/src/shared/utils/stringUtils.modify.ts

@@ -0,0 +1,67 @@
+/**
+ * String Utilities - Modify Operations
+ * String manipulation and transformation functions
+ */
+
+/**
+ * Remove all whitespace from string
+ */
+export function removeWhitespace(str: string): string {
+  return str.replace(/\s+/g, "");
+}
+
+/**
+ * Normalize whitespace (replace multiple spaces with single space)
+ */
+export function normalizeWhitespace(str: string): string {
+  return str.trim().replace(/\s+/g, " ");
+}
+
+/**
+ * Count words in a string
+ */
+export function countWords(str: string): number {
+  if (!str.trim()) return 0;
+  return str.trim().split(/\s+/).length;
+}
+
+/**
+ * Count characters in a string (excluding whitespace)
+ */
+export function countChars(str: string, excludeWhitespace: boolean = true): number {
+  return excludeWhitespace ? removeWhitespace(str).length : str.length;
+}
+
+/**
+ * Replace all occurrences of a substring
+ */
+export function replaceAll(str: string, search: string, replacement: string): string {
+  return str.split(search).join(replacement);
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+export function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Strip HTML tags from a string
+ */
+export function stripHtml(html: string): string {
+  return html.replace(/<[^>]*>/g, "");
+}
+
+/**
+ * Sanitize string input (trim and remove extra whitespace)
+ */
+export function sanitizeStringValue(value: unknown): string | null {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value.trim().replace(/\s+/g, " ");
+  }
+  return String(value).trim().replace(/\s+/g, " ");
+}

package/src/shared/utils/stringUtils.ts

@@ -0,0 +1,10 @@
+/**
+ * String Utilities
+ * Re-exports all string utility modules
+ */
+
+export * from "./stringUtils.case";
+export * from "./stringUtils.check";
+export * from "./stringUtils.format";
+export * from "./stringUtils.generate";
+export * from "./stringUtils.modify";

package/src/shared/utils/validators.ts

@@ -0,0 +1,187 @@
+/**
+ * Shared Validation Utilities
+ * Common validation functions and type guards
+ */
+
+/**
+ * Check if value is a non-empty string
+ */
+export function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+/**
+ * Check if value is a valid number (not NaN or Infinity)
+ */
+export function isValidNumber(value: unknown): value is number {
+  return typeof value === "number" && !isNaN(value) && isFinite(value);
+}
+
+/**
+ * Check if value is a positive number
+ */
+export function isPositiveNumber(value: unknown): value is number {
+  return isValidNumber(value) && value > 0;
+}
+
+/**
+ * Check if value is a non-negative number
+ */
+export function isNonNegativeNumber(value: unknown): value is number {
+  return isValidNumber(value) && value >= 0;
+}
+
+/**
+ * Check if value is a valid integer
+ */
+export function isInteger(value: unknown): value is number {
+  return isValidNumber(value) && Number.isInteger(value);
+}
+
+/**
+ * Check if value is a valid date
+ */
+export function isValidDate(value: unknown): boolean {
+  if (value instanceof Date) {
+    return !isNaN(value.getTime());
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const d = new Date(value);
+    return !isNaN(d.getTime());
+  }
+  return false;
+}
+
+/**
+ * Check if value is a valid email (basic validation)
+ */
+export function isValidEmail(value: unknown): value is string {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value);
+}
+
+/**
+ * Check if value is a valid URL (basic validation)
+ */
+export function isValidUrl(value: unknown): value is string {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if value is within a numeric range (type guard version)
+ */
+export function isValueInRange(
+  value: unknown,
+  min: number,
+  max: number,
+  inclusive: boolean = true
+): value is number {
+  if (!isValidNumber(value)) {
+    return false;
+  }
+  if (inclusive) {
+    return value >= min && value <= max;
+  }
+  return value > min && value < max;
+}
+
+/**
+ * Check if array has at least one element
+ */
+export function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]] {
+  return Array.isArray(value) && value.length > 0;
+}
+
+/**
+ * Check if value is a plain object (not null, not array)
+ */
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Check if value is defined (not null or undefined)
+ */
+export function isDefined<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined;
+}
+
+/**
+ * Validate that a number is within credit limits
+ */
+export function isValidCreditAmount(value: unknown): value is number {
+  return isInteger(value) && isNonNegativeNumber(value);
+}
+
+/**
+ * Validate that a price is valid (positive number with max 2 decimal places)
+ */
+export function isValidPrice(value: unknown): value is number {
+  if (!isPositiveNumber(value)) {
+    return false;
+  }
+  // Check for max 2 decimal places
+  const decimalPlaces = (value.toString().split(".")[1] || "").length;
+  return decimalPlaces <= 2;
+}
+
+/**
+ * Check if a string is a valid product identifier
+ */
+export function isValidProductId(value: unknown): value is string {
+  return isNonEmptyString(value) && /^[a-zA-Z0-9._-]+$/.test(value);
+}
+
+/**
+ * Check if value is a valid user ID
+ */
+export function isValidUserId(value: unknown): value is string {
+  return isNonEmptyString(value) && value.length > 0;
+}
+
+/**
+ * Sanitize string input (trim and remove extra whitespace)
+ */
+export function sanitizeString(value: unknown): string | null {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value.trim().replace(/\s+/g, " ");
+  }
+  return String(value).trim().replace(/\s+/g, " ");
+}
+
+/**
+ * Validate and sanitize a number input
+ */
+export function sanitizeNumber(
+  value: unknown,
+  defaultValue: number = 0
+): number {
+  if (isValidNumber(value)) {
+    return value;
+  }
+  return defaultValue;
+}
+
+/**
+ * Check if a value is within an allowed set of values
+ */
+export function isOneOf<T>(
+  value: unknown,
+  allowedValues: readonly T[]
+): value is T {
+  return allowedValues.includes(value as T);
+}

package/src/utils/dateUtils.compare.ts

@@ -0,0 +1,65 @@
+/**
+ * Date Utilities - Comparison Operations
+ * Date comparison and calculation functions
+ */
+
+import { isValidDate, isPast, currentDate } from "./dateUtils.core";
+import { addDays } from "./dateUtils.math";
+
+/**
+ * Calculate difference in days between two dates
+ */
+export function daysBetween(date1: Date | string | number, date2: Date | string | number): number {
+  const d1 = new Date(date1);
+  const d2 = new Date(date2);
+  const diffTime = d2.getTime() - d1.getTime();
+  return Math.floor(diffTime / (1000 * 60 * 60 * 24));
+}
+
+/**
+ * Calculate days remaining until a date
+ * Returns null if date is in the past or invalid
+ */
+export function daysUntil(date: Date | string | number): number | null {
+  const target = new Date(date);
+  if (!isValidDate(target) || isPast(target)) {
+    return null;
+  }
+  return daysBetween(currentDate(), target);
+}
+
+/**
+ * Check if two dates are the same day
+ */
+export function isSameDay(date1: Date | string | number, date2: Date | string | number): boolean {
+  const d1 = new Date(date1);
+  const d2 = new Date(date2);
+  return (
+    d1.getFullYear() === d2.getFullYear() &&
+    d1.getMonth() === d2.getMonth() &&
+    d1.getDate() === d2.getDate()
+  );
+}
+
+/**
+ * Check if a date is today
+ */
+export function isToday(date: Date | string | number): boolean {
+  return isSameDay(date, currentDate());
+}
+
+/**
+ * Check if a date is yesterday
+ */
+export function isYesterday(date: Date | string | number): boolean {
+  const yesterday = addDays(currentDate(), -1);
+  return isSameDay(date, yesterday);
+}
+
+/**
+ * Check if a date is tomorrow
+ */
+export function isTomorrow(date: Date | string | number): boolean {
+  const tomorrow = addDays(currentDate(), 1);
+  return isSameDay(date, tomorrow);
+}

package/src/utils/dateUtils.core.ts

@@ -0,0 +1,67 @@
+/**
+ * Date Utilities - Core Operations
+ * Basic date manipulation and validation functions
+ */
+
+export type DateLike = Date | string | number;
+
+/**
+ * Checks if a date is in the past
+ */
+export function isPast(date: DateLike): boolean {
+  const d = new Date(date);
+  return d.getTime() < Date.now();
+}
+
+/**
+ * Checks if a date is in the future
+ */
+export function isFuture(date: DateLike): boolean {
+  const d = new Date(date);
+  return d.getTime() > Date.now();
+}
+
+/**
+ * Checks if a date is valid
+ */
+export function isValidDate(date: DateLike): boolean {
+  const d = date instanceof Date ? date : new Date(date);
+  return !isNaN(d.getTime());
+}
+
+/**
+ * Converts various timestamp formats to a safe Date object
+ */
+export function toSafeDate(ts: unknown): Date | null {
+  if (!ts) return null;
+  if (typeof ts === "object" && ts !== null && "toDate" in ts && typeof ts.toDate === "function") {
+    return (ts as { toDate: () => Date }).toDate();
+  }
+  if (ts instanceof Date) return ts;
+  if (typeof ts === "string" || typeof ts === "number") {
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+
+/**
+ * Formats a date to ISO string safely
+ */
+export function formatISO(date: Date | null): string | null {
+  return date ? date.toISOString() : null;
+}
+
+/**
+ * Get current timestamp in milliseconds
+ */
+export function now(): number {
+  return Date.now();
+}
+
+/**
+ * Get current date
+ */
+export function currentDate(): Date {
+  return new Date();
+}

package/src/utils/dateUtils.format.ts

@@ -0,0 +1,138 @@
+/**
+ * Date Utilities - Formatting
+ * Date display and formatting functions
+ */
+
+import type { DateLike } from "./dateUtils.core";
+
+/**
+ * Format date to locale string
+ */
+export function formatLocale(
+  date: DateLike,
+  options?: Intl.DateTimeFormatOptions,
+  locale: string = "en-US"
+): string {
+  const d = new Date(date);
+  if (isNaN(d.getTime())) {
+    return "";
+  }
+  return d.toLocaleDateString(locale, options);
+}
+
+/**
+ * Format date to relative time (e.g., "2 days ago", "in 3 hours")
+ */
+export function formatRelative(date: DateLike, now: Date = new Date()): string {
+  const target = new Date(date);
+  if (isNaN(target.getTime())) {
+    return "";
+  }
+
+  const diffMs = target.getTime() - now.getTime();
+  const diffSecs = Math.floor(diffMs / 1000);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+
+  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+
+  if (Math.abs(diffDays) > 0) {
+    return rtf.format(diffDays, "day");
+  }
+  if (Math.abs(diffHours) > 0) {
+    return rtf.format(diffHours, "hour");
+  }
+  if (Math.abs(diffMins) > 0) {
+    return rtf.format(diffMins, "minute");
+  }
+  return rtf.format(diffSecs, "second");
+}
+
+/**
+ * Format date to short date string (e.g., "1/1/2024")
+ */
+export function formatShort(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { month: "numeric", day: "numeric", year: "numeric" }, locale);
+}
+
+/**
+ * Format date to medium date string (e.g., "Jan 1, 2024")
+ */
+export function formatMedium(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { month: "short", day: "numeric", year: "numeric" }, locale);
+}
+
+/**
+ * Format date to long date string (e.g., "January 1, 2024")
+ */
+export function formatLong(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { month: "long", day: "numeric", year: "numeric" }, locale);
+}
+
+/**
+ * Format date to time string
+ */
+export function formatTime(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { hour: "numeric", minute: "numeric" }, locale);
+}
+
+/**
+ * Format date to date and time string
+ */
+export function formatDateTime(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(
+    date,
+    { month: "short", day: "numeric", year: "numeric", hour: "numeric", minute: "numeric" },
+    locale
+  );
+}
+
+/**
+ * Convert milliseconds to human-readable duration
+ */
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) {
+    return `${days}d ${hours % 24}h`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+
+/**
+ * Format date to weekday name (e.g., "Monday")
+ */
+export function formatWeekday(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { weekday: "long" }, locale);
+}
+
+/**
+ * Format date to short weekday name (e.g., "Mon")
+ */
+export function formatWeekdayShort(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { weekday: "short" }, locale);
+}
+
+/**
+ * Format date to month name (e.g., "January")
+ */
+export function formatMonth(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { month: "long" }, locale);
+}
+
+/**
+ * Format date to short month name (e.g., "Jan")
+ */
+export function formatMonthShort(date: DateLike, locale: string = "en-US"): string {
+  return formatLocale(date, { month: "short" }, locale);
+}