@cranberry-money/shared-utils 8.17.7 → 8.17.9

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.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.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.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.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency.d.ts","sourceRoot":"","sources":["../src/currency.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;CAIjC,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;CAGxC,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAW7D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,YAAY,GAAE,MAAyB,EACvC,MAAM,GAAE,MAAgB,EACxB,qBAAqB,GAAE,MAAU,EACjC,qBAAqB,GAAE,MAAU,GAChC,MAAM,CASR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,qBAAqB,GAAE,MAAU,EACjC,qBAAqB,GAAE,MAAU,GAChC,MAAM,CAER;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAgB,GAAG,MAAM,CAK7E"}

package/dist/currency.js

@@ -0,0 +1,128 @@
+/**
+ * Currency formatting utility functions and constants
+ *
+ * This module provides pure functions for formatting currency values,
+ * parsing currency inputs, and working with different currency formats.
+ */
+import { DEFAULT_CURRENCY, DECIMAL_PLACES } from '@cranberry-money/shared-constants';
+/**
+ * Number formatting options for currency display
+ */
+export const NUMBER_FORMAT_OPTIONS_CURRENCY = {
+    style: 'currency',
+    minimumFractionDigits: DECIMAL_PLACES,
+    maximumFractionDigits: DECIMAL_PLACES,
+};
+/**
+ * Number formatting options for currency with explicit sign display
+ */
+export const NUMBER_FORMAT_OPTIONS_CURRENCY_SIGNED = {
+    ...NUMBER_FORMAT_OPTIONS_CURRENCY,
+    signDisplay: 'always',
+};
+/**
+ * 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 function formatCurrency(value) {
+    if (!value && value !== 0)
+        return '';
+    const numValue = typeof value === 'string' ? parseFloat(value) : value;
+    if (isNaN(numValue))
+        return '';
+    return numValue.toLocaleString('en-AU', {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+}
+/**
+ * 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 function parseCurrencyInput(value) {
+    const cleanValue = value.replace(/[^0-9.]/g, '');
+    const parts = cleanValue.split('.');
+    const formattedValue = parts[0] + (parts.length > 1 && parts[1] ? '.' + parts[1].slice(0, 2) : '');
+    return parseFloat(formattedValue) || 0;
+}
+/**
+ * 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 function formatCurrencyWithCode(value, currencyCode = DEFAULT_CURRENCY, locale = 'en-AU', minimumFractionDigits = 0, maximumFractionDigits = 0) {
+    if (value == null || isNaN(value))
+        return '';
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency: currencyCode,
+        minimumFractionDigits,
+        maximumFractionDigits,
+    }).format(value);
+}
+/**
+ * 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 function formatDefaultCurrency(value, minimumFractionDigits = 0, maximumFractionDigits = 0) {
+    return formatCurrencyWithCode(value, DEFAULT_CURRENCY, 'en-AU', minimumFractionDigits, maximumFractionDigits);
+}
+/**
+ * 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 function formatShares(shares, locale = 'en-AU') {
+    return new Intl.NumberFormat(locale, {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 0,
+    }).format(shares);
+}

package/dist/dashboard.js

@@ -0,0 +1,121 @@
+import { DEFAULT_CURRENCY } from '@cranberry-money/shared-constants';
+import { getChartColor } from '@cranberry-money/shared-constants';
+import { formatCurrencyWithCode } from './currency';
+import { calculateHoldingAllocations } from './holdings';
+/**
+ * Processes allocation and holding data for dashboard display
+ * Merges target allocations with actual holdings data
+ *
+ * @param allocations - Target asset allocations
+ * @param holdings - Actual asset holdings
+ * @returns Array of display items sorted by target/actual percentage
+ *
+ * @example
+ * const allocations = [{ instrument: '123', percentage: '50.00', ... }];
+ * const holdings = [{ instrument: { uuid: '123' }, quantity: 100, ... }];
+ * processAllocationData(allocations, holdings);
+ */
+export const processAllocationData = (allocations, holdings) => {
+    const actualAllocations = calculateHoldingAllocations(holdings);
+    const instrumentMap = new Map();
+    // Process target allocations
+    allocations.forEach(allocation => {
+        instrumentMap.set(allocation.instrument, {
+            symbol: allocation.instrumentSymbol,
+            name: allocation.instrumentName,
+            targetPercentage: parseFloat(allocation.percentage),
+        });
+    });
+    // Process actual holdings
+    holdings.forEach(holding => {
+        const existing = instrumentMap.get(holding.instrument.uuid);
+        const currentPrice = parseFloat(holding.instrument.currentPrice || '0');
+        const value = holding.quantity * currentPrice;
+        instrumentMap.set(holding.instrument.uuid, {
+            symbol: holding.instrumentSymbol,
+            name: holding.instrumentName,
+            targetPercentage: existing?.targetPercentage,
+            actualPercentage: actualAllocations[holding.instrument.uuid] || 0,
+            quantity: holding.quantity,
+            currentPrice,
+            value,
+        });
+    });
+    // Convert to display items
+    const items = [];
+    let colorIndex = 0;
+    instrumentMap.forEach((data, instrumentUuid) => {
+        items.push({
+            instrumentUuid,
+            symbol: data.symbol,
+            name: data.name,
+            targetPercentage: data.targetPercentage,
+            actualPercentage: data.actualPercentage,
+            quantity: data.quantity,
+            currentPrice: data.currentPrice,
+            value: data.value,
+            color: getChartColor(colorIndex++),
+            hasTarget: data.targetPercentage !== undefined,
+            hasActual: data.actualPercentage !== undefined && data.actualPercentage > 0,
+        });
+    });
+    // Sort by target percentage (highest first), then by actual percentage
+    return items.sort((a, b) => {
+        const aTarget = a.targetPercentage || 0;
+        const bTarget = b.targetPercentage || 0;
+        if (aTarget !== bTarget)
+            return bTarget - aTarget;
+        const aActual = a.actualPercentage || 0;
+        const bActual = b.actualPercentage || 0;
+        return bActual - aActual;
+    });
+};
+/**
+ * Calculates totals from allocation display items
+ *
+ * @param items - Array of allocation display items
+ * @returns Object with total calculations
+ *
+ * @example
+ * const items = [{ targetPercentage: 50, actualPercentage: 45, value: 1000, quantity: 10 }];
+ * calculateTotals(items);
+ * // returns { totalTarget: 50, totalActual: 45, totalValue: 1000, totalQuantity: 10 }
+ */
+export const calculateTotals = (items) => {
+    const totalTarget = items.reduce((sum, item) => sum + (item.targetPercentage || 0), 0);
+    const totalActual = items.reduce((sum, item) => sum + (item.actualPercentage || 0), 0);
+    const totalValue = items.reduce((sum, item) => sum + (item.value || 0), 0);
+    const totalQuantity = items.reduce((sum, item) => sum + (item.quantity || 0), 0);
+    return { totalTarget, totalActual, totalValue, totalQuantity };
+};
+/**
+ * Formats a percentage value for display
+ *
+ * @param value - The percentage value to format
+ * @returns Formatted percentage string
+ *
+ * @example
+ * formatPercentage(45.678); // returns "45.7%"
+ * formatPercentage(undefined); // returns "0.0%"
+ */
+export const formatPercentage = (value) => {
+    if (value === undefined)
+        return '0.0%';
+    return `${value.toFixed(1)}%`;
+};
+/**
+ * Formats currency value for dashboard display
+ *
+ * @param value - The numeric value to format
+ * @param currency - Currency code (defaults to DEFAULT_CURRENCY)
+ * @returns Formatted currency string or "—" for undefined values
+ *
+ * @example
+ * formatDashboardCurrency(1234.56); // returns "$1,234.56"
+ * formatDashboardCurrency(undefined); // returns "—"
+ */
+export const formatDashboardCurrency = (value, currency = DEFAULT_CURRENCY) => {
+    if (value === undefined || value === null)
+        return '—';
+    return formatCurrencyWithCode(value, currency, 'en-AU', 2, 2);
+};

