@brcarddev/frontend-commons 1.0.2

package/src/utils/countries/countries.ts

@@ -0,0 +1,69 @@
+import { MASK_HELPERS } from '../masks';
+
+export type CountryCode = typeof COUNTRY_CODES[number];
+
+export const COUNTRY_CODES = [
+  { code: '+55', country: 'BR', name: 'Brasil', flag: '🇧🇷', mask: '(__) _ ____-____' },
+  { code: '+1', country: 'US', name: 'Estados Unidos', flag: '🇺🇸', mask: '(___) ___-____' },
+  { code: '+44', country: 'GB', name: 'Reino Unido', flag: '🇬🇧', mask: '____ ______' },
+  { code: '+33', country: 'FR', name: 'França', flag: '🇫🇷', mask: '_ __ __ __ __' },
+  { code: '+49', country: 'DE', name: 'Alemanha', flag: '🇩🇪', mask: '____ ______' },
+  { code: '+34', country: 'ES', name: 'Espanha', flag: '🇪🇸', mask: '___ ___ ___' },
+  { code: '+39', country: 'IT', name: 'Itália', flag: '🇮🇹', mask: '___ ___ ____' },
+  { code: '+31', country: 'NL', name: 'Países Baixos', flag: '🇳🇱', mask: '_ ____ ____' },
+  { code: '+32', country: 'BE', name: 'Bélgica', flag: '🇧🇪', mask: '___ ___ ___' },
+  { code: '+46', country: 'SE', name: 'Suécia', flag: '🇸🇪', mask: '__ ___ ____' },
+  { code: '+47', country: 'NO', name: 'Noruega', flag: '🇳🇴', mask: '___ __ ___' },
+  { code: '+45', country: 'DK', name: 'Dinamarca', flag: '🇩🇰', mask: '__ __ __ __' },
+  { code: '+358', country: 'FI', name: 'Finlândia', flag: '🇫🇮', mask: '__ ___ ____' },
+  { code: '+351', country: 'PT', name: 'Portugal', flag: '🇵🇹', mask: '___ ___ ___' },
+  { code: '+41', country: 'CH', name: 'Suíça', flag: '🇨🇭', mask: '__ ___ ____' },
+  { code: '+43', country: 'AT', name: 'Áustria', flag: '🇦🇹', mask: '___ ___ ____' },
+  { code: '+48', country: 'PL', name: 'Polônia', flag: '🇵🇱', mask: '___ ___ ___' },
+  { code: '+420', country: 'CZ', name: 'República Tcheca', flag: '🇨🇿', mask: '___ ___ ___' },
+  { code: '+36', country: 'HU', name: 'Hungria', flag: '🇭🇺', mask: '__ ___ ____' },
+  { code: '+7', country: 'RU', name: 'Rússia', flag: '🇷🇺', mask: '(___) ___-__-__' },
+  { code: '+86', country: 'CN', name: 'China', flag: '🇨🇳', mask: '___ ____ ____' },
+  { code: '+81', country: 'JP', name: 'Japão', flag: '🇯🇵', mask: '__ ____ ____' },
+  { code: '+82', country: 'KR', name: 'Coreia do Sul', flag: '🇰🇷', mask: '__ ____ ____' },
+  { code: '+91', country: 'IN', name: 'Índia', flag: '🇮🇳', mask: '_____ _____' },
+  { code: '+61', country: 'AU', name: 'Austrália', flag: '🇦🇺', mask: '___ ___ ___' },
+  { code: '+64', country: 'NZ', name: 'Nova Zelândia', flag: '🇳🇿', mask: '___ ___ ____' },
+  { code: '+52', country: 'MX', name: 'México', flag: '🇲🇽', mask: '___ ___ ____' },
+  { code: '+54', country: 'AR', name: 'Argentina', flag: '🇦🇷', mask: '__ ____ ____' },
+  { code: '+56', country: 'CL', name: 'Chile', flag: '🇨🇱', mask: '_ ____ ____' },
+  { code: '+57', country: 'CO', name: 'Colômbia', flag: '🇨🇴', mask: '___ ___ ____' },
+  { code: '+58', country: 'VE', name: 'Venezuela', flag: '🇻🇪', mask: '___ ___ ____' },
+  { code: '+51', country: 'PE', name: 'Peru', flag: '🇵🇪', mask: '___ ___ ___' },
+  { code: '+593', country: 'EC', name: 'Equador', flag: '🇪🇨', mask: '__ ___ ____' },
+  { code: '+595', country: 'PY', name: 'Paraguai', flag: '🇵🇾', mask: '__ ___ ____' },
+  { code: '+598', country: 'UY', name: 'Uruguai', flag: '🇺🇾', mask: '__ ___ ____' },
+] as const;
+
+export const formatInternationalPhone = (phone: string, countryCode: string): string => {
+  const country = getCountryByCode(countryCode);
+
+  if (!country) return phone;
+
+  const numbers = phone.replace(/\D/g, '');
+  return MASK_HELPERS.applyMask(numbers, country.mask);
+};
+
+export const getCountryByCode = (code: string): CountryCode | undefined => {
+  return COUNTRY_CODES.find(country => country.code === code);
+};
+
+export const getDefaultCountry = (): CountryCode => {
+  return COUNTRY_CODES.find(country => country.country === 'BR') || COUNTRY_CODES[0];
+};
+
+export const isValidInternationalPhone = (phone: string, countryCode: string): boolean => {
+  const country = getCountryByCode(countryCode);
+
+  if (!country) return false;
+
+  const numbers = phone.replace(/\D/g, '');
+  const expectedLength = country.mask.replace(/\D/g, '').length;
+
+  return numbers.length === expectedLength;
+};

