rn-custom-ui 1.0.0

package/src/components/loading/index.tsx

@@ -0,0 +1,34 @@
+import { ActivityIndicator, StyleSheet, View } from 'react-native';
+
+interface Props {
+  small?: boolean;
+  color?: string;
+}
+
+const Loader = ({ small = false, color = 'white' }: Props) => {
+  return (
+    <View style={styles.container}>
+      {small ? (
+        <ActivityIndicator color={color} size={'small'} />
+      ) : (
+        <ActivityIndicator color={color} size={'large'} />
+      )}
+    </View>
+  );
+};
+
+export default Loader;
+
+const styles = StyleSheet.create({
+  container: {
+    position: 'absolute',
+    top: 0,
+    bottom: 0,
+    right: 0,
+    left: 0,
+    backgroundColor: '#00000061',
+    justifyContent: 'center',
+    alignItems: 'center',
+    zIndex: 1,
+  },
+});

package/src/customFunctions/array.ts

@@ -0,0 +1,83 @@
+export const groupBy = <T, K extends string | number>(
+  items: T[],
+  getKey: (item: T) => K
+): Record<K, T[]> => {
+  return items.reduce(
+    (acc, item) => {
+      const key = getKey(item);
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {} as Record<K, T[]>
+  );
+};
+
+export const chunk = <T>(items: T[], size: number): T[][] => {
+  if (size <= 0) {
+    return [];
+  }
+
+  const chunks: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+
+  return chunks;
+};
+
+export const sortBy = <T>(
+  items: T[],
+  selector: (item: T) => string | number,
+  direction: 'asc' | 'desc' = 'asc'
+): T[] => {
+  const multiplier = direction === 'asc' ? 1 : -1;
+
+  return [...items].sort((left, right) => {
+    const leftValue = selector(left);
+    const rightValue = selector(right);
+
+    if (leftValue < rightValue) {
+      return -1 * multiplier;
+    }
+
+    if (leftValue > rightValue) {
+      return 1 * multiplier;
+    }
+
+    return 0;
+  });
+};
+
+export const uniqueBy = <T, K>(items: T[], selector: (item: T) => K): T[] => {
+  const seen = new Set<K>();
+  const result: T[] = [];
+
+  for (const item of items) {
+    const key = selector(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+
+  return result;
+};
+
+export const flatten = <T>(items: Array<T | T[]>): T[] => items.flat() as T[];
+
+export const shuffle = <T>(items: T[]): T[] => {
+  const copy = [...items];
+
+  for (let index = copy.length - 1; index > 0; index -= 1) {
+    const randomIndex = Math.floor(Math.random() * (index + 1));
+    const current = copy[index] as T;
+    const swap = copy[randomIndex] as T;
+    copy[index] = swap;
+    copy[randomIndex] = current;
+  }
+
+  return copy;
+};

package/src/customFunctions/async.ts

@@ -0,0 +1,85 @@
+export const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+export const debounce = <T extends (...args: never[]) => void>(
+  fn: T,
+  delayMs: number
+) => {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  const debounced = (...args: Parameters<T>) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    timeoutId = setTimeout(() => {
+      fn(...args);
+    }, delayMs);
+  };
+
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+    }
+  };
+
+  return debounced;
+};
+
+export const throttle = <T extends (...args: never[]) => void>(
+  fn: T,
+  intervalMs: number
+) => {
+  let lastCall = 0;
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  return (...args: Parameters<T>) => {
+    const now = Date.now();
+    const remaining = intervalMs - (now - lastCall);
+
+    if (remaining <= 0) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+      }
+
+      lastCall = now;
+      fn(...args);
+      return;
+    }
+
+    if (!timeoutId) {
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        timeoutId = undefined;
+        fn(...args);
+      }, remaining);
+    }
+  };
+};
+
+export const tryParseJson = <T = unknown>(
+  value: string,
+  fallback: T | null = null
+): T | null => {
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return fallback;
+  }
+};
+
+export const safeStringify = (
+  value: unknown,
+  space = 2,
+  fallback = ''
+): string => {
+  try {
+    return JSON.stringify(value, null, space);
+  } catch {
+    return fallback;
+  }
+};

package/src/customFunctions/date.ts

