@cranberry-money/shared-utils 8.19.0 → 8.19.1

package/dist/badge.js

@@ -1,72 +0,0 @@
-/**
- * Badge System Core - Type definitions and factory function
- *
- * This module provides a standardized way to create and style badges.
- * It ensures consistency in colors, typography, and semantic meaning
- * while maintaining accessibility standards.
- *
- * Note: The actual style classes are designed to work with Tailwind CSS
- * and assume a specific color system is in place.
- */
-/**
- * Default variant styles using Tailwind CSS classes
- * These assume a specific color system with surface and semantic colors
- */
-const DEFAULT_BADGE_VARIANTS = {
-    default: 'bg-surface-secondary text-content-body',
-    primary: 'bg-surface-tertiary text-content-secondary',
-    secondary: 'bg-surface-secondary text-content-body',
-    success: 'bg-success-900/80 text-success-300',
-    warning: 'bg-warning-900/80 text-warning-300',
-    error: 'bg-error-900/80 text-error-300',
-    info: 'bg-surface-tertiary text-content-body',
-    neutral: 'bg-surface-secondary text-content-muted',
-};
-/**
- * Default size styles for badges
- */
-const DEFAULT_BADGE_SIZES = {
-    sm: 'text-xs px-1.5 py-0.5',
-    md: 'text-xs px-2 py-1',
-    lg: 'text-sm px-3 py-1.5',
-};
-/**
- * Base badge styles that apply to all badges
- */
-const BASE_BADGE_STYLES = 'inline-flex items-center rounded-md font-medium whitespace-nowrap transition-colors';
-/**
- * Creates a badge style configuration with appropriate CSS classes
- *
- * @param config - Badge configuration options
- * @param variantStyles - Optional custom variant styles (defaults to DEFAULT_BADGE_VARIANTS)
- * @param sizeStyles - Optional custom size styles (defaults to DEFAULT_BADGE_SIZES)
- * @returns Badge style object with className and accessibility attributes
- *
- * @example
- * ```typescript
- * // Create a success badge
- * const successBadge = createBadge({ variant: 'success' });
- * // Returns: { className: 'inline-flex items-center rounded-md font-medium whitespace-nowrap transition-colors bg-success-900/80 text-success-300 text-xs px-2 py-1', ariaLabel: 'success status' }
- *
- * // Create a large warning badge with custom class
- * const warningBadge = createBadge({ variant: 'warning', size: 'lg', className: 'ml-2' });
- *
- * // Use custom variant styles
- * const customVariants = { primary: 'bg-blue-500 text-white', ... };
- * const customBadge = createBadge({ variant: 'primary' }, customVariants);
- * ```
- */
-export function createBadge({ variant, size = 'md', className = '' }, variantStyles = DEFAULT_BADGE_VARIANTS, sizeStyles = DEFAULT_BADGE_SIZES) {
-    const variantClasses = variantStyles[variant] || variantStyles.neutral;
-    const sizeClasses = sizeStyles[size];
-    return {
-        className: `${BASE_BADGE_STYLES} ${variantClasses} ${sizeClasses} ${className}`.trim(),
-        ariaLabel: `${variant} status`,
-    };
-}
-/**
- * Export the default style mappings for consumers who want to use them directly
- * or extend them with their own styles
- */
-export const BADGE_VARIANTS = DEFAULT_BADGE_VARIANTS;
-export const BADGE_SIZES = DEFAULT_BADGE_SIZES;

package/dist/cash-account.d.ts

@@ -1,43 +0,0 @@
-/**
- * Base transaction type interface for type flexibility
- */
-export interface BaseTransactionType {
-    readonly [key: string]: string;
-}
-/**
- * Format cash account balance with AUD currency formatting
- *
- * @param balance - Balance value to format (string or number)
- * @returns Formatted currency string using Australian locale and AUD currency
- *
- * @example
- * formatBalance(1234.56); // returns '$1,234.56'
- * formatBalance('1000'); // returns '$1,000.00'
- * formatBalance(0); // returns '$0.00'
- */
-export declare const formatBalance: (balance: string | number) => string;
-/**
- * Format transaction amount with signed currency formatting (shows + or -)
- *
- * @param amount - Transaction amount to format (string or number)
- * @returns Formatted signed currency string using Australian locale and AUD currency
- *
- * @example
- * formatTransactionAmount(1234.56); // returns '+$1,234.56'
- * formatTransactionAmount(-500); // returns '-$500.00'
- * formatTransactionAmount('1000'); // returns '+$1,000.00'
- */
-export declare const formatTransactionAmount: (amount: string | number) => string;
-/**
- * Get human-readable label for transaction type
- *
- * @param transactionType - Transaction type key
- * @param labels - Optional custom transaction type labels (defaults to shared constants)
- * @returns Human-readable transaction type label
- *
- * @example
- * getTransactionTypeLabel('DEPOSIT'); // returns transaction type label from constants
- * getTransactionTypeLabel('WITHDRAWAL'); // returns transaction type label from constants
- */
-export declare const getTransactionTypeLabel: <T extends string>(transactionType: T, labels?: Record<T, string>) => string;
-//# sourceMappingURL=cash-account.d.ts.map

