@umituz/react-native-subscription 2.27.114 → 2.27.116

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

@@ -0,0 +1,64 @@
+/**
+ * String Utilities - Case Conversion
+ * String case transformation functions
+ */
+
+/**
+ * Capitalize first letter of a string
+ */
+export function capitalize(str: string): string {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+/**
+ * Capitalize first letter of each word
+ */
+export function titleCase(str: string): string {
+  if (!str) return "";
+  return str
+    .toLowerCase()
+    .split(" ")
+    .map((word) => capitalize(word))
+    .join(" ");
+}
+
+/**
+ * Convert string to kebab-case
+ */
+export function kebabCase(str: string): string {
+  if (!str) return "";
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase();
+}
+
+/**
+ * Convert string to snake_case
+ */
+export function snakeCase(str: string): string {
+  if (!str) return "";
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/[\s-]+/g, "_")
+    .toLowerCase();
+}
+
+/**
+ * Convert string to camelCase
+ */
+export function camelCase(str: string): string {
+  if (!str) return "";
+  return str
+    .replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ""))
+    .replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+
+/**
+ * Convert string to PascalCase
+ */
+export function pascalCase(str: string): string {
+  if (!str) return "";
+  return capitalize(camelCase(str));
+}

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

@@ -0,0 +1,65 @@
+/**
+ * String Utilities - Check Operations
+ * String validation and comparison functions
+ */
+
+/**
+ * Check if value is a non-empty string
+ */
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+/**
+ * Check if string contains a substring (case insensitive)
+ */
+export function containsIgnoreCase(str: string, search: string): boolean {
+  return str.toLowerCase().includes(search.toLowerCase());
+}
+
+/**
+ * Check if string starts with a prefix (case insensitive)
+ */
+export function startsWithIgnoreCase(str: string, prefix: string): boolean {
+  return str.toLowerCase().startsWith(prefix.toLowerCase());
+}
+
+/**
+ * Check if string ends with a suffix (case insensitive)
+ */
+export function endsWithIgnoreCase(str: string, suffix: string): boolean {
+  return str.toLowerCase().endsWith(suffix.toLowerCase());
+}
+
+/**
+ * Check if a string is a valid email (basic validation)
+ */
+export function isValidEmailString(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 isValidUrlString(value: unknown): value is string {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  try {
+    new URL(value as string);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a string is a valid product identifier
+ */
+export function isValidProductIdString(value: unknown): value is string {
+  return isNonEmptyString(value) && /^[a-zA-Z0-9._-]+$/.test(value as string);
+}

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();
+}