@@ -0,0 +1,158 @@
+import type { LocalizedDateTimeOptions } from './types';
+
+export const formatDateYYYYMMDD = (date: Date = new Date()): string => {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+
+  return `${year}-${month}-${day}`;
+};
+
+export const getIsoTimeWithoutMilliseconds = (
+  date: Date = new Date()
+): string => `${date.toISOString().split('.')[0]}Z`;
+
+export const isOlderThanHours = (
+  timestamp: string | number,
+  hours = 24
+): boolean => {
+  const diffMs = Math.abs(Date.now() - Number(timestamp));
+  const diffHours = diffMs / (1000 * 60 * 60);
+
+  return diffHours >= hours;
+};
+
+export const formatTimestampTo12Hour = (
+  timestampMs: string | number
+): string => {
+  const date = new Date(Number(timestampMs));
+  let hours = date.getHours();
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+  const meridiem = hours >= 12 ? 'pm' : 'am';
+
+  hours %= 12;
+  if (hours === 0) {
+    hours = 12;
+  }
+
+  return `${hours}:${minutes}:${seconds} ${meridiem}`;
+};
+
+export const formatDateTimeLocalized = (
+  date: Date = new Date(),
+  options: LocalizedDateTimeOptions = {}
+) => {
+  const englishLocale = options.englishLocale ?? 'en-GB';
+  const frenchLocale = options.frenchLocale ?? 'fr-FR';
+
+  const englishDate = new Intl.DateTimeFormat(englishLocale, {
+    day: 'numeric',
+    month: 'short',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+  }).format(date);
+
+  const frenchDate = new Intl.DateTimeFormat(frenchLocale, {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: false,
+  }).format(date);
+
+  return { englishDate, frenchDate };
+};
+
+export const parseCompactDateTime = (dateString: string): string => {
+  const year = dateString.slice(0, 4);
+  const month = dateString.slice(4, 6);
+  const day = dateString.slice(6, 8);
+  const hour = dateString.slice(8, 10);
+  const minute = dateString.slice(10, 12);
+  const second = dateString.slice(12, 14);
+
+  return `${year}-${month}-${day}T${hour}:${minute}:${second}`;
+};
+
+export const generateCompactTimestampId = (hoursOffset = 0): string => {
+  const date = new Date();
+
+  if (hoursOffset !== 0) {
+    date.setHours(date.getHours() + hoursOffset);
+  }
+
+  return date.toISOString().replace(/[-:]/g, '').replace('T', '').slice(0, 15);
+};
+
+export const addDays = (date: Date, days: number): Date => {
+  const next = new Date(date);
+  next.setDate(next.getDate() + days);
+  return next;
+};
+
+export const differenceInDays = (from: Date, to: Date): number => {
+  const msPerDay = 1000 * 60 * 60 * 24;
+  const start = new Date(from.getFullYear(), from.getMonth(), from.getDate());
+  const end = new Date(to.getFullYear(), to.getMonth(), to.getDate());
+
+  return Math.round((end.getTime() - start.getTime()) / msPerDay);
+};
+
+export const differenceInMinutes = (
+  from: Date | number,
+  to: Date | number
+): number => {
+  const start = new Date(from).getTime();
+  const end = new Date(to).getTime();
+
+  return Math.round((end - start) / (1000 * 60));
+};
+
+export const isSameDay = (
+  left: Date | number,
+  right: Date | number
+): boolean => {
+  const a = new Date(left);
+  const b = new Date(right);
+
+  return (
+    a.getFullYear() === b.getFullYear() &&
+    a.getMonth() === b.getMonth() &&
+    a.getDate() === b.getDate()
+  );
+};
+
+export const isToday = (date: Date | number): boolean =>
+  isSameDay(date, new Date());
+
+export const formatRelativeTime = (
+  date: Date | number,
+  now: Date | number = Date.now()
+): string => {
+  const diffMinutes = differenceInMinutes(date, now);
+  const absMinutes = Math.abs(diffMinutes);
+  const isPast = diffMinutes > 0;
+
+  if (absMinutes < 1) {
+    return 'just now';
+  }
+
+  if (absMinutes < 60) {
+    const label = `${absMinutes} min`;
+    return isPast ? `${label} ago` : `in ${label}`;
+  }
+
+  const absHours = Math.round(absMinutes / 60);
+  if (absHours < 24) {
+    const label = `${absHours} hour${absHours === 1 ? '' : 's'}`;
+    return isPast ? `${label} ago` : `in ${label}`;
+  }
+
+  const absDays = Math.round(absHours / 24);
+  const label = `${absDays} day${absDays === 1 ? '' : 's'}`;
+  return isPast ? `${label} ago` : `in ${label}`;
+};

package/src/customFunctions/general.ts

@@ -0,0 +1,35 @@
+import type { LoggerPayload } from './types';
+
+export const logger = ({ msg = '', data }: LoggerPayload) => {
+  console.log(`------------------------${msg}------------------------`);
+  console.log(data);
+  console.log('------------------------------------------------------');
+};
+
+export const isNullish = (value: unknown): value is null | undefined =>
+  value === null || value === undefined;
+
+export const isEmpty = (value: unknown): boolean => {
+  if (isNullish(value)) {
+    return true;
+  }
+
+  if (typeof value === 'string') {
+    return value.trim().length === 0;
+  }
+
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (typeof value === 'object') {
+    return Object.keys(value).length === 0;
+  }
+
+  return false;
+};
+
+export const isDefined = <T>(value: T | null | undefined): value is T =>
+  value !== null && value !== undefined;
+
+export const noop = () => {};

