@cranberry-money/shared-utils 8.19.0 → 8.19.1

package/dist/portfolio.js

@@ -1,87 +0,0 @@
-/**
- * Portfolio calculation and formatting utilities
- *
- * This module provides pure functions for portfolio value calculations,
- * allocations, and formatting. All functions handle string or number inputs
- * for flexibility with API responses.
- */
-import { LOCALE_AUSTRALIA, DEFAULT_NUMERIC_ZERO, DEFAULT_EMPTY_STRING, CURRENCY_AUD, } from '@cranberry-money/shared-constants';
-import { NUMBER_FORMAT_OPTIONS_CURRENCY } from './currency';
-/**
- * Formats a portfolio value as currency with AUD
- *
- * @param value - Portfolio value as string or number
- * @returns Formatted currency string with AUD symbol
- *
- * @example
- * ```typescript
- * formatPortfolioValue(12345.67) // 'A$12,345.67'
- * formatPortfolioValue('12345.67') // 'A$12,345.67'
- * ```
- */
-export function formatPortfolioValue(value) {
-    const numValue = typeof value === 'string' ? parseFloat(value) : value;
-    return new Intl.NumberFormat(LOCALE_AUSTRALIA, {
-        ...NUMBER_FORMAT_OPTIONS_CURRENCY,
-        currency: CURRENCY_AUD,
-    }).format(numValue);
-}
-/**
- * Calculates total portfolio value from market value and cash balance
- *
- * @param marketValue - Market value of holdings
- * @param cashBalance - Cash balance in portfolio
- * @returns Total portfolio value as number
- *
- * @example
- * ```typescript
- * calculateTotalValue(10000, 5000) // 15000
- * calculateTotalValue('10000', '5000') // 15000
- * calculateTotalValue('10000.50', 5000.25) // 15000.75
- * ```
- */
-export function calculateTotalValue(marketValue, cashBalance) {
-    const market = typeof marketValue === 'string' ? parseFloat(marketValue || DEFAULT_EMPTY_STRING) : marketValue;
-    const cash = typeof cashBalance === 'string' ? parseFloat(cashBalance || DEFAULT_EMPTY_STRING) : cashBalance;
-    return market + cash;
-}
-/**
- * Calculates market allocation percentage in portfolio
- *
- * @param marketValue - Market value of holdings
- * @param totalValue - Total portfolio value
- * @returns Market allocation percentage (0-100)
- *
- * @example
- * ```typescript
- * getMarketAllocation(7500, 10000) // 75
- * getMarketAllocation('7500', '10000') // 75
- * getMarketAllocation(0, 10000) // 0
- * getMarketAllocation(100, 0) // 0 (prevents division by zero)
- * ```
- */
-export function getMarketAllocation(marketValue, totalValue) {
-    const market = typeof marketValue === 'string' ? parseFloat(marketValue || DEFAULT_EMPTY_STRING) : marketValue;
-    const total = typeof totalValue === 'string' ? parseFloat(totalValue || DEFAULT_EMPTY_STRING) : totalValue;
-    return total > DEFAULT_NUMERIC_ZERO ? (market / total) * 100 : DEFAULT_NUMERIC_ZERO;
-}
-/**
- * Calculates cash allocation percentage in portfolio
- *
- * @param cashBalance - Cash balance in portfolio
- * @param totalValue - Total portfolio value
- * @returns Cash allocation percentage (0-100)
- *
- * @example
- * ```typescript
- * getCashAllocation(2500, 10000) // 25
- * getCashAllocation('2500', '10000') // 25
- * getCashAllocation(0, 10000) // 0
- * getCashAllocation(100, 0) // 0 (prevents division by zero)
- * ```
- */
-export function getCashAllocation(cashBalance, totalValue) {
-    const cash = typeof cashBalance === 'string' ? parseFloat(cashBalance || DEFAULT_EMPTY_STRING) : cashBalance;
-    const total = typeof totalValue === 'string' ? parseFloat(totalValue || DEFAULT_EMPTY_STRING) : totalValue;
-    return total > DEFAULT_NUMERIC_ZERO ? (cash / total) * 100 : DEFAULT_NUMERIC_ZERO;
-}

