@joewinke/jatui 0.1.25 → 0.1.26

package/dist/utils/dateFormatters.js

@@ -0,0 +1,199 @@
+/**
+ * Date formatting utilities for consistent date/time display.
+ *
+ * UTC/ISO Timestamp Handling:
+ * Database timestamps are often stored without timezone info (e.g., "2024-11-21 15:30:00").
+ * These utilities normalize timestamps to ensure correct UTC parsing.
+ */
+/**
+ * Normalize a timestamp string to proper ISO 8601 format.
+ * Handles database timestamps that may lack 'T' separator or 'Z' suffix.
+ */
+export function normalizeTimestamp(timestamp) {
+    if (!timestamp)
+        return timestamp;
+    if (timestamp.includes('T')) {
+        if (timestamp.endsWith('Z'))
+            return timestamp;
+        if (/[+-]\d{2}:\d{2}$/.test(timestamp))
+            return timestamp;
+        return timestamp + 'Z';
+    }
+    return timestamp.replace(' ', 'T') + 'Z';
+}
+/**
+ * Parse a potentially non-standard timestamp into a Date object.
+ * Accepts a Date (returned by postgres.js), ISO string, or null/undefined.
+ */
+export function parseTimestamp(timestamp) {
+    if (!timestamp)
+        return null;
+    if (timestamp instanceof Date)
+        return isNaN(timestamp.getTime()) ? null : timestamp;
+    var normalized = normalizeTimestamp(timestamp);
+    var date = new Date(normalized);
+    return isNaN(date.getTime()) ? null : date;
+}
+/**
+ * Format relative time (e.g., "2d", "3mo", "1y").
+ * Compact format suitable for tables and compact UIs.
+ */
+export function formatRelativeTime(dateStr) {
+    if (!dateStr)
+        return '-';
+    var date = parseTimestamp(dateStr);
+    if (!date)
+        return '-';
+    var now = new Date();
+    var diffMs = now.getTime() - date.getTime();
+    var diffMins = Math.floor(diffMs / (1000 * 60));
+    var diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    var diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    var diffWeeks = Math.floor(diffDays / 7);
+    var diffMonths = Math.floor(diffDays / 30);
+    var diffYears = Math.floor(diffDays / 365);
+    if (diffMins < 1)
+        return 'now';
+    if (diffMins < 60)
+        return "".concat(diffMins, "m");
+    if (diffHours < 24)
+        return "".concat(diffHours, "h");
+    if (diffDays < 7)
+        return "".concat(diffDays, "d");
+    if (diffWeeks < 4)
+        return "".concat(diffWeeks, "w");
+    if (diffMonths < 12)
+        return "".concat(diffMonths, "mo");
+    return "".concat(diffYears, "y");
+}
+/**
+ * Format full date and time for tooltips and detailed views.
+ */
+export function formatFullDate(dateStr) {
+    if (!dateStr)
+        return '';
+    var date = parseTimestamp(dateStr);
+    if (!date)
+        return '';
+    return date.toLocaleString('en-US', {
+        month: 'short',
+        day: 'numeric',
+        year: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit'
+    });
+}
+/**
+ * Format short date for compact displays (e.g., date range picker).
+ */
+export function formatShortDate(dateStr) {
+    if (!dateStr)
+        return '';
+    var date = parseTimestamp(dateStr);
+    if (!date)
+        return '';
+    return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+/**
+ * Format last activity time for agent cards.
+ * Shows "Just now", "Xm ago", "Xh ago", or "Xd ago".
+ */
+export function formatLastActivity(timestamp) {
+    if (!timestamp)
+        return 'Never';
+    var date = parseTimestamp(timestamp);
+    if (!date)
+        return 'Never';
+    var now = new Date();
+    var diffMs = now.getTime() - date.getTime();
+    var diffMins = Math.floor(diffMs / 60000);
+    var diffHours = Math.floor(diffMs / 3600000);
+    var diffDays = Math.floor(diffMs / 86400000);
+    if (diffMins < 1)
+        return 'Just now';
+    if (diffMins < 60)
+        return "".concat(diffMins, "m ago");
+    if (diffHours < 24)
+        return "".concat(diffHours, "h ago");
+    return "".concat(diffDays, "d ago");
+}
+/**
+ * Format date for display (simple locale string).
+ */
+export function formatDate(dateString) {
+    if (!dateString)
+        return 'N/A';
+    var date = parseTimestamp(dateString);
+    if (!date)
+        return 'N/A';
+    return date.toLocaleString();
+}
+/**
+ * Get milliseconds since timestamp (for calculations).
+ */
+export function getTimeSinceMs(timestamp) {
+    if (!timestamp)
+        return Infinity;
+    var date = parseTimestamp(timestamp);
+    if (!date)
+        return Infinity;
+    return Date.now() - date.getTime();
+}
+/**
+ * Get minutes since timestamp.
+ */
+export function getTimeSinceMinutes(timestamp) {
+    return getTimeSinceMs(timestamp) / 60000;
+}
+/**
+ * Check if timestamp is within a given number of minutes.
+ */
+export function isWithinMinutes(timestamp, minutes) {
+    return getTimeSinceMinutes(timestamp) < minutes;
+}
+/**
+ * Format date + time for detail views (e.g. "Jan 5, 2:30 PM").
+ * No year — use formatFullDate when year is needed.
+ */
+export function formatDateTime(dateStr) {
+    if (!dateStr)
+        return '';
+    var date = parseTimestamp(dateStr);
+    if (!date)
+        return '';
+    return date.toLocaleString(undefined, {
+        month: 'short',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+    });
+}
+/**
+ * Color-coded relative age for task rows.
+ * Returns a label (e.g. "3d", "2w") and an oklch color string
+ * that shifts from green (fresh) → blue → amber → orange → red (stale).
+ *
+ * Usage:
+ *   const age = taskAge(task.created_at)
+ *   // <span style="color: {age.color}">{age.label}</span>
+ */
+export function taskAge(dateStr) {
+    var now = Date.now();
+    var created = new Date(dateStr).getTime();
+    var minutes = Math.floor((now - created) / 60000);
+    var hours = Math.floor(minutes / 60);
+    var days = Math.floor(hours / 24);
+    var weeks = Math.floor(days / 7);
+    var months = Math.floor(days / 30);
+    if (minutes < 60)
+        return { label: "".concat(minutes, "m"), color: 'oklch(0.75 0.18 145)' }; // green — fresh
+    if (hours < 24)
+        return { label: "".concat(hours, "h"), color: 'oklch(0.75 0.18 145)' }; // green
+    if (days < 3)
+        return { label: "".concat(days, "d"), color: 'oklch(0.70 0.15 200)' }; // blue — recent
+    if (days < 7)
+        return { label: "".concat(days, "d"), color: 'oklch(0.75 0.15 85)' }; // amber — aging
+    if (weeks < 4)
+        return { label: "".concat(weeks, "w"), color: 'oklch(0.65 0.18 50)' }; // orange — stale
+    return { label: "".concat(months, "mo"), color: 'oklch(0.65 0.20 25)' }; // red — old
+}

package/dist/utils/googleMapsLoader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Centralized Google Maps API loader for jatui.
+ *
+ * Prevents multiple script loads and ensures all required libraries are available.
+ * Pass the API key explicitly — jatui is SvelteKit-agnostic (no $env imports).
+ *
+ * Usage:
+ *   await loadGoogleMapsAPI({ apiKey: 'YOUR_KEY', libraries: ['marker', 'geometry'] })
+ *   if (isGoogleMapsLoaded()) { ... }
+ */
+interface LoadOptions {
+    apiKey: string;
+    libraries?: string[];
+}
+export declare function loadGoogleMapsAPI(options: LoadOptions): Promise<void>;
+export declare function isGoogleMapsLoaded(): boolean;
+export declare function isPlacesLoaded(): boolean;
+export declare function isGeometryLoaded(): boolean;
+export {};

package/dist/utils/googleMapsLoader.js

@@ -0,0 +1,121 @@
+/**
+ * Centralized Google Maps API loader for jatui.
+ *
+ * Prevents multiple script loads and ensures all required libraries are available.
+ * Pass the API key explicitly — jatui is SvelteKit-agnostic (no $env imports).
+ *
+ * Usage:
+ *   await loadGoogleMapsAPI({ apiKey: 'YOUR_KEY', libraries: ['marker', 'geometry'] })
+ *   if (isGoogleMapsLoaded()) { ... }
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var loadPromise = null;
+var isLoaded = false;
+export function loadGoogleMapsAPI(options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var apiKey, _a, libraries, allLibrariesAvailable, allLibraries;
+        var _b;
+        return __generator(this, function (_c) {
+            if (typeof window === 'undefined')
+                return [2 /*return*/];
+            apiKey = options.apiKey, _a = options.libraries, libraries = _a === void 0 ? [] : _a;
+            if (!apiKey) {
+                console.warn('googleMapsLoader: No API key provided');
+                return [2 /*return*/];
+            }
+            // If already loaded and all required libraries are available, return
+            if (isLoaded && ((_b = window.google) === null || _b === void 0 ? void 0 : _b.maps)) {
+                allLibrariesAvailable = libraries.every(function (lib) {
+                    var _a, _b, _c, _d;
+                    switch (lib) {
+                        case 'places':
+                            return (_b = (_a = window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.places;
+                        case 'geometry':
+                            return (_d = (_c = window.google) === null || _c === void 0 ? void 0 : _c.maps) === null || _d === void 0 ? void 0 : _d.geometry;
+                        default:
+                            return true;
+                    }
+                });
+                if (allLibrariesAvailable)
+                    return [2 /*return*/];
+            }
+            // If already loading, return the existing promise
+            if (loadPromise)
+                return [2 /*return*/, loadPromise];
+            allLibraries = Array.from(new Set(__spreadArray(['geometry', 'places', 'marker'], libraries, true)));
+            loadPromise = new Promise(function (resolve, reject) {
+                var script = document.createElement('script');
+                script.src = "https://maps.googleapis.com/maps/api/js?key=".concat(apiKey, "&libraries=").concat(allLibraries.join(','));
+                script.async = true;
+                script.defer = true;
+                script.onload = function () {
+                    isLoaded = true;
+                    loadPromise = null;
+                    resolve();
+                };
+                script.onerror = function (error) {
+                    loadPromise = null;
+                    reject(error);
+                };
+                document.head.appendChild(script);
+            });
+            return [2 /*return*/, loadPromise];
+        });
+    });
+}
+export function isGoogleMapsLoaded() {
+    var _a;
+    return isLoaded && !!((_a = window.google) === null || _a === void 0 ? void 0 : _a.maps);
+}
+export function isPlacesLoaded() {
+    var _a, _b;
+    return isGoogleMapsLoaded() && !!((_b = (_a = window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.places);
+}
+export function isGeometryLoaded() {
+    var _a, _b;
+    return isGoogleMapsLoaded() && !!((_b = (_a = window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.geometry);
+}

package/dist/utils/mentionParser.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Mention Parser Utilities
+ *
+ * Handles parsing and rendering of @-mentions in messages.
+ * Format: [@Display Name](type:id) -> clickable links
+ *
+ * The URL generator is configurable — consuming apps provide their own
+ * routing via the `urlGenerator` parameter or by setting a default.
+ */
+export interface MentionMatch {
+    type: string;
+    id: string;
+    displayName: string;
+    url: string;
+    startIndex: number;
+    endIndex: number;
+    fullMatch: string;
+}
+export type MentionUrlGenerator = (type: string, id: string) => string;
+/**
+ * Set the default URL generator for mentions.
+ * Call this once at app startup to configure mention link routing.
+ */
+export declare function setMentionUrlGenerator(generator: MentionUrlGenerator): void;
+/**
+ * Parse message content and extract all mentions
+ */
+export declare function parseMentions(content: string, urlGenerator?: MentionUrlGenerator): MentionMatch[];
+/**
+ * Convert message content with mentions to HTML
+ */
+export declare function renderMentionsAsHTML(content: string, urlGenerator?: MentionUrlGenerator): string;
+/**
+ * Create a mention string for insertion into message input
+ */
+export declare function createMentionString(type: string, id: string, displayName: string): string;
+/**
+ * Extract plain text from message content (remove mention markup)
+ */
+export declare function extractPlainText(content: string): string;
+/**
+ * Check if cursor is inside a mention
+ */
+export declare function findMentionAtCursor(content: string, cursorPosition: number): MentionMatch | null;
+/**
+ * Find @ symbol and following text that could be a mention being typed.
+ * Supported symbols: @ $ # ! ~ / +
+ */
+export declare function findPartialMention(content: string, cursorPosition: number): {
+    start: number;
+    query: string;
+} | null;
+/**
+ * Replace partial mention with complete mention string
+ */
+export declare function replaceMentionInContent(content: string, startIndex: number, endIndex: number, mentionString: string): {
+    newContent: string;
+    newCursorPosition: number;
+};
+/**
+ * Simple HTML escape function
+ */
+export declare function escapeHTML(text: string): string;
+/**
+ * Count mentions in content
+ */
+export declare function countMentions(content: string): number;

package/dist/utils/mentionParser.js

@@ -0,0 +1,132 @@
+/**
+ * Mention Parser Utilities
+ *
+ * Handles parsing and rendering of @-mentions in messages.
+ * Format: [@Display Name](type:id) -> clickable links
+ *
+ * The URL generator is configurable — consuming apps provide their own
+ * routing via the `urlGenerator` parameter or by setting a default.
+ */
+// Regex to match mention pattern: [@Display Name](type:id)
+var MENTION_REGEX = /\[@([^\]]+)\]\(([^:]+):([^)]+)\)/g;
+// Default URL generator (apps can override)
+var defaultUrlGenerator = function (type, id) { return "#".concat(type, "/").concat(id); };
+/**
+ * Set the default URL generator for mentions.
+ * Call this once at app startup to configure mention link routing.
+ */
+export function setMentionUrlGenerator(generator) {
+    defaultUrlGenerator = generator;
+}
+/**
+ * Parse message content and extract all mentions
+ */
+export function parseMentions(content, urlGenerator) {
+    var mentions = [];
+    var gen = urlGenerator !== null && urlGenerator !== void 0 ? urlGenerator : defaultUrlGenerator;
+    var match;
+    MENTION_REGEX.lastIndex = 0;
+    while ((match = MENTION_REGEX.exec(content)) !== null) {
+        var fullMatch = match[0], displayName = match[1], type = match[2], id = match[3];
+        mentions.push({
+            type: type,
+            id: id,
+            displayName: displayName,
+            url: gen(type, id),
+            startIndex: match.index,
+            endIndex: match.index + fullMatch.length,
+            fullMatch: fullMatch
+        });
+    }
+    return mentions;
+}
+/**
+ * Convert message content with mentions to HTML
+ */
+export function renderMentionsAsHTML(content, urlGenerator) {
+    var mentions = parseMentions(content, urlGenerator);
+    if (mentions.length === 0) {
+        return escapeHTML(content);
+    }
+    var result = '';
+    var lastIndex = 0;
+    mentions.forEach(function (mention) {
+        result += escapeHTML(content.substring(lastIndex, mention.startIndex));
+        result += "<a href=\"".concat(mention.url, "\" class=\"mention-link mention-").concat(mention.type, "\" data-mention-type=\"").concat(mention.type, "\" data-mention-id=\"").concat(mention.id, "\">@").concat(escapeHTML(mention.displayName), "</a>");
+        lastIndex = mention.endIndex;
+    });
+    result += escapeHTML(content.substring(lastIndex));
+    return result;
+}
+/**
+ * Create a mention string for insertion into message input
+ */
+export function createMentionString(type, id, displayName) {
+    return "[@".concat(displayName, "](").concat(type, ":").concat(id, ")");
+}
+/**
+ * Extract plain text from message content (remove mention markup)
+ */
+export function extractPlainText(content) {
+    MENTION_REGEX.lastIndex = 0;
+    return content.replace(MENTION_REGEX, '@$1');
+}
+/**
+ * Check if cursor is inside a mention
+ */
+export function findMentionAtCursor(content, cursorPosition) {
+    var mentions = parseMentions(content);
+    return (mentions.find(function (mention) { return cursorPosition >= mention.startIndex && cursorPosition <= mention.endIndex; }) || null);
+}
+/**
+ * Find @ symbol and following text that could be a mention being typed.
+ * Supported symbols: @ $ # ! ~ / +
+ */
+export function findPartialMention(content, cursorPosition) {
+    var mentionSymbols = ['@', '$', '#', '!', '~', '/', '+'];
+    var symbolIndex = -1;
+    for (var i = cursorPosition - 1; i >= 0; i--) {
+        var char = content[i];
+        if (mentionSymbols.includes(char)) {
+            symbolIndex = i;
+            break;
+        }
+        if (char === ' ' || char === '\n' || char === ']' || char === ')') {
+            break;
+        }
+    }
+    if (symbolIndex === -1)
+        return null;
+    var query = content.substring(symbolIndex + 1, cursorPosition).trim();
+    var existingMention = findMentionAtCursor(content, symbolIndex);
+    if (existingMention)
+        return null;
+    return { start: symbolIndex, query: query };
+}
+/**
+ * Replace partial mention with complete mention string
+ */
+export function replaceMentionInContent(content, startIndex, endIndex, mentionString) {
+    var before = content.substring(0, startIndex);
+    var after = content.substring(endIndex);
+    var newContent = before + mentionString + after;
+    var newCursorPosition = startIndex + mentionString.length;
+    return { newContent: newContent, newCursorPosition: newCursorPosition };
+}
+/**
+ * Simple HTML escape function
+ */
+export function escapeHTML(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+/**
+ * Count mentions in content
+ */
+export function countMentions(content) {
+    return parseMentions(content).length;
+}

package/dist/utils/phone.d.ts

@@ -0,0 +1,13 @@
+import { type CountryCode } from "libphonenumber-js";
+export declare const DEFAULT_COUNTRY: CountryCode;
+export declare function toE164(raw: string | null | undefined, defaultCountry?: CountryCode): string | null;
+export declare function formatPhoneForDisplay(e164: string | null | undefined): string;
+export declare function isValidPhone(raw: string | null | undefined, defaultCountry?: CountryCode): boolean;
+export type CountryOption = {
+    code: CountryCode;
+    name: string;
+    dialCode: string;
+    flag: string;
+};
+export declare function listCountries(): CountryOption[];
+export declare const PRIORITY_COUNTRIES: CountryCode[];

package/dist/utils/phone.js

@@ -0,0 +1,67 @@
+import { parsePhoneNumberFromString, getCountries, getCountryCallingCode, } from "libphonenumber-js";
+export var DEFAULT_COUNTRY = "US";
+export function toE164(raw, defaultCountry) {
+    if (defaultCountry === void 0) { defaultCountry = DEFAULT_COUNTRY; }
+    if (!raw)
+        return null;
+    var trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    var parsed = parsePhoneNumberFromString(trimmed, defaultCountry);
+    if (parsed === null || parsed === void 0 ? void 0 : parsed.isValid())
+        return parsed.number;
+    return null;
+}
+export function formatPhoneForDisplay(e164) {
+    if (!e164)
+        return "";
+    var parsed = parsePhoneNumberFromString(e164);
+    if (!parsed)
+        return e164;
+    return parsed.country === DEFAULT_COUNTRY ? parsed.formatNational() : parsed.formatInternational();
+}
+export function isValidPhone(raw, defaultCountry) {
+    var _a;
+    if (defaultCountry === void 0) { defaultCountry = DEFAULT_COUNTRY; }
+    if (!raw)
+        return false;
+    var parsed = parsePhoneNumberFromString(raw.trim(), defaultCountry);
+    return (_a = parsed === null || parsed === void 0 ? void 0 : parsed.isValid()) !== null && _a !== void 0 ? _a : false;
+}
+var COUNTRY_NAMES = {
+    US: "United States", CA: "Canada", GB: "United Kingdom", AU: "Australia", NZ: "New Zealand",
+    IE: "Ireland", DE: "Germany", FR: "France", ES: "Spain", IT: "Italy", NL: "Netherlands",
+    BE: "Belgium", CH: "Switzerland", AT: "Austria", SE: "Sweden", NO: "Norway", DK: "Denmark",
+    FI: "Finland", PT: "Portugal", PL: "Poland", CZ: "Czechia", GR: "Greece", MX: "Mexico",
+    BR: "Brazil", AR: "Argentina", CL: "Chile", CO: "Colombia", PE: "Peru", JP: "Japan",
+    KR: "South Korea", CN: "China", HK: "Hong Kong", TW: "Taiwan", SG: "Singapore", MY: "Malaysia",
+    TH: "Thailand", PH: "Philippines", ID: "Indonesia", VN: "Vietnam", IN: "India", PK: "Pakistan",
+    BD: "Bangladesh", IL: "Israel", AE: "UAE", SA: "Saudi Arabia", TR: "Turkey", EG: "Egypt",
+    ZA: "South Africa", NG: "Nigeria", KE: "Kenya", RU: "Russia", UA: "Ukraine",
+};
+function flagEmoji(code) {
+    return code
+        .toUpperCase()
+        .split("")
+        .map(function (c) { return String.fromCodePoint(127397 + c.charCodeAt(0)); })
+        .join("");
+}
+var countriesCache = null;
+export function listCountries() {
+    if (countriesCache)
+        return countriesCache;
+    var all = getCountries()
+        .map(function (code) {
+        var _a;
+        return ({
+            code: code,
+            name: (_a = COUNTRY_NAMES[code]) !== null && _a !== void 0 ? _a : code,
+            dialCode: "+".concat(getCountryCallingCode(code)),
+            flag: flagEmoji(code),
+        });
+    })
+        .sort(function (a, b) { return a.name.localeCompare(b.name); });
+    countriesCache = all;
+    return all;
+}
+export var PRIORITY_COUNTRIES = ["US", "CA", "GB", "AU", "MX"];

package/dist/utils/phoneFormat.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Phone number formatting utilities
+ *
+ * Provides consistent phone number formatting as (xxx) xxx-xxxx
+ * Limits input to 10 digits and handles formatting as user types
+ */
+/**
+ * Strips all non-numeric characters from a phone number
+ */
+export declare function stripPhoneNumber(value: string): string;
+/**
+ * Formats a phone number to (xxx) xxx-xxxx format
+ */
+export declare function formatPhoneNumber(value: string): string;
+/**
+ * Checks if a phone number has exactly 10 digits
+ */
+export declare function isCompletePhoneNumber(value: string): boolean;
+/**
+ * Validates phone number format (exactly 10 digits)
+ */
+export declare function isValidPhoneNumber(value: string): boolean;
+/**
+ * Handles input formatting with cursor position preservation
+ */
+export declare function updatePhoneInput(input: HTMLInputElement, newValue: string, oldValue: string): void;