package/src/customFunctions/id.ts

@@ -0,0 +1,25 @@
+const ALPHANUMERIC_CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789';
+
+export const generateRandomAlphanumeric = (length = 10): string => {
+  let id = '';
+
+  for (let i = 0; i < length; i += 1) {
+    id += ALPHANUMERIC_CHARS.charAt(
+      Math.floor(Math.random() * ALPHANUMERIC_CHARS.length)
+    );
+  }
+
+  return id;
+};
+
+export const generateSessionId = (randomLength = 29): string => {
+  const prefix = Date.now();
+  return `${prefix}_${generateRandomAlphanumeric(randomLength)}`;
+};
+
+export const generateUuid = (): string =>
+  'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+    const random = Math.floor(Math.random() * 16);
+    const value = char === 'x' ? random : (random & 0x3) | 0x8;
+    return value.toString(16);
+  });

package/src/customFunctions/index.ts

@@ -0,0 +1,91 @@
+export { chunk, flatten, groupBy, shuffle, sortBy, uniqueBy } from './array';
+export {
+  debounce,
+  safeStringify,
+  sleep,
+  throttle,
+  tryParseJson,
+} from './async';
+export {
+  addDays,
+  differenceInDays,
+  differenceInMinutes,
+  formatDateYYYYMMDD,
+  formatDateTimeLocalized,
+  formatRelativeTime,
+  formatTimestampTo12Hour,
+  generateCompactTimestampId,
+  getIsoTimeWithoutMilliseconds,
+  isOlderThanHours,
+  isSameDay,
+  isToday,
+  parseCompactDateTime,
+} from './date';
+export { isDefined, isEmpty, isNullish, logger, noop } from './general';
+export {
+  generateRandomAlphanumeric,
+  generateSessionId,
+  generateUuid,
+} from './id';
+export {
+  average,
+  clamp,
+  formatBytes,
+  formatCurrency,
+  formatDiscountAmount,
+  formatNumberWithCommas,
+  formatPercentage,
+  generateRandomNumberString,
+  parseNumberSafe,
+  percentage,
+  randomInt,
+  roundToDecimals,
+  sum,
+} from './number';
+export { deepClone, getNestedValue, isPlainObject, omit, pick } from './object';
+export {
+  camelToTitle,
+  capitalizeFirst,
+  capitalizeWords,
+  findItemByProperty,
+  getLocalizedSplitText,
+  initialsFromName,
+  maskString,
+  normalizeWhitespace,
+  removeDuplicateStrings,
+  removeDuplicates,
+  slugify,
+  truncate,
+} from './string';
+export type {
+  CurrencyLocale,
+  FormatCurrencyOptions,
+  FormatNumberOptions,
+  LocalizedDateTimeOptions,
+  LoggerPayload,
+} from './types';
+export {
+  encodePlusInEmail,
+  isNumeric,
+  isStrongPassword,
+  isValidEmail,
+  isValidPhone,
+  isValidUrl,
+} from './validation';
+
+// Backward-friendly aliases mapped from the original app helpers
+export { isOlderThanHours as isUpdateAppSession } from './date';
+export { capitalizeFirst as getFirstCap } from './string';
+export { formatCurrency as getFrAmount } from './number';
+export { formatDateYYYYMMDD as getFormattedDate } from './date';
+export { getIsoTimeWithoutMilliseconds as getCurrentTime } from './date';
+export { generateCompactTimestampId as getUniqueId } from './date';
+export { formatTimestampTo12Hour as getLastScannedTime } from './date';
+export { formatDateTimeLocalized as getPrintDate } from './date';
+export { parseCompactDateTime as formatToEST } from './date';
+export { generateRandomAlphanumeric as paymentServiceId } from './id';
+export { generateSessionId as generateAppSessionId } from './id';
+export { generateSessionId as generateUserSessionId } from './id';
+export { generateUuid as generateCartSessionId } from './id';
+export { findItemByProperty as getCurrentScreen } from './string';
+export { getLocalizedSplitText as getTextByLanguage } from './string';

package/src/customFunctions/number.ts