package/dist/sector.d.ts

@@ -1,123 +0,0 @@
-export interface BaseSector {
-    readonly uuid: string;
-    readonly name: string;
-}
-export type { SortDirection } from './stock-exchange';
-/**
- * Sort sectors by name
- *
- * @param sectors - List of sectors
- * @param direction - Sort direction ('asc' or 'desc')
- * @returns New sorted array of sectors
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' }
- * ];
- * sortSectorsByName(sectors); // returns [Healthcare, Technology]
- * sortSectorsByName(sectors, 'desc'); // returns [Technology, Healthcare]
- */
-export declare const sortSectorsByName: <T extends BaseSector>(sectors: readonly T[], direction?: "asc" | "desc") => T[];
-/**
- * Filter sectors by name (case-insensitive search)
- *
- * @param sectors - List of sectors
- * @param searchTerm - Search term to filter by
- * @returns Filtered array of sectors
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' },
- *   { uuid: '3', name: 'Financial Services' }
- * ];
- * filterSectorsByName(sectors, 'tech'); // returns [Technology]
- * filterSectorsByName(sectors, 'care'); // returns [Healthcare]
- */
-export declare const filterSectorsByName: <T extends BaseSector>(sectors: readonly T[], searchTerm: string) => T[];
-/**
- * Find sector by exact name match
- *
- * @param sectors - List of sectors
- * @param name - Exact name to search for
- * @returns The sector if found, undefined otherwise
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' }
- * ];
- * findSectorByName(sectors, 'Technology'); // returns Technology sector
- * findSectorByName(sectors, 'Tech'); // returns undefined
- */
-export declare const findSectorByName: <T extends BaseSector>(sectors: readonly T[], name: string) => T | undefined;
-/**
- * Get sorted list of sector names
- *
- * @param sectors - List of sectors
- * @returns Sorted array of sector names
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' },
- *   { uuid: '3', name: 'Energy' }
- * ];
- * getSectorNames(sectors); // returns ['Energy', 'Healthcare', 'Technology']
- */
-export declare const getSectorNames: <T extends BaseSector>(sectors: readonly T[]) => string[];
-/**
- * Group sectors alphabetically by first letter
- *
- * @param sectors - List of sectors
- * @returns Object with first letters as keys and sectors as values
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' },
- *   { uuid: '3', name: 'Energy' },
- *   { uuid: '4', name: 'Telecommunications' }
- * ];
- * groupSectorsAlphabetically(sectors);
- * // returns {
- * //   'E': [Energy],
- * //   'H': [Healthcare],
- * //   'T': [Technology, Telecommunications]
- * // }
- */
-export declare const groupSectorsAlphabetically: <T extends BaseSector>(sectors: readonly T[]) => Record<string, T[]>;
-/**
- * Check if a sector name exists in the list
- *
- * @param sectors - List of sectors
- * @param sectorName - Name to check for existence
- * @returns True if sector exists, false otherwise
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' }
- * ];
- * sectorExists(sectors, 'Technology'); // returns true
- * sectorExists(sectors, 'Manufacturing'); // returns false
- */
-export declare const sectorExists: <T extends BaseSector>(sectors: readonly T[], sectorName: string) => boolean;
-/**
- * Get sectors by partial name match (fuzzy search)
- *
- * @param sectors - List of sectors
- * @param partialName - Partial name to search for
- * @returns Array of matching sectors
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Biotechnology' },
- *   { uuid: '3', name: 'Healthcare Technology' }
- * ];
- * findSectorsByPartialName(sectors, 'tech');
- * // returns [Technology, Biotechnology, Healthcare Technology]
- */
-export declare const findSectorsByPartialName: <T extends BaseSector>(sectors: readonly T[], partialName: string) => T[];

package/dist/sector.js