package/src/utils/countries/index.ts

@@ -0,0 +1 @@
+export * from './countries';

package/src/utils/currency/currency.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+
+import { normalizeCurrency } from '../string';
+
+import {
+  convertFromCents,
+  formatCurrency,
+  formatCurrencyFromString,
+  displayAmount,
+  formatNumberToKOrM,
+  currencyShortener,
+  maskCurrency,
+} from './currency';
+
+describe('Currency Utils', () => {
+  describe('convertFromCents', () => {
+    it('should convert cents to decimal value', () => {
+      expect(convertFromCents('1000')).toBe(10);
+      expect(convertFromCents('150')).toBe(1.5);
+      expect(convertFromCents('0')).toBe(0);
+    });
+  });
+
+  describe('formatCurrency', () => {
+    it('should format number to currency string', () => {
+      expect(normalizeCurrency(formatCurrency(10.5))).toBe('R$ 10,50');
+      expect(normalizeCurrency(formatCurrency(1000))).toBe('R$ 1.000,00');
+      expect(normalizeCurrency(formatCurrency(0))).toBe('R$ 0,00');
+    });
+
+    it('should handle different currencies', () => {
+      expect(normalizeCurrency(formatCurrency(10.5, 'USD'))).toBe('US$ 10,50');
+      expect(normalizeCurrency(formatCurrency(10.5, 'EUR'))).toBe('€ 10,50');
+    });
+
+    it('should handle different locales', () => {
+      expect(normalizeCurrency(formatCurrency(10.5, 'USD', 2, 'en-US'))).toBe('$10.50');
+    });
+
+    it('should return dash for NaN values', () => {
+      expect(formatCurrency(NaN)).toBe('-');
+    });
+  });
+
+  describe('formatCurrencyFromString', () => {
+    it('should format string number to currency', () => {
+      expect(normalizeCurrency(formatCurrencyFromString('10.5'))).toBe('R$ 10,50');
+      expect(normalizeCurrency(formatCurrencyFromString('1000'))).toBe('R$ 1.000,00');
+    });
+
+    it('should handle different currencies', () => {
+      expect(normalizeCurrency(formatCurrencyFromString('10.5', 'USD'))).toBe('US$ 10,50');
+    });
+
+    it('should return dash for invalid strings', () => {
+      expect(normalizeCurrency(formatCurrencyFromString('invalid'))).toBe('-');
+    });
+  });
+
+  describe('displayAmount', () => {
+    it('should display amount within limit', () => {
+      expect(displayAmount(5, 10)).toBe('5');
+      expect(displayAmount(10, 10)).toBe('+10');
+    });
+
+    it('should display limit with plus sign when amount exceeds limit', () => {
+      expect(displayAmount(15, 10)).toBe('+10');
+    });
+
+    it('should display amount without limit', () => {
+      expect(displayAmount(5)).toBe('5');
+      expect(displayAmount(100)).toBe('100');
+    });
+  });
+
+  describe('formatNumberToKOrM', () => {
+    it('should format numbers less than 1000', () => {
+      expect(formatNumberToKOrM(999)).toBe('999');
+      expect(formatNumberToKOrM(0)).toBe('0');
+    });
+
+    it('should format numbers in thousands', () => {
+      expect(formatNumberToKOrM(1500)).toBe('1.5K');
+      expect(formatNumberToKOrM(9999)).toBe('10.0K');
+    });
+
+    it('should format numbers in millions', () => {
+      expect(formatNumberToKOrM(100000000)).toBe('100M');
+      expect(formatNumberToKOrM(150000000)).toBe('150M');
+    });
+  });
+
+  describe('currencyShortener', () => {
+    it('should shorten currency values', () => {
+      expect(currencyShortener(1000)).toBe('1.0K');
+    });
+  });
+
+  describe('maskCurrency', () => {
+    it('should mask currency values', () => {
+      expect(normalizeCurrency(maskCurrency(10.5))).toBe('R$ 10,50');
+      expect(normalizeCurrency(maskCurrency(1000))).toBe('R$ 1.000,00');
+    });
+
+    it('should handle different currencies', () => {
+      expect(normalizeCurrency(maskCurrency(10.5, 'pt-BR', 'USD'))).toBe('US$ 10,50');
+      expect(normalizeCurrency(maskCurrency(10.5, 'pt-BR', 'EUR'))).toBe('€ 10,50');
+    });
+
+    it('should handle different locales', () => {
+      expect(normalizeCurrency(maskCurrency(10.5, 'en-US', 'USD'))).toBe('$10.50');
+    });
+  });
+});