@@ -0,0 +1,139 @@
+import type { FormatCurrencyOptions, FormatNumberOptions } from './types';
+
+const toSafeNumber = (value: number | string | null | undefined): number => {
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+};
+
+export const parseNumberSafe = toSafeNumber;
+
+export const formatNumberWithCommas = (
+  value: number | string | null | undefined,
+  options: FormatNumberOptions = {}
+): string => {
+  const {
+    locale = 'en-US',
+    minimumFractionDigits = 0,
+    maximumFractionDigits = 2,
+  } = options;
+
+  return toSafeNumber(value).toLocaleString(locale, {
+    minimumFractionDigits,
+    maximumFractionDigits,
+  });
+};
+
+export const formatCurrency = (
+  amount: number | string | null | undefined,
+  options: FormatCurrencyOptions = {}
+): string => {
+  const {
+    locale = 'en-US',
+    currency = 'USD',
+    isDiscount = false,
+    minimumFractionDigits = 2,
+    maximumFractionDigits = 2,
+  } = options;
+
+  const safeAmount = toSafeNumber(amount);
+
+  if (locale.startsWith('fr')) {
+    const formatted = `${safeAmount
+      .toFixed(maximumFractionDigits)
+      .replace('.', ',')} $`;
+    return isDiscount ? `-${formatted}` : formatted;
+  }
+
+  const formatted = new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency,
+    minimumFractionDigits,
+    maximumFractionDigits,
+  }).format(safeAmount);
+
+  return isDiscount ? `-${formatted}` : formatted;
+};
+
+export const formatDiscountAmount = (
+  discount: number | string | undefined,
+  options: FormatCurrencyOptions = {}
+): string | number => {
+  if (discount === undefined || discount === null || discount === '') {
+    return 0;
+  }
+
+  const raw = discount.toString().replace('-', '');
+  return formatCurrency(raw, { ...options, isDiscount: true });
+};
+
+export const generateRandomNumberString = (length: number): string => {
+  let result = '';
+  const digits = '0123456789';
+
+  for (let i = 0; i < length; i += 1) {
+    result += digits.charAt(Math.floor(Math.random() * digits.length));
+  }
+
+  return result;
+};
+
+export const roundToDecimals = (
+  value: number | string,
+  decimals = 2
+): number => {
+  const factor = 10 ** decimals;
+  return Math.round(toSafeNumber(value) * factor) / factor;
+};
+
+export const clamp = (value: number, min: number, max: number): number =>
+  Math.min(Math.max(value, min), max);
+
+export const formatPercentage = (
+  value: number | string,
+  decimals = 0,
+  locale = 'en-US'
+): string =>
+  `${toSafeNumber(value).toLocaleString(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  })}%`;
+
+export const percentage = (part: number, total: number): number => {
+  if (!total) {
+    return 0;
+  }
+
+  return roundToDecimals((part / total) * 100, 2);
+};
+
+export const formatBytes = (bytes: number, decimals = 2): string => {
+  if (bytes === 0) {
+    return '0 B';
+  }
+
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const index = Math.min(
+    Math.floor(Math.log(bytes) / Math.log(1024)),
+    units.length - 1
+  );
+  const value = bytes / 1024 ** index;
+
+  return `${roundToDecimals(value, decimals)} ${units[index]}`;
+};
+
+export const randomInt = (min: number, max: number): number => {
+  const lower = Math.ceil(min);
+  const upper = Math.floor(max);
+  return Math.floor(Math.random() * (upper - lower + 1)) + lower;
+};
+
+export const sum = (values: Array<number | string>): number =>
+  values.reduce<number>((total, value) => total + toSafeNumber(value), 0);
+
+export const average = (values: Array<number | string>): number => {
+  if (!values.length) {
+    return 0;
+  }
+
+  return roundToDecimals(sum(values) / values.length, 2);
+};

package/src/customFunctions/object.ts

@@ -0,0 +1,59 @@
+export const pick = <T extends object, K extends keyof T>(
+  object: T,
+  keys: K[]
+): Pick<T, K> => {
+  const result = {} as Pick<T, K>;
+
+  for (const key of keys) {
+    if (key in object) {
+      result[key] = object[key];
+    }
+  }
+
+  return result;
+};
+
+export const omit = <T extends object, K extends keyof T>(
+  object: T,
+  keys: K[]
+): Omit<T, K> => {
+  const result = { ...object };
+
+  for (const key of keys) {
+    delete result[key];
+  }
+
+  return result;
+};
+
+export const deepClone = <T>(value: T): T => {
+  if (value === null || typeof value !== 'object') {
+    return value;
+  }
+
+  return JSON.parse(JSON.stringify(value)) as T;
+};
+
+export const isPlainObject = (
+  value: unknown
+): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+export const getNestedValue = <T = unknown>(
+  object: Record<string, unknown>,
+  path: string,
+  fallback?: T
+): T | undefined => {
+  const keys = path.split('.');
+  let current: unknown = object;
+
+  for (const key of keys) {
+    if (!isPlainObject(current) || !(key in current)) {
+      return fallback;
+    }
+
+    current = current[key];
+  }
+
+  return current as T;
+};