@@ -1,134 +0,0 @@
-import { sortByStringField, filterByTextSearch, findByStringField, extractAndSortField, groupByFirstLetter, } from './collections';
-/**
- * Sort sectors by name
- *
- * @param sectors - List of sectors
- * @param direction - Sort direction ('asc' or 'desc')
- * @returns New sorted array of sectors
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' }
- * ];
- * sortSectorsByName(sectors); // returns [Healthcare, Technology]
- * sortSectorsByName(sectors, 'desc'); // returns [Technology, Healthcare]
- */
-export const sortSectorsByName = (sectors, direction = 'asc') => {
-    const sorted = sortByStringField([...sectors], 'name');
-    return direction === 'asc' ? sorted : sorted.reverse();
-};
-/**
- * Filter sectors by name (case-insensitive search)
- *
- * @param sectors - List of sectors
- * @param searchTerm - Search term to filter by
- * @returns Filtered array of sectors
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' },
- *   { uuid: '3', name: 'Financial Services' }
- * ];
- * filterSectorsByName(sectors, 'tech'); // returns [Technology]
- * filterSectorsByName(sectors, 'care'); // returns [Healthcare]
- */
-export const filterSectorsByName = (sectors, searchTerm) => {
-    return filterByTextSearch([...sectors], 'name', searchTerm);
-};
-/**
- * Find sector by exact name match
- *
- * @param sectors - List of sectors
- * @param name - Exact name to search for
- * @returns The sector if found, undefined otherwise
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' }
- * ];
- * findSectorByName(sectors, 'Technology'); // returns Technology sector
- * findSectorByName(sectors, 'Tech'); // returns undefined
- */
-export const findSectorByName = (sectors, name) => {
-    return findByStringField([...sectors], 'name', name);
-};
-/**
- * Get sorted list of sector names
- *
- * @param sectors - List of sectors
- * @returns Sorted array of sector names
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' },
- *   { uuid: '3', name: 'Energy' }
- * ];
- * getSectorNames(sectors); // returns ['Energy', 'Healthcare', 'Technology']
- */
-export const getSectorNames = (sectors) => {
-    return extractAndSortField([...sectors], 'name');
-};
-/**
- * Group sectors alphabetically by first letter
- *
- * @param sectors - List of sectors
- * @returns Object with first letters as keys and sectors as values
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' },
- *   { uuid: '3', name: 'Energy' },
- *   { uuid: '4', name: 'Telecommunications' }
- * ];
- * groupSectorsAlphabetically(sectors);
- * // returns {
- * //   'E': [Energy],
- * //   'H': [Healthcare],
- * //   'T': [Technology, Telecommunications]
- * // }
- */
-export const groupSectorsAlphabetically = (sectors) => {
-    return groupByFirstLetter([...sectors], 'name');
-};
-/**
- * Check if a sector name exists in the list
- *
- * @param sectors - List of sectors
- * @param sectorName - Name to check for existence
- * @returns True if sector exists, false otherwise
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Healthcare' }
- * ];
- * sectorExists(sectors, 'Technology'); // returns true
- * sectorExists(sectors, 'Manufacturing'); // returns false
- */
-export const sectorExists = (sectors, sectorName) => {
-    return findByStringField([...sectors], 'name', sectorName) !== undefined;
-};
-/**
- * Get sectors by partial name match (fuzzy search)
- *
- * @param sectors - List of sectors
- * @param partialName - Partial name to search for
- * @returns Array of matching sectors
- *
- * @example
- * const sectors = [
- *   { uuid: '1', name: 'Technology' },
- *   { uuid: '2', name: 'Biotechnology' },
- *   { uuid: '3', name: 'Healthcare Technology' }
- * ];
- * findSectorsByPartialName(sectors, 'tech');
- * // returns [Technology, Biotechnology, Healthcare Technology]
- */
-export const findSectorsByPartialName = (sectors, partialName) => {
-    return filterByTextSearch([...sectors], 'name', partialName);
-};

package/dist/stock-exchange.d.ts