package/dist/cash-account.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cash-account.d.ts","sourceRoot":"","sources":["../src/cash-account.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,MAAM,KAAG,MAMxD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GAAI,QAAQ,MAAM,GAAG,MAAM,KAAG,MAMjE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,MAAM,EACtD,iBAAiB,CAAC,EAClB,SAAQ,MAAM,CAAC,CAAC,EAAE,MAAM,CAA6D,KACpF,MAEF,CAAC"}

package/dist/cash-account.js

@@ -1,52 +0,0 @@
-import { LOCALE_AUSTRALIA, CURRENCY_AUD, CASH_ACCOUNT_TRANSACTION_TYPE_LABELS, } from '@cranberry-money/shared-constants';
-import { NUMBER_FORMAT_OPTIONS_CURRENCY, NUMBER_FORMAT_OPTIONS_CURRENCY_SIGNED } from './currency';
-/**
- * Format cash account balance with AUD currency formatting
- *
- * @param balance - Balance value to format (string or number)
- * @returns Formatted currency string using Australian locale and AUD currency
- *
- * @example
- * formatBalance(1234.56); // returns '$1,234.56'
- * formatBalance('1000'); // returns '$1,000.00'
- * formatBalance(0); // returns '$0.00'
- */
-export const formatBalance = (balance) => {
-    const numBalance = typeof balance === 'string' ? parseFloat(balance) : balance;
-    return new Intl.NumberFormat(LOCALE_AUSTRALIA, {
-        ...NUMBER_FORMAT_OPTIONS_CURRENCY,
-        currency: CURRENCY_AUD,
-    }).format(numBalance);
-};
-/**
- * Format transaction amount with signed currency formatting (shows + or -)
- *
- * @param amount - Transaction amount to format (string or number)
- * @returns Formatted signed currency string using Australian locale and AUD currency
- *
- * @example
- * formatTransactionAmount(1234.56); // returns '+$1,234.56'
- * formatTransactionAmount(-500); // returns '-$500.00'
- * formatTransactionAmount('1000'); // returns '+$1,000.00'
- */
-export const formatTransactionAmount = (amount) => {
-    const numAmount = typeof amount === 'string' ? parseFloat(amount) : amount;
-    return new Intl.NumberFormat(LOCALE_AUSTRALIA, {
-        ...NUMBER_FORMAT_OPTIONS_CURRENCY_SIGNED,
-        currency: CURRENCY_AUD,
-    }).format(numAmount);
-};
-/**
- * Get human-readable label for transaction type
- *
- * @param transactionType - Transaction type key
- * @param labels - Optional custom transaction type labels (defaults to shared constants)
- * @returns Human-readable transaction type label
- *
- * @example
- * getTransactionTypeLabel('DEPOSIT'); // returns transaction type label from constants
- * getTransactionTypeLabel('WITHDRAWAL'); // returns transaction type label from constants
- */
-export const getTransactionTypeLabel = (transactionType, labels = CASH_ACCOUNT_TRANSACTION_TYPE_LABELS) => {
-    return labels[transactionType];
-};

package/dist/collections.d.ts

