@cranberry-money/shared-utils 8.17.8 → 8.17.9

package/dist/numbers.d.ts

@@ -1,72 +0,0 @@
-/**
- * Number formatting utilities
- * Generic number manipulation and formatting functions
- */
-/**
- * Format a large number with K/M suffixes for display
- * @param quantity - The number to format
- * @param decimals - Number of decimal places (default: 1)
- * @returns Formatted number string with suffix
- * @example
- * formatQuantityWithSuffix(1000) // '1.0K'
- * formatQuantityWithSuffix(1500000) // '1.5M'
- * formatQuantityWithSuffix(999) // '999'
- */
-export declare function formatQuantityWithSuffix(quantity: number, decimals?: number): string;
-/**
- * Format a large number with customizable suffixes
- * @param num - The number to format
- * @param suffixes - Array of suffix configurations (default: standard K, M, B, T)
- * @param decimals - Number of decimal places (default: 1)
- * @returns Formatted number string with suffix
- * @example
- * formatLargeNumber(1500000) // '1.5M'
- * formatLargeNumber(1500000000) // '1.5B'
- */
-export declare function formatLargeNumber(num: number, suffixes?: Array<{
-    threshold: number;
-    suffix: string;
-}>, decimals?: number): string;
-/**
- * Format a number as a percentage
- * @param value - The decimal value to format as percentage
- * @param decimals - Number of decimal places (default: 1)
- * @returns Formatted percentage string
- * @example
- * formatAsPercentage(0.1234) // '12.3%'
- * formatAsPercentage(0.5, 0) // '50%'
- */
-export declare function formatAsPercentage(value: number, decimals?: number): string;
-/**
- * Format a number with thousand separators
- * @param num - The number to format
- * @param separator - The separator character (default: ',')
- * @returns Formatted number string with separators
- * @example
- * formatWithSeparators(1234567) // '1,234,567'
- * formatWithSeparators(1234567, ' ') // '1 234 567'
- */
-export declare function formatWithSeparators(num: number, separator?: string): string;
-/**
- * Round a number to specified decimal places
- * @param num - The number to round
- * @param decimals - Number of decimal places (default: 2)
- * @returns Rounded number
- * @example
- * roundToDecimals(3.14159, 2) // 3.14
- * roundToDecimals(123.456, 0) // 123
- */
-export declare function roundToDecimals(num: number, decimals?: number): number;
-/**
- * Clamp a number between min and max values
- * @param num - The number to clamp
- * @param min - Minimum value
- * @param max - Maximum value
- * @returns Clamped number
- * @example
- * clampNumber(150, 0, 100) // 100
- * clampNumber(-10, 0, 100) // 0
- * clampNumber(50, 0, 100) // 50
- */
-export declare function clampNumber(num: number, min: number, max: number): number;
-//# sourceMappingURL=numbers.d.ts.map

package/dist/portfolio-template.d.ts

@@ -1,57 +0,0 @@
-/**
- * Base interface for allocation objects
- */
-export interface BaseAllocation {
-    readonly percentage: string;
-}
-/**
- * Calculate total allocation from an array of allocations
- *
- * @param allocations - Array of allocation objects with percentage strings
- * @returns Total allocation as a number
- *
- * @example
- * const total = calculateTotalAllocation([
- *   { percentage: '50.5' },
- *   { percentage: '30.0' },
- *   { percentage: '19.5' }
- * ]);
- * // Returns 100.0
- */
-export declare const calculateTotalAllocation: <T extends BaseAllocation>(allocations: readonly T[]) => number;
-/**
- * Validate that allocation percentages sum to approximately 100%
- *
- * @param allocations - Array of allocation objects with percentage strings
- * @param tolerance - Tolerance for percentage validation (default: 0.01)
- * @returns True if allocations sum to approximately 100%
- *
- * @example
- * const isValid = validateAllocationPercentages([
- *   { percentage: '50.0' },
- *   { percentage: '30.0' },
- *   { percentage: '20.0' }
- * ]);
- * // Returns true
- *
- * @example
- * const isValid = validateAllocationPercentages([
- *   { percentage: '50.0' },
- *   { percentage: '30.0' },
- *   { percentage: '15.0' }
- * ]);
- * // Returns false (sums to 95%)
- */
-export declare const validateAllocationPercentages: <T extends BaseAllocation>(allocations: readonly T[], tolerance?: number) => boolean;
-/**
- * Format risk level for display (re-export from formatting utilities)
- *
- * @param riskLevel - Risk level string to format
- * @returns Formatted risk level string
- *
- * @example
- * formatRiskLevelDisplay('HIGH'); // returns 'High'
- * formatRiskLevelDisplay('moderate'); // returns 'Moderate'
- */
-export declare const formatRiskLevelDisplay: (riskLevel: string) => string;
-//# sourceMappingURL=portfolio-template.d.ts.map

package/dist/portfolio-validation.d.ts

@@ -1,42 +0,0 @@
-import type { MessageFieldValidation, BaseFormValidation } from '@cranberry-money/shared-types';
-/**
- * Portfolio selection form validation interface
- */
-export interface PortfolioSelectionValidation extends BaseFormValidation {
-    readonly selectedTemplate: MessageFieldValidation;
-}
-/**
- * Portfolio selection state interface
- */
-export interface PortfolioSelectionState {
-    readonly selectedTemplateUuid: string | null;
-    readonly viewingDetailsForUuid?: string | null;
-}
-/**
- * Validates if a portfolio template is selected
- *
- * @param selectedTemplateUuid - The UUID of the selected template
- * @returns true if a template is selected, false otherwise
- *
- * @example
- * isValidTemplateSelection('123-456'); // returns true
- * isValidTemplateSelection(null); // returns false
- * isValidTemplateSelection(''); // returns false
- */
-export declare const isValidTemplateSelection: (selectedTemplateUuid: string | null) => boolean;
-/**
- * Comprehensive validation for portfolio selection form
- *
- * @param state - The portfolio selection state
- * @returns Validation object with field-level and form-level validity
- *
- * @example
- * const state = { selectedTemplateUuid: '123-456' };
- * validatePortfolioSelection(state);
- * // returns {
- * //   selectedTemplate: { isValid: true, message: '' },
- * //   isFormValid: true
- * // }
- */
-export declare const validatePortfolioSelection: (state: PortfolioSelectionState) => PortfolioSelectionValidation;
-//# sourceMappingURL=portfolio-validation.d.ts.map

package/dist/portfolio.d.ts

@@ -1,68 +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.
- */
-/**
- * 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 declare function formatPortfolioValue(value: string | number): string;
-/**
- * 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 declare function calculateTotalValue(marketValue: string | number, cashBalance: string | number): number;
-/**
- * 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 declare function getMarketAllocation(marketValue: string | number, totalValue: string | number): number;
-/**
- * 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 declare function getCashAllocation(cashBalance: string | number, totalValue: string | number): number;
-//# sourceMappingURL=portfolio.d.ts.map

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/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/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/text.d.ts

@@ -1,22 +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 declare function truncateText(text: string, maxLength?: number): string;
-//# sourceMappingURL=text.d.ts.map