@cranberry-money/shared-utils 8.17.5 → 8.17.7

package/dist/sector.d.ts

@@ -1,124 +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[];
-//# sourceMappingURL=sector.d.ts.map

package/dist/sector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sector.d.ts","sourceRoot":"","sources":["../src/sector.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAGD,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,UAAU,EACpD,SAAS,SAAS,CAAC,EAAE,EACrB,YAAW,KAAK,GAAG,MAAc,KAChC,CAAC,EAGH,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,SAAS,CAAC,EAAE,EAAE,YAAY,MAAM,KAAG,CAAC,EAEtG,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,SAAS,CAAC,EAAE,EAAE,MAAM,MAAM,KAAG,CAAC,GAAG,SAEhG,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,SAAS,CAAC,EAAE,KAAG,MAAM,EAElF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,SAAS,CAAC,EAAE,KAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAE1G,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,SAAS,CAAC,EAAE,EAAE,YAAY,MAAM,KAAG,OAE9F,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,SAAS,CAAC,EAAE,EAAE,aAAa,MAAM,KAAG,CAAC,EAE5G,CAAC"}

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,89 +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[];
-//# sourceMappingURL=stock-exchange.d.ts.map

package/dist/stock-exchange.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stock-exchange.d.ts","sourceRoot":"","sources":["../src/stock-exchange.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CACvC;AAGD,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,iBAAiB,EAAE,WAAW,SAAS,CAAC,EAAE,KAAG,WAAW,EAU3G,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,iBAAiB,EAAE,WAAW,SAAS,CAAC,EAAE,KAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAYhH,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,iBAAiB,EACjE,WAAW,SAAS,CAAC,EAAE,EACvB,WAAW,MAAM,KAChB,CAAC,GAAG,SAEN,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,iBAAiB,EAC7D,WAAW,SAAS,CAAC,EAAE,EACvB,YAAW,aAAqB,KAC/B,CAAC,EAGH,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,iBAAiB,EAClE,WAAW,SAAS,CAAC,EAAE,EACvB,aAAa,MAAM,KAClB,CAAC,EAEH,CAAC"}

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,67 +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[];
-//# sourceMappingURL=tax-residency.d.ts.map

package/dist/tax-residency.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tax-residency.d.ts","sourceRoot":"","sources":["../src/tax-residency.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,gBAAgB,EAAE,gBAAgB,SAAS,CAAC,EAAE,KAAG,CAAC,GAAG,SAEtG,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,6BAA6B,GAAI,CAAC,SAAS,gBAAgB,EACtE,gBAAgB,SAAS,CAAC,EAAE,EAC5B,aAAa,MAAM,KAClB,CAAC,EAEH,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,gBAAgB,EACjE,gBAAgB,SAAS,CAAC,EAAE,EAC5B,aAAa,MAAM,KAClB,OAEF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS,gBAAgB,EAAE,gBAAgB,SAAS,CAAC,EAAE,KAAG,CAAC,EAExG,CAAC"}

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);
-};

package/dist/text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../src/text.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAW,GAAG,MAAM,CAGzE"}

package/dist/text.js

@@ -1,25 +0,0 @@
-/**
- * Text manipulation utility functions
- *
- * This module provides pure functions for common text operations
- * such as truncation, formatting, and manipulation.
- */
-/**
- * Truncates text to a specified maximum length and adds ellipsis if needed
- *
- * @param text - The text to truncate
- * @param maxLength - The maximum length of the text (default: 30)
- * @returns The truncated text with ellipsis if it exceeds maxLength
- *
- * @example
- * ```typescript
- * truncateText('This is a very long text', 10) // 'This is a...'
- * truncateText('Short', 10) // 'Short'
- * truncateText('', 10) // ''
- * ```
- */
-export function truncateText(text, maxLength = 30) {
-    if (text.length <= maxLength)
-        return text;
-    return `${text.substring(0, maxLength)}...`;
-}