@@ -1,88 +0,0 @@
-export interface BaseCountry {
-    readonly uuid: string;
-    readonly code: string;
-    readonly name?: string;
-}
-export interface BaseStockExchange {
-    readonly uuid: string;
-    readonly name: string;
-    readonly shortName: string;
-    readonly country?: BaseCountry | null;
-}
-export type SortDirection = 'asc' | 'desc';
-/**
- * Extract unique countries from stock exchanges
- *
- * @param exchanges - List of stock exchanges
- * @returns Array of unique countries
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '2', name: 'NASDAQ', shortName: 'NASDAQ', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '3', name: 'TSX', shortName: 'TSX', country: { uuid: 'ca', code: 'CA' } }
- * ];
- * getCountriesFromExchanges(exchanges); // returns [{ uuid: 'us', code: 'US' }, { uuid: 'ca', code: 'CA' }]
- */
-export declare const getCountriesFromExchanges: <T extends BaseStockExchange>(exchanges: readonly T[]) => BaseCountry[];
-/**
- * Group stock exchanges by country code
- *
- * @param exchanges - List of stock exchanges
- * @returns Object with country codes as keys and exchanges as values
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '2', name: 'TSX', shortName: 'TSX', country: { uuid: 'ca', code: 'CA' } }
- * ];
- * groupExchangesByCountry(exchanges);
- * // returns { 'US': [NYSE exchange], 'CA': [TSX exchange], 'Unknown': [] }
- */
-export declare const groupExchangesByCountry: <T extends BaseStockExchange>(exchanges: readonly T[]) => Record<string, T[]>;
-/**
- * Find stock exchange by short name
- *
- * @param exchanges - List of stock exchanges
- * @param shortName - Short name to search for
- * @returns The exchange if found, undefined otherwise
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'New York Stock Exchange', shortName: 'NYSE' },
- *   { uuid: '2', name: 'NASDAQ', shortName: 'NASDAQ' }
- * ];
- * findExchangeByShortName(exchanges, 'NYSE'); // returns NYSE exchange
- */
-export declare const findExchangeByShortName: <T extends BaseStockExchange>(exchanges: readonly T[], shortName: string) => T | undefined;
-/**
- * Sort stock exchanges by name
- *
- * @param exchanges - List of stock exchanges
- * @param direction - Sort direction ('asc' or 'desc')
- * @returns New sorted array of exchanges
- *
- * @example
- * const exchanges = [
- *   { uuid: '2', name: 'NASDAQ', shortName: 'NASDAQ' },
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE' }
- * ];
- * sortExchangesByName(exchanges); // returns [NASDAQ, NYSE] (alphabetical)
- * sortExchangesByName(exchanges, 'desc'); // returns [NYSE, NASDAQ] (reverse)
- */
-export declare const sortExchangesByName: <T extends BaseStockExchange>(exchanges: readonly T[], direction?: SortDirection) => T[];
-/**
- * Filter stock exchanges by country code
- *
- * @param exchanges - List of stock exchanges
- * @param countryCode - Country code to filter by
- * @returns Array of exchanges in the specified country
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '2', name: 'TSX', shortName: 'TSX', country: { uuid: 'ca', code: 'CA' } }
- * ];
- * filterExchangesByCountry(exchanges, 'US'); // returns [NYSE exchange]
- */
-export declare const filterExchangesByCountry: <T extends BaseStockExchange>(exchanges: readonly T[], countryCode: string) => T[];

package/dist/stock-exchange.js

