@cranberry-money/shared-utils 8.17.7 → 8.17.8

package/dist/allocations.d.ts

@@ -0,0 +1,18 @@
+import type { AssetAllocation } from '@cranberry-money/shared-types';
+/**
+ * Validates if allocation percentages sum to 100%
+ * Allows for small floating point errors (e.g., 99.99 or 100.01)
+ *
+ * @param allocations - Array of asset allocations to validate
+ * @returns true if allocations sum to approximately 100%, false otherwise
+ *
+ * @example
+ * const allocations = [
+ *   { percentage: '50.00' },
+ *   { percentage: '30.00' },
+ *   { percentage: '20.00' }
+ * ];
+ * validateAllocations(allocations); // returns true
+ */
+export declare const validateAllocations: (allocations: readonly AssetAllocation[]) => boolean;
+//# sourceMappingURL=allocations.d.ts.map

package/dist/allocations.js

@@ -0,0 +1,20 @@
+/**
+ * Validates if allocation percentages sum to 100%
+ * Allows for small floating point errors (e.g., 99.99 or 100.01)
+ *
+ * @param allocations - Array of asset allocations to validate
+ * @returns true if allocations sum to approximately 100%, false otherwise
+ *
+ * @example
+ * const allocations = [
+ *   { percentage: '50.00' },
+ *   { percentage: '30.00' },
+ *   { percentage: '20.00' }
+ * ];
+ * validateAllocations(allocations); // returns true
+ */
+export const validateAllocations = (allocations) => {
+    const totalPercentage = allocations.reduce((sum, allocation) => sum + parseFloat(allocation.percentage), 0);
+    // Allow for small floating point errors (e.g., 99.99 or 100.01)
+    return Math.abs(totalPercentage - 100) < 0.01;
+};

package/dist/cash-account.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,81 @@
+/**
+ * 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;
+//# sourceMappingURL=collections.d.ts.map

package/dist/collections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../src/collections.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAMxE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,CAAC,EAAE,CAM7F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,EAAE,CAE3F;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,GAAG,SAAS,CAE5F;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAMjG;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAE1F;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAazF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAYhG;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAEhG;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAE3F"}

package/dist/collections.js

@@ -0,0 +1,127 @@
+/**
+ * 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

@@ -0,0 +1,108 @@
+/**
+ * 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;
+//# sourceMappingURL=country.d.ts.map

package/dist/country.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"country.d.ts","sourceRoot":"","sources":["../src/country.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,WAAW,EAAE,WAAW,SAAS,CAAC,EAAE,KAAG,CAAC,EAErF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,WAAW,EAAE,WAAW,SAAS,CAAC,EAAE,EAAE,YAAY,MAAM,KAAG,CAAC,EAE3G,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,WAAW,EAAE,WAAW,SAAS,CAAC,EAAE,KAAG,CAAC,EAE1F,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,WAAW,EAAE,WAAW,SAAS,CAAC,EAAE,EAAE,MAAM,MAAM,KAAG,CAAC,GAAG,SAEpG,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,WAAW,EAAE,WAAW,SAAS,CAAC,EAAE,EAAE,MAAM,MAAM,KAAG,CAAC,GAAG,SAEpG,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,WAAW,EAAE,WAAW,SAAS,CAAC,EAAE,KAAG,MAAM,EAEtF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS,WAAW,EAAE,WAAW,SAAS,CAAC,EAAE,KAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAE/G,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,WAAW,EAAE,SAAS,CAAC,KAAG,MAE7E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,WAAW,EAAE,SAAS,CAAC,KAAG,OAEtE,CAAC"}

package/dist/country.js

@@ -0,0 +1,116 @@
+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;
+};

package/dist/currency.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Currency formatting utility functions and constants
+ *
+ * This module provides pure functions for formatting currency values,
+ * parsing currency inputs, and working with different currency formats.
+ */
+/**
+ * Number formatting options for currency display
+ */
+export declare const NUMBER_FORMAT_OPTIONS_CURRENCY: {
+    readonly style: "currency";
+    readonly minimumFractionDigits: 2;
+    readonly maximumFractionDigits: 2;
+};
+/**
+ * Number formatting options for currency with explicit sign display
+ */
+export declare const NUMBER_FORMAT_OPTIONS_CURRENCY_SIGNED: {
+    readonly signDisplay: "always";
+    readonly style: "currency";
+    readonly minimumFractionDigits: 2;
+    readonly maximumFractionDigits: 2;
+};
+/**
+ * Formats a number as currency with commas and 2 decimal places
+ *
+ * @param value - Number or string value to format
+ * @returns Formatted currency string without currency symbol
+ *
+ * @example
+ * ```typescript
+ * formatCurrency(1234.5) // '1,234.50'
+ * formatCurrency('1234.5') // '1,234.50'
+ * formatCurrency(0) // '0.00'
+ * ```
+ */
+export declare function formatCurrency(value: number | string): string;
+/**
+ * Parses a currency string input into a number
+ *
+ * @param value - Currency string to parse
+ * @returns Parsed number value (or 0 if invalid)
+ *
+ * @example
+ * ```typescript
+ * parseCurrencyInput('$1,234.56') // 1234.56
+ * parseCurrencyInput('1234.567') // 1234.56
+ * parseCurrencyInput('abc') // 0
+ * ```
+ */
+export declare function parseCurrencyInput(value: string): number;
+/**
+ * Formats a number as currency with specific currency code and locale
+ *
+ * @param value - Number to format
+ * @param currencyCode - ISO 4217 currency code (default: DEFAULT_CURRENCY)
+ * @param locale - Locale for formatting (default: 'en-AU')
+ * @param minimumFractionDigits - Minimum decimal places (default: 0)
+ * @param maximumFractionDigits - Maximum decimal places (default: 0)
+ * @returns Formatted currency string
+ *
+ * @example
+ * ```typescript
+ * formatCurrencyWithCode(1234.5) // 'A$1,235'
+ * formatCurrencyWithCode(1234.5, 'USD', 'en-US') // '$1,235'
+ * formatCurrencyWithCode(1234.56, 'AUD', 'en-AU', 2, 2) // 'A$1,234.56'
+ * ```
+ */
+export declare function formatCurrencyWithCode(value: number, currencyCode?: string, locale?: string, minimumFractionDigits?: number, maximumFractionDigits?: number): string;
+/**
+ * Convenience function to format currency with the default currency (AUD)
+ *
+ * @param value - Number to format
+ * @param minimumFractionDigits - Minimum decimal places (default: 0)
+ * @param maximumFractionDigits - Maximum decimal places (default: 0)
+ * @returns Formatted currency string with default currency
+ *
+ * @example
+ * ```typescript
+ * formatDefaultCurrency(1234.5) // 'A$1,235'
+ * formatDefaultCurrency(1234.56, 2, 2) // 'A$1,234.56'
+ * ```
+ */
+export declare function formatDefaultCurrency(value: number, minimumFractionDigits?: number, maximumFractionDigits?: number): string;
+/**
+ * Formats a number for displaying share quantities (no decimals)
+ *
+ * @param shares - Number of shares to format
+ * @param locale - Locale for formatting (default: 'en-AU')
+ * @returns Formatted shares string with commas as thousands separators
+ *
+ * @example
+ * ```typescript
+ * formatShares(1234) // '1,234'
+ * formatShares(1234567) // '1,234,567'
+ * ```
+ */
+export declare function formatShares(shares: number, locale?: string): string;
+//# sourceMappingURL=currency.d.ts.map