package/dist/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../src/date.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,GAAE,MAAoB,GAAG,MAAM,CAG5F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,MAAgB,GAAG,MAAM,CAMpF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,MAAgB,GAAG,MAAM,CAM/E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,MAAgB,GAAG,MAAM,CAYnF"}

package/dist/date.js

@@ -0,0 +1,91 @@
+/**
+ * Date and time formatting utility functions
+ *
+ * This module provides pure functions for formatting dates and times
+ * in various formats suitable for display in the application.
+ */
+/**
+ * Formats a date string to a localized date
+ *
+ * @param dateString - ISO date string or null
+ * @param fallback - Fallback text when date is null (default: 'No expiry')
+ * @returns Formatted date string
+ *
+ * @example
+ * ```typescript
+ * formatDate('2024-03-15') // '3/15/2024' (in en-US)
+ * formatDate(null) // 'No expiry'
+ * formatDate(null, 'Not set') // 'Not set'
+ * ```
+ */
+export function formatDate(dateString, fallback = 'No expiry') {
+    if (!dateString)
+        return fallback;
+    return new Date(dateString).toLocaleDateString();
+}
+/**
+ * Formats a date string to a short date format (e.g., "Jan 15")
+ *
+ * @param dateString - ISO date string
+ * @param locale - Locale for formatting (default: 'en-AU')
+ * @returns Formatted short date string
+ *
+ * @example
+ * ```typescript
+ * formatShortDate('2024-01-15') // 'Jan 15'
+ * formatShortDate('2024-12-25', 'en-US') // 'Dec 25'
+ * ```
+ */
+export function formatShortDate(dateString, locale = 'en-AU') {
+    const date = new Date(dateString);
+    return date.toLocaleDateString(locale, {
+        month: 'short',
+        day: 'numeric',
+    });
+}
+/**
+ * Formats a date string to a time format (24-hour)
+ *
+ * @param dateString - ISO date string
+ * @param locale - Locale for formatting (default: 'en-AU')
+ * @returns Formatted time string in 24-hour format
+ *
+ * @example
+ * ```typescript
+ * formatTime('2024-01-15T14:30:00') // '14:30'
+ * formatTime('2024-01-15T09:05:00') // '09:05'
+ * ```
+ */
+export function formatTime(dateString, locale = 'en-AU') {
+    return new Date(dateString).toLocaleTimeString(locale, {
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    });
+}
+/**
+ * Formats a date string to a combined short date and time format
+ *
+ * @param dateString - ISO date string
+ * @param locale - Locale for formatting (default: 'en-AU')
+ * @returns Formatted string like "Jan 15 14:30"
+ *
+ * @example
+ * ```typescript
+ * formatDateTime('2024-01-15T14:30:00') // 'Jan 15 14:30'
+ * formatDateTime('2024-12-25T09:00:00', 'en-US') // 'Dec 25 09:00'
+ * ```
+ */
+export function formatDateTime(dateString, locale = 'en-AU') {
+    const date = new Date(dateString);
+    const shortDate = date.toLocaleDateString(locale, {
+        month: 'short',
+        day: 'numeric',
+    });
+    const time = date.toLocaleTimeString(locale, {
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    });
+    return `${shortDate} ${time}`;
+}

package/dist/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GAAI,cAAc,MAAM,EAAE,cAAc,MAAM,KAAG,MAErF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,GAAI,cAAc,MAAM,KAAG,MAgBzD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,MAAM,KAAG,MAErD,CAAC"}