@@ -1,101 +0,0 @@
-import { sortByStringField, findByStringField } from './collections';
-/**
- * Extract unique countries from stock exchanges
- *
- * @param exchanges - List of stock exchanges
- * @returns Array of unique countries
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '2', name: 'NASDAQ', shortName: 'NASDAQ', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '3', name: 'TSX', shortName: 'TSX', country: { uuid: 'ca', code: 'CA' } }
- * ];
- * getCountriesFromExchanges(exchanges); // returns [{ uuid: 'us', code: 'US' }, { uuid: 'ca', code: 'CA' }]
- */
-export const getCountriesFromExchanges = (exchanges) => {
-    const countriesMap = new Map();
-    exchanges.forEach(exchange => {
-        if (exchange.country) {
-            countriesMap.set(exchange.country.uuid, exchange.country);
-        }
-    });
-    return Array.from(countriesMap.values());
-};
-/**
- * Group stock exchanges by country code
- *
- * @param exchanges - List of stock exchanges
- * @returns Object with country codes as keys and exchanges as values
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '2', name: 'TSX', shortName: 'TSX', country: { uuid: 'ca', code: 'CA' } }
- * ];
- * groupExchangesByCountry(exchanges);
- * // returns { 'US': [NYSE exchange], 'CA': [TSX exchange], 'Unknown': [] }
- */
-export const groupExchangesByCountry = (exchanges) => {
-    return exchanges.reduce((groups, exchange) => {
-        const countryCode = exchange.country?.code || 'Unknown';
-        if (!groups[countryCode]) {
-            groups[countryCode] = [];
-        }
-        groups[countryCode].push(exchange);
-        return groups;
-    }, {});
-};
-/**
- * Find stock exchange by short name
- *
- * @param exchanges - List of stock exchanges
- * @param shortName - Short name to search for
- * @returns The exchange if found, undefined otherwise
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'New York Stock Exchange', shortName: 'NYSE' },
- *   { uuid: '2', name: 'NASDAQ', shortName: 'NASDAQ' }
- * ];
- * findExchangeByShortName(exchanges, 'NYSE'); // returns NYSE exchange
- */
-export const findExchangeByShortName = (exchanges, shortName) => {
-    return findByStringField([...exchanges], 'shortName', shortName);
-};
-/**
- * Sort stock exchanges by name
- *
- * @param exchanges - List of stock exchanges
- * @param direction - Sort direction ('asc' or 'desc')
- * @returns New sorted array of exchanges
- *
- * @example
- * const exchanges = [
- *   { uuid: '2', name: 'NASDAQ', shortName: 'NASDAQ' },
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE' }
- * ];
- * sortExchangesByName(exchanges); // returns [NASDAQ, NYSE] (alphabetical)
- * sortExchangesByName(exchanges, 'desc'); // returns [NYSE, NASDAQ] (reverse)
- */
-export const sortExchangesByName = (exchanges, direction = 'asc') => {
-    const sorted = sortByStringField([...exchanges], 'name');
-    return direction === 'asc' ? sorted : sorted.reverse();
-};
-/**
- * Filter stock exchanges by country code
- *
- * @param exchanges - List of stock exchanges
- * @param countryCode - Country code to filter by
- * @returns Array of exchanges in the specified country
- *
- * @example
- * const exchanges = [
- *   { uuid: '1', name: 'NYSE', shortName: 'NYSE', country: { uuid: 'us', code: 'US' } },
- *   { uuid: '2', name: 'TSX', shortName: 'TSX', country: { uuid: 'ca', code: 'CA' } }
- * ];
- * filterExchangesByCountry(exchanges, 'US'); // returns [NYSE exchange]
- */
-export const filterExchangesByCountry = (exchanges, countryCode) => {
-    return exchanges.filter(exchange => exchange.country?.code === countryCode);
-};

package/dist/tax-residency.d.ts