package/src/utils/currency/currency.ts

@@ -0,0 +1,134 @@
+export type CurrencyOption = {
+  code: string;
+  label: string;
+  locale: string;
+  symbol: string;
+};
+
+export function convertFromCents (value: string): number {
+  const cents = parseInt(value, 10);
+
+  if (isNaN(cents)) return 0;
+
+  return toMajorUnits(cents);
+}
+
+export const CURRENCY_OPTIONS: readonly CurrencyOption[] = [
+  { code: 'BRL', label: 'BRL - Real', locale: 'pt-BR', symbol: 'R$' },
+  // { code: 'USD', label: 'USD - Dollar', locale: 'en-US', symbol: '$' },
+  // { code: 'EUR', label: 'EUR - Euro', locale: 'de-DE', symbol: '€' },
+  // { code: 'GBP', label: 'GBP - Pound', locale: 'en-GB', symbol: '£' },
+] as const;
+
+export function currencyShortener (value: number): string {
+  return formatNumberToKOrM(value);
+}
+
+export function displayAmount (amount: number, limit?: number): string {
+  if (limit && amount >= limit) return `+${limit.toString()}`;
+
+  return amount.toString();
+}
+
+export function formatCurrency (value: number, currency = 'BRL', decimalPlaces = 2, locale = 'pt-BR'): string {
+  const formatter = new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency,
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces,
+  });
+
+  return !isNaN(value) ? formatter.format(value) : '-';
+}
+
+export function formatCurrencyFromString (value: string, currency = 'BRL'): string {
+  const parsedValue = parseFloat(value);
+
+  if (isNaN(parsedValue)) {
+    return '-';
+  }
+
+  return formatCurrency(parsedValue, currency);
+}
+
+export function formatMinorUnitsToCurrency (
+  valueInMinorUnits: number,
+  currencyCode: string,
+  locale?: string
+): string {
+  const currency = getCurrencyByCode(currencyCode) || getDefaultCurrency();
+  const resolvedLocale = locale || currency.locale;
+  const value = (valueInMinorUnits || 0) / 100;
+  return formatCurrency(value, currency.code, 2, resolvedLocale);
+}
+
+export function formatMinorUnitsToNumberString (
+  valueInMinorUnits: number,
+  locale = 'pt-BR'
+): string {
+  const value = (valueInMinorUnits || 0) / 100;
+  const formatter = new Intl.NumberFormat(locale, {
+    style: 'decimal',
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+    useGrouping: true,
+  });
+
+  return formatter.format(value);
+}
+
+export function formatNumberToKOrM (value: number): string {
+  const sign = value < 0 ? '-' : '';
+  const abs = Math.abs(value);
+
+  if (abs < 1000) {
+    return value.toString();
+  }
+
+  if (abs < 1_000_000) {
+    const thousands = abs / 1000;
+
+    return `${sign}${thousands < 10 ? thousands.toFixed(1) : Math.round(thousands).toString()}K`;
+  }
+
+  const millions = abs / 1_000_000;
+
+  return `${sign}${millions < 10 ? millions.toFixed(1) : Math.round(millions).toString()}M`;
+}
+
+export const getCurrencyByCode = (code: string): CurrencyOption | undefined => {
+  return CURRENCY_OPTIONS.find(c => c.code === code);
+};
+
+export const getDefaultCurrency = (): CurrencyOption => {
+  return getCurrencyByCode('BRL') || CURRENCY_OPTIONS[0];
+};
+
+export function maskCurrency (value: number, locale = 'pt-BR', currency = 'BRL'): string {
+  return formatCurrency(value, currency, 2, locale);
+}
+
+export function parseCurrencyToMinorUnits (formatted: string): number {
+  if (!formatted) return 0;
+
+  const trimmed = formatted.trim();
+  const isNegative = /^-/.test(trimmed) || /-$/.test(trimmed) || (trimmed.includes('(') && trimmed.includes(')'));
+  const sign = isNegative ? -1 : 1;
+  const numbers = trimmed.replace(/\D/g, '');
+
+  if (!numbers) return 0;
+
+  return sign * parseInt(numbers, 10);
+}
+
+export function toMajorUnits (minorUnits: number): number {
+  if (typeof minorUnits !== 'number' || !isFinite(minorUnits)) return 0;
+
+  return minorUnits / 100;
+}
+
+export function toMinorUnits (majorUnits: number): number {
+  if (typeof majorUnits !== 'number' || !isFinite(majorUnits)) return 0;
+
+  return Math.round(majorUnits * 100);
+}