@@ -1,80 +0,0 @@
-/**
- * Generic collection and array utilities
- * Pure functions for common array operations with type safety
- */
-/**
- * Sort array of objects by a string field
- * @param items - Array of objects to sort
- * @param fieldName - Name of the field to sort by
- * @returns New sorted array
- */
-export declare function sortByStringField<T>(items: T[], fieldName: keyof T): T[];
-/**
- * Filter array by text search in a specific field (case-insensitive)
- * @param items - Array of objects to filter
- * @param fieldName - Name of the field to search in
- * @param searchTerm - Search term
- * @returns Filtered array
- */
-export declare function filterByTextSearch<T>(items: T[], fieldName: keyof T, searchTerm: string): T[];
-/**
- * Filter array by boolean field
- * @param items - Array of objects to filter
- * @param fieldName - Name of the boolean field
- * @param value - Boolean value to filter by
- * @returns Filtered array
- */
-export declare function filterByBooleanField<T>(items: T[], fieldName: keyof T, value: boolean): T[];
-/**
- * Find item by exact field match
- * @param items - Array of objects to search
- * @param fieldName - Name of the field to match
- * @param value - Value to match
- * @returns Found item or undefined
- */
-export declare function findByField<T>(items: T[], fieldName: keyof T, value: unknown): T | undefined;
-/**
- * Find item by case-insensitive string field match
- * @param items - Array of objects to search
- * @param fieldName - Name of the string field to match
- * @param value - String value to match (case-insensitive)
- * @returns Found item or undefined
- */
-export declare function findByStringField<T>(items: T[], fieldName: keyof T, value: string): T | undefined;
-/**
- * Extract values from a specific field and sort them
- * @param items - Array of objects
- * @param fieldName - Name of the field to extract
- * @returns Sorted array of extracted values
- */
-export declare function extractAndSortField<T, K extends keyof T>(items: T[], fieldName: K): T[K][];
-/**
- * Group array items by the first character of a string field
- * @param items - Array of objects to group
- * @param fieldName - Name of the string field to group by
- * @returns Object with first letters as keys and arrays of items as values
- */
-export declare function groupByFirstLetter<T>(items: T[], fieldName: keyof T): Record<string, T[]>;
-/**
- * Group array items by a field value
- * @param items - Array of objects to group
- * @param fieldName - Name of the field to group by
- * @returns Object with field values as keys and arrays of items as values
- */
-export declare function groupByField<T, K extends keyof T>(items: T[], fieldName: K): Record<string, T[]>;
-/**
- * Check if any item in array has a specific boolean field value
- * @param items - Array of objects to check
- * @param fieldName - Name of the boolean field
- * @param value - Boolean value to check for
- * @returns true if any item matches, false otherwise
- */
-export declare function hasItemWithFieldValue<T>(items: T[], fieldName: keyof T, value: unknown): boolean;
-/**
- * Count items that match a field value
- * @param items - Array of objects to count
- * @param fieldName - Name of the field to check
- * @param value - Value to count
- * @returns Number of matching items
- */
-export declare function countByFieldValue<T>(items: T[], fieldName: keyof T, value: unknown): number;

package/dist/collections.js