@@ -1,66 +0,0 @@
-export interface BaseTaxResidency {
-    readonly country: string;
-    readonly isPrimary: boolean;
-    readonly isExempted: boolean;
-}
-/**
- * Find the primary tax residency from a list
- *
- * @param taxResidencies - List of tax residencies
- * @returns The primary tax residency if found, undefined otherwise
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: false, isExempted: false },
- *   { country: 'CA', isPrimary: true, isExempted: false }
- * ];
- * findPrimaryTaxResidency(residencies); // returns CA residency
- */
-export declare const findPrimaryTaxResidency: <T extends BaseTaxResidency>(taxResidencies: readonly T[]) => T | undefined;
-/**
- * Filter tax residencies by country code
- *
- * @param taxResidencies - List of tax residencies
- * @param countryCode - Country code to filter by
- * @returns List of tax residencies for the specified country
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: true, isExempted: false },
- *   { country: 'US', isPrimary: false, isExempted: true },
- *   { country: 'CA', isPrimary: false, isExempted: false }
- * ];
- * filterTaxResidenciesByCountry(residencies, 'US'); // returns 2 US residencies
- */
-export declare const filterTaxResidenciesByCountry: <T extends BaseTaxResidency>(taxResidencies: readonly T[], countryCode: string) => T[];
-/**
- * Check if user has tax residency in a specific country
- *
- * @param taxResidencies - List of tax residencies
- * @param countryCode - Country code to check
- * @returns True if user has residency in the country, false otherwise
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: true, isExempted: false },
- *   { country: 'CA', isPrimary: false, isExempted: false }
- * ];
- * hasTaxResidencyInCountry(residencies, 'US'); // returns true
- * hasTaxResidencyInCountry(residencies, 'UK'); // returns false
- */
-export declare const hasTaxResidencyInCountry: <T extends BaseTaxResidency>(taxResidencies: readonly T[], countryCode: string) => boolean;
-/**
- * Get all non-exempted tax residencies
- *
- * @param taxResidencies - List of tax residencies
- * @returns List of non-exempted tax residencies
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: true, isExempted: false },
- *   { country: 'CA', isPrimary: false, isExempted: true },
- *   { country: 'UK', isPrimary: false, isExempted: false }
- * ];
- * getNonExemptedTaxResidencies(residencies); // returns US and UK residencies
- */
-export declare const getNonExemptedTaxResidencies: <T extends BaseTaxResidency>(taxResidencies: readonly T[]) => T[];

package/dist/tax-residency.js

@@ -1,70 +0,0 @@
-import { findByField, hasItemWithFieldValue, filterByBooleanField } from './collections';
-/**
- * Find the primary tax residency from a list
- *
- * @param taxResidencies - List of tax residencies
- * @returns The primary tax residency if found, undefined otherwise
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: false, isExempted: false },
- *   { country: 'CA', isPrimary: true, isExempted: false }
- * ];
- * findPrimaryTaxResidency(residencies); // returns CA residency
- */
-export const findPrimaryTaxResidency = (taxResidencies) => {
-    return findByField([...taxResidencies], 'isPrimary', true);
-};
-/**
- * Filter tax residencies by country code
- *
- * @param taxResidencies - List of tax residencies
- * @param countryCode - Country code to filter by
- * @returns List of tax residencies for the specified country
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: true, isExempted: false },
- *   { country: 'US', isPrimary: false, isExempted: true },
- *   { country: 'CA', isPrimary: false, isExempted: false }
- * ];
- * filterTaxResidenciesByCountry(residencies, 'US'); // returns 2 US residencies
- */
-export const filterTaxResidenciesByCountry = (taxResidencies, countryCode) => {
-    return taxResidencies.filter(residency => residency.country === countryCode);
-};
-/**
- * Check if user has tax residency in a specific country
- *
- * @param taxResidencies - List of tax residencies
- * @param countryCode - Country code to check
- * @returns True if user has residency in the country, false otherwise
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: true, isExempted: false },
- *   { country: 'CA', isPrimary: false, isExempted: false }
- * ];
- * hasTaxResidencyInCountry(residencies, 'US'); // returns true
- * hasTaxResidencyInCountry(residencies, 'UK'); // returns false
- */
-export const hasTaxResidencyInCountry = (taxResidencies, countryCode) => {
-    return hasItemWithFieldValue([...taxResidencies], 'country', countryCode);
-};
-/**
- * Get all non-exempted tax residencies
- *
- * @param taxResidencies - List of tax residencies
- * @returns List of non-exempted tax residencies
- *
- * @example
- * const residencies = [
- *   { country: 'US', isPrimary: true, isExempted: false },
- *   { country: 'CA', isPrimary: false, isExempted: true },
- *   { country: 'UK', isPrimary: false, isExempted: false }
- * ];
- * getNonExemptedTaxResidencies(residencies); // returns US and UK residencies
- */
-export const getNonExemptedTaxResidencies = (taxResidencies) => {
-    return filterByBooleanField([...taxResidencies], 'isExempted', false);
-};