package/src/utils/currency/index.ts

@@ -0,0 +1 @@
+export * from './currency';

package/src/utils/date/date.test.ts

@@ -0,0 +1,167 @@
+import { DateTime } from 'luxon';
+import { describe, it, expect, beforeEach } from 'vitest';
+
+import {
+  getCurrentDate,
+  toCurrentTimezone,
+  toCurrentTimezoneWithSeconds,
+  fromIsoToLocale,
+  createISODate,
+  formatISODate,
+  formatFromFromat,
+  fromIsoToMillis,
+  convertUnixTime,
+  addMonth,
+} from './date';
+
+describe('Date Utils', () => {
+  const MOCK_ISO_DATE = '2023-01-01T12:00:00.000Z';
+  const MOCK_UNIX_TIMESTAMP = 1672560000; // 2023-01-01T12:00:00Z
+  let mockDateTime: DateTime;
+
+  beforeEach(() => {
+    mockDateTime = DateTime.fromISO(MOCK_ISO_DATE);
+  });
+
+  describe('getCurrentDate', () => {
+    it('should return current date in ISO format', () => {
+      const today = DateTime.local().toISODate();
+      expect(getCurrentDate()).toBe(today);
+    });
+  });
+
+  describe('toCurrentTimezone', () => {
+    it('should format ISO string to local string with default format', () => {
+      const expected = mockDateTime.toLocaleString(DateTime.DATETIME_SHORT);
+      expect(toCurrentTimezone(MOCK_ISO_DATE)).toBe(expected);
+    });
+
+    it('should format ISO string with custom format', () => {
+      const customFormat = DateTime.DATE_FULL;
+      const expected = mockDateTime.toLocaleString(customFormat);
+      expect(toCurrentTimezone(MOCK_ISO_DATE, customFormat)).toBe(expected);
+    });
+
+    it('should return dash for empty input', () => {
+      expect(toCurrentTimezone('')).toBe('-');
+      expect(toCurrentTimezone(undefined)).toBe('-');
+    });
+  });
+
+  describe('toCurrentTimezoneWithSeconds', () => {
+    it('should format ISO string with seconds and replace slashes with dashes', () => {
+      const expected = mockDateTime
+        .toLocaleString(DateTime.DATETIME_SHORT_WITH_SECONDS)
+        .replace(/\//g, '-');
+      expect(toCurrentTimezoneWithSeconds(MOCK_ISO_DATE)).toBe(expected);
+    });
+
+    it('should return dash for empty input', () => {
+      expect(toCurrentTimezoneWithSeconds('')).toBe('-');
+      expect(toCurrentTimezoneWithSeconds(null)).toBe('-');
+    });
+  });
+
+  describe('fromIsoToLocale', () => {
+    it('should convert ISO string to local string format', () => {
+      const expected = mockDateTime.toLocaleString();
+      expect(fromIsoToLocale(MOCK_ISO_DATE)).toBe(expected);
+    });
+
+    it('should throw error for invalid ISO string', () => {
+      expect(() => fromIsoToLocale('invalid-date')).toThrow();
+    });
+  });
+
+  describe('createISODate', () => {
+    it('should create DateTime object from ISO string', () => {
+      const result = createISODate(MOCK_ISO_DATE);
+      expect(result).toBeInstanceOf(DateTime);
+      expect(result.toISO()).toBe(mockDateTime.toISO());
+    });
+
+    it('should throw error for invalid ISO string', () => {
+      expect(() => createISODate('invalid-date')).toThrow();
+    });
+  });
+
+  describe('formatISODate', () => {
+    it('should format ISO string with custom format', () => {
+      const format = 'dd/MM/yyyy';
+      const expected = mockDateTime.toFormat(format);
+      expect(formatISODate(MOCK_ISO_DATE, format)).toBe(expected);
+    });
+
+    it('should throw error for invalid ISO string', () => {
+      expect(() => formatISODate('invalid-date', 'dd/MM/yyyy')).toThrow();
+    });
+  });
+
+  describe('formatFromFromat', () => {
+    const MOCK_DATE = '01-02-2023';
+    const FROM_FORMAT = 'dd-MM-yyyy';
+    const TO_FORMAT = 'yyyy/MM/dd';
+
+    it('should convert date from one format to another', () => {
+      const expected = DateTime.fromFormat(MOCK_DATE, FROM_FORMAT).toFormat(TO_FORMAT);
+      expect(formatFromFromat(MOCK_DATE, FROM_FORMAT, TO_FORMAT)).toBe(expected);
+    });
+
+    it('should throw error for invalid date format', () => {
+      expect(() => formatFromFromat('invalid-date', FROM_FORMAT, TO_FORMAT)).toThrow();
+    });
+  });
+
+  describe('fromIsoToMillis', () => {
+    it('should convert ISO string to milliseconds', () => {
+      const expected = mockDateTime.toMillis();
+      expect(fromIsoToMillis(MOCK_ISO_DATE)).toBe(expected);
+    });
+
+    it('should throw error for invalid ISO string', () => {
+      expect(() => fromIsoToMillis('invalid-date')).toThrow();
+    });
+  });
+
+  describe('convertUnixTime', () => {
+    it('should convert unix timestamp to local string', () => {
+      const expected = DateTime.fromSeconds(MOCK_UNIX_TIMESTAMP, {
+        zone: 'utc',
+        locale: 'pt-BR',
+      }).toLocaleString(DateTime.DATETIME_SHORT);
+      expect(convertUnixTime(MOCK_UNIX_TIMESTAMP)).toBe(expected);
+    });
+
+    it('should handle zero timestamp', () => {
+      const expected = DateTime.fromSeconds(0, {
+        zone: 'utc',
+        locale: 'pt-BR',
+      }).toLocaleString(DateTime.DATETIME_SHORT);
+      expect(convertUnixTime(0)).toBe(expected);
+    });
+  });
+
+  describe('addMonth', () => {
+    it('should add months to DateTime object', () => {
+      const monthsToAdd = 2;
+      const result = addMonth(mockDateTime, monthsToAdd);
+      expect(result.month).toBe(mockDateTime.month + monthsToAdd);
+      expect(result.year).toBe(mockDateTime.year);
+    });
+
+    it('should handle year rollover when adding months', () => {
+      const date = DateTime.fromISO('2023-12-01T12:00:00.000Z');
+      const result = addMonth(date, 2);
+      expect(result.month).toBe(2);
+      expect(result.year).toBe(date.year + 1);
+    });
+
+    it('should handle negative months', () => {
+      const monthsToSubtract = -2;
+      const result = addMonth(mockDateTime, monthsToSubtract);
+      const expectedDate = mockDateTime.minus({ months: 2 });
+      expect(result.month).toBe(expectedDate.month);
+      expect(result.year).toBe(expectedDate.year);
+    });
+  });
+});

package/src/utils/date/date.ts

@@ -0,0 +1,83 @@
+import { DateTime } from 'luxon';
+
+export function addMonth (date: DateTime, month: number): DateTime {
+  const result = date.plus({ months: month });
+  return result;
+}
+
+export function convertUnixTime (unix: number) {
+  const unixParsed = Number(unix);
+
+  const unixConverted = DateTime.fromSeconds(unixParsed, {
+    zone: 'utc',
+    locale: 'pt-BR',
+  });
+
+  return unixConverted.toLocaleString(DateTime.DATETIME_SHORT);
+}
+
+export function createISODate (date: string): DateTime {
+  const parsedDate = DateTime.fromISO(date);
+
+  if (!parsedDate.isValid) {
+    throw new Error('Invalid ISO date string');
+  }
+
+  return parsedDate;
+}
+
+export function formatFromFromat (date: string, fromFormat: string, toFormat: string) {
+  const dateFormat = DateTime.fromFormat(date, fromFormat);
+
+  if (!dateFormat.isValid) {
+    throw new Error('Invalid date format');
+  }
+
+  return dateFormat.toFormat(toFormat);
+}
+
+export function formatISODate (date: string, format: string): string {
+  const parsedDate = DateTime.fromISO(date);
+
+  if (!parsedDate.isValid) {
+    throw new Error('Invalid ISO date string');
+  }
+
+  return parsedDate.toFormat(format);
+}
+
+export function fromIsoToLocale (date: string): string {
+  const parsedDate = DateTime.fromISO(date);
+
+  if (!parsedDate.isValid) {
+    throw new Error('Invalid ISO date string');
+  }
+
+  return parsedDate.toLocaleString();
+}
+
+export function fromIsoToMillis (date: string): number {
+  const parsedDate = DateTime.fromISO(date);
+
+  if (!parsedDate.isValid) {
+    throw new Error('Invalid ISO date string');
+  }
+
+  return parsedDate.toMillis();
+}
+
+export function getCurrentDate (): string | null {
+  return DateTime.local().toISODate();
+}
+
+export function toCurrentTimezone (date: string | undefined | null, format = DateTime.DATETIME_SHORT): string {
+  if (!date) return '-';
+
+  return DateTime?.fromISO(date)?.toLocaleString(format);
+}
+
+export function toCurrentTimezoneWithSeconds (date: string | undefined | null): string {
+  if (!date) return '-';
+
+  return DateTime?.fromISO(date)?.toLocaleString(DateTime.DATETIME_SHORT_WITH_SECONDS).replace(/\//g, '-');
+}

package/src/utils/date/index.ts

@@ -0,0 +1 @@
+export * from './date';

package/src/utils/file/file.ts

@@ -0,0 +1,45 @@
+export const formatFileSize = (bytes: number) => {
+  if (bytes === 0) return '0 Bytes';
+
+  const k = 1024;
+  const sizes = [ 'Bytes', 'KB', 'MB', 'GB' ];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+};
+
+export function getMimeTypeByExtension(extension: string): string {
+  const mimeTypes: { [key: string]: string } = {
+    '.3gp': 'video/3gpp',
+    '.avi': 'video/x-msvideo',
+    '.bmp': 'image/bmp',
+    '.csv': 'text/csv',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.gif': 'image/gif',
+    '.htm': 'text/html',
+    '.html': 'text/html',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.json': 'application/json',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.mpeg': 'video/mpeg',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.svg': 'image/svg+xml',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.txt': 'text/plain',
+    '.wav': 'audio/wav',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.xml': 'application/xml',
+    '.zip': 'application/zip',
+  };
+
+  const mimeType = mimeTypes[extension.toLowerCase()];
+
+  return mimeType;
+}

package/src/utils/file/index.ts

@@ -0,0 +1 @@
+export * from './file';

package/src/utils/get-initials/get-initials.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+
+import { getInitials } from './get-initials';
+
+describe('getInitials utility', () => {
+  it('should return empty string when input is empty', () => {
+    expect(getInitials('')).toBe('');
+  });
+
+  it('should return empty string when input is only spaces', () => {
+    expect(getInitials('     ')).toBe('');
+  });
+
+  it('should return the first letter of a single name, capitalized', () => {
+    expect(getInitials('alice')).toBe('A');
+    expect(getInitials('  bob  ')).toBe('B');
+  });
+
+  it('should return initials from first and last words of a full name', () => {
+    expect(getInitials('John Doe')).toBe('JD');
+    expect(getInitials('Marie Curie')).toBe('MC');
+  });
+
+  it('should return initials using first and last word, ignoring middle names', () => {
+    expect(getInitials('Ada Lovelace Byron')).toBe('AB');
+    expect(getInitials('Jean Baptiste Pierre Antoine de Monet')).toBe('JM');
+  });
+
+  it('should handle mixed casing and trim spaces correctly', () => {
+    expect(getInitials('  aDa   lOvElAcE  ')).toBe('AL');
+  });
+
+  it('should return correct initials for hyphenated names', () => {
+    expect(getInitials('Mary-Jane Watson')).toBe('MW');
+  });
+
+  it('should not throw if name is a string with only one character', () => {
+    expect(getInitials('Q')).toBe('Q');
+  });
+});

package/src/utils/get-initials/get-initials.ts

@@ -0,0 +1,13 @@
+export function getInitials(name: string) {
+  if (!name) return '';
+
+  const words = name.trim().split(' ').filter(Boolean);
+
+  if (words.length === 0) return '';
+
+  if (words.length === 1) {
+    return words[0][0].toUpperCase();
+  }
+
+  return (words[0][0] + words[words.length - 1][0]).toUpperCase();
+}

package/src/utils/get-initials/index.ts

@@ -0,0 +1 @@
+export * from './get-initials';