@@ -1,127 +0,0 @@
-/**
- * Generic collection and array utilities
- * Pure functions for common array operations with type safety
- */
-/**
- * Sort array of objects by a string field
- * @param items - Array of objects to sort
- * @param fieldName - Name of the field to sort by
- * @returns New sorted array
- */
-export function sortByStringField(items, fieldName) {
-    return [...items].sort((a, b) => {
-        const aValue = String(a[fieldName]);
-        const bValue = String(b[fieldName]);
-        return aValue.localeCompare(bValue);
-    });
-}
-/**
- * Filter array by text search in a specific field (case-insensitive)
- * @param items - Array of objects to filter
- * @param fieldName - Name of the field to search in
- * @param searchTerm - Search term
- * @returns Filtered array
- */
-export function filterByTextSearch(items, fieldName, searchTerm) {
-    const lowercaseSearch = searchTerm.toLowerCase();
-    return items.filter(item => {
-        const fieldValue = String(item[fieldName]).toLowerCase();
-        return fieldValue.includes(lowercaseSearch);
-    });
-}
-/**
- * Filter array by boolean field
- * @param items - Array of objects to filter
- * @param fieldName - Name of the boolean field
- * @param value - Boolean value to filter by
- * @returns Filtered array
- */
-export function filterByBooleanField(items, fieldName, value) {
-    return items.filter(item => Boolean(item[fieldName]) === value);
-}
-/**
- * Find item by exact field match
- * @param items - Array of objects to search
- * @param fieldName - Name of the field to match
- * @param value - Value to match
- * @returns Found item or undefined
- */
-export function findByField(items, fieldName, value) {
-    return items.find(item => item[fieldName] === value);
-}
-/**
- * Find item by case-insensitive string field match
- * @param items - Array of objects to search
- * @param fieldName - Name of the string field to match
- * @param value - String value to match (case-insensitive)
- * @returns Found item or undefined
- */
-export function findByStringField(items, fieldName, value) {
-    const lowercaseValue = value.toLowerCase();
-    return items.find(item => {
-        const fieldValue = String(item[fieldName]).toLowerCase();
-        return fieldValue === lowercaseValue;
-    });
-}
-/**
- * Extract values from a specific field and sort them
- * @param items - Array of objects
- * @param fieldName - Name of the field to extract
- * @returns Sorted array of extracted values
- */
-export function extractAndSortField(items, fieldName) {
-    return items.map(item => item[fieldName]).sort();
-}
-/**
- * Group array items by the first character of a string field
- * @param items - Array of objects to group
- * @param fieldName - Name of the string field to group by
- * @returns Object with first letters as keys and arrays of items as values
- */
-export function groupByFirstLetter(items, fieldName) {
-    return items.reduce((groups, item) => {
-        const fieldValue = String(item[fieldName]);
-        const firstLetter = fieldValue.charAt(0).toUpperCase();
-        if (!groups[firstLetter]) {
-            groups[firstLetter] = [];
-        }
-        groups[firstLetter].push(item);
-        return groups;
-    }, {});
-}
-/**
- * Group array items by a field value
- * @param items - Array of objects to group
- * @param fieldName - Name of the field to group by
- * @returns Object with field values as keys and arrays of items as values
- */
-export function groupByField(items, fieldName) {
-    return items.reduce((groups, item) => {
-        const fieldValue = String(item[fieldName]);
-        if (!groups[fieldValue]) {
-            groups[fieldValue] = [];
-        }
-        groups[fieldValue].push(item);
-        return groups;
-    }, {});
-}
-/**
- * Check if any item in array has a specific boolean field value
- * @param items - Array of objects to check
- * @param fieldName - Name of the boolean field
- * @param value - Boolean value to check for
- * @returns true if any item matches, false otherwise
- */
-export function hasItemWithFieldValue(items, fieldName, value) {
-    return items.some(item => item[fieldName] === value);
-}
-/**
- * Count items that match a field value
- * @param items - Array of objects to count
- * @param fieldName - Name of the field to check
- * @param value - Value to count
- * @returns Number of matching items
- */
-export function countByFieldValue(items, fieldName, value) {
-    return items.filter(item => item[fieldName] === value).length;
-}

package/dist/country.d.ts

@@ -1,107 +0,0 @@
-/**
- * Base interface for country objects
- */
-export interface BaseCountry {
-    readonly name: string;
-    readonly code: string;
-    readonly uuid: string;
-    readonly isAvailable: boolean;
-    readonly dialCode?: string;
-}
-/**
- * Sort countries by name
- *
- * @param countries - Array of countries to sort
- * @returns Sorted array of countries
- *
- * @example
- * const sorted = sortCountriesByName(countries);
- */
-export declare const sortCountriesByName: <T extends BaseCountry>(countries: readonly T[]) => T[];
-/**
- * Filter countries by name (case-insensitive search)
- *
- * @param countries - Array of countries to filter
- * @param searchTerm - Search term to filter by
- * @returns Filtered array of countries
- *
- * @example
- * const filtered = filterCountriesByName(countries, 'united');
- * // Returns countries with 'united' in the name
- */
-export declare const filterCountriesByName: <T extends BaseCountry>(countries: readonly T[], searchTerm: string) => T[];
-/**
- * Filter countries by availability
- *
- * @param countries - Array of countries to filter
- * @returns Array of available countries
- *
- * @example
- * const available = filterAvailableCountries(countries);
- */
-export declare const filterAvailableCountries: <T extends BaseCountry>(countries: readonly T[]) => T[];
-/**
- * Find country by exact name match
- *
- * @param countries - Array of countries to search
- * @param name - Exact name to find
- * @returns Found country or undefined
- *
- * @example
- * const country = findCountryByName(countries, 'United States');
- */
-export declare const findCountryByName: <T extends BaseCountry>(countries: readonly T[], name: string) => T | undefined;
-/**
- * Find country by country code
- *
- * @param countries - Array of countries to search
- * @param code - Country code to find (e.g., 'US', 'CA')
- * @returns Found country or undefined
- *
- * @example
- * const country = findCountryByCode(countries, 'US');
- */
-export declare const findCountryByCode: <T extends BaseCountry>(countries: readonly T[], code: string) => T | undefined;
-/**
- * Get sorted list of country names
- *
- * @param countries - Array of countries
- * @returns Sorted array of country names
- *
- * @example
- * const names = getCountryNames(countries);
- * // ['Australia', 'Canada', 'United States', ...]
- */
-export declare const getCountryNames: <T extends BaseCountry>(countries: readonly T[]) => string[];
-/**
- * Group countries alphabetically by first letter
- *
- * @param countries - Array of countries to group
- * @returns Record of countries grouped by first letter
- *
- * @example
- * const grouped = groupCountriesAlphabetically(countries);
- * // { 'A': [...], 'B': [...], 'C': [...], ... }
- */
-export declare const groupCountriesAlphabetically: <T extends BaseCountry>(countries: readonly T[]) => Record<string, T[]>;
-/**
- * Format country with dial code for display
- *
- * @param country - Country to format
- * @returns Formatted string with country name and dial code
- *
- * @example
- * formatCountryWithDialCode({ name: 'United States', dialCode: '+1', ... });
- * // Returns 'United States (+1)'
- */
-export declare const formatCountryWithDialCode: <T extends BaseCountry>(country: T) => string;
-/**
- * Check if a country is available
- *
- * @param country - Country to check
- * @returns True if country is available
- *
- * @example
- * const available = isCountryAvailable(country);
- */
-export declare const isCountryAvailable: <T extends BaseCountry>(country: T) => boolean;

package/dist/country.js

@@ -1,116 +0,0 @@
-import { sortByStringField, filterByTextSearch, filterByBooleanField, findByStringField, extractAndSortField, groupByFirstLetter, } from './collections';
-/**
- * Sort countries by name
- *
- * @param countries - Array of countries to sort
- * @returns Sorted array of countries
- *
- * @example
- * const sorted = sortCountriesByName(countries);
- */
-export const sortCountriesByName = (countries) => {
-    return sortByStringField([...countries], 'name');
-};
-/**
- * Filter countries by name (case-insensitive search)
- *
- * @param countries - Array of countries to filter
- * @param searchTerm - Search term to filter by
- * @returns Filtered array of countries
- *
- * @example
- * const filtered = filterCountriesByName(countries, 'united');
- * // Returns countries with 'united' in the name
- */
-export const filterCountriesByName = (countries, searchTerm) => {
-    return filterByTextSearch([...countries], 'name', searchTerm);
-};
-/**
- * Filter countries by availability
- *
- * @param countries - Array of countries to filter
- * @returns Array of available countries
- *
- * @example
- * const available = filterAvailableCountries(countries);
- */
-export const filterAvailableCountries = (countries) => {
-    return filterByBooleanField([...countries], 'isAvailable', true);
-};
-/**
- * Find country by exact name match
- *
- * @param countries - Array of countries to search
- * @param name - Exact name to find
- * @returns Found country or undefined
- *
- * @example
- * const country = findCountryByName(countries, 'United States');
- */
-export const findCountryByName = (countries, name) => {
-    return findByStringField([...countries], 'name', name);
-};
-/**
- * Find country by country code
- *
- * @param countries - Array of countries to search
- * @param code - Country code to find (e.g., 'US', 'CA')
- * @returns Found country or undefined
- *
- * @example
- * const country = findCountryByCode(countries, 'US');
- */
-export const findCountryByCode = (countries, code) => {
-    return findByStringField([...countries], 'code', code);
-};
-/**
- * Get sorted list of country names
- *
- * @param countries - Array of countries
- * @returns Sorted array of country names
- *
- * @example
- * const names = getCountryNames(countries);
- * // ['Australia', 'Canada', 'United States', ...]
- */
-export const getCountryNames = (countries) => {
-    return extractAndSortField([...countries], 'name');
-};
-/**
- * Group countries alphabetically by first letter
- *
- * @param countries - Array of countries to group
- * @returns Record of countries grouped by first letter
- *
- * @example
- * const grouped = groupCountriesAlphabetically(countries);
- * // { 'A': [...], 'B': [...], 'C': [...], ... }
- */
-export const groupCountriesAlphabetically = (countries) => {
-    return groupByFirstLetter([...countries], 'name');
-};
-/**
- * Format country with dial code for display
- *
- * @param country - Country to format
- * @returns Formatted string with country name and dial code
- *
- * @example
- * formatCountryWithDialCode({ name: 'United States', dialCode: '+1', ... });
- * // Returns 'United States (+1)'
- */
-export const formatCountryWithDialCode = (country) => {
-    return country.dialCode ? `${country.name} (${country.dialCode})` : country.name;
-};
-/**
- * Check if a country is available
- *
- * @param country - Country to check
- * @returns True if country is available
- *
- * @example
- * const available = isCountryAvailable(country);
- */
-export const isCountryAvailable = (country) => {
-    return country.isAvailable;
-};