@vamos-ui/react 0.0.0-stage → 0.3.0

package/dist/components/pagination.js

@@ -0,0 +1,174 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { ChevronDown, ChevronLeft, ChevronRight, MoreHorizontal } from "lucide-react";
+import { cn } from "../lib/cn.js";
+import { useLabels } from "../lib/labels.js";
+import { useFormat } from "../lib/locale.js";
+import { useLink } from "../lib/provider.js";
+import { controlVariants } from "../lib/variants.js";
+import { buttonVariants } from "./button.js";
+import { Spinner } from "./spinner.js";
+const paginationLabels = {
+    label: "Pagination",
+    previous: "Previous",
+    next: "Next",
+    previousPage: "Previous page",
+    nextPage: "Next page",
+    goTo: "Page {page}",
+    page: "Page {page} of {total}",
+    range: "{from}–{to} of {total}",
+    empty: "No results",
+    pageSize: "Rows per page",
+    morePages: "More pages",
+};
+/**
+ * The page numbers to render, with ellipsis markers. The length stays constant while paging
+ * (no jumping buttons): `paginationRange({ page: 6, pageCount: 20 })` → `[1, "ellipsis-start", 5, 6, 7, "ellipsis-end", 20]`.
+ * A gap of exactly one page shows the page instead of "…".
+ */
+export function paginationRange({ page, pageCount, siblingCount = 1, boundaryCount = 1 }) {
+    const count = Math.max(0, Math.floor(pageCount));
+    if (count === 0)
+        return [];
+    const current = Math.min(Math.max(1, Math.floor(page)), count);
+    const range = (a, b) => Array.from({ length: Math.max(0, b - a + 1) }, (_, i) => a + i);
+    // boundaries + siblings + current + 2 ellipses
+    const total = boundaryCount * 2 + siblingCount * 2 + 3;
+    if (count <= total)
+        return range(1, count);
+    const startPages = range(1, Math.min(boundaryCount, count));
+    const endPages = range(Math.max(count - boundaryCount + 1, boundaryCount + 1), count);
+    const siblingsStart = Math.max(Math.min(current - siblingCount, count - boundaryCount - siblingCount * 2 - 1), boundaryCount + 2);
+    const siblingsEnd = Math.min(Math.max(current + siblingCount, boundaryCount + siblingCount * 2 + 2), count - boundaryCount - 1);
+    const out = [...startPages];
+    if (siblingsStart > boundaryCount + 2)
+        out.push("ellipsis-start");
+    else if (boundaryCount + 1 < count - boundaryCount)
+        out.push(boundaryCount + 1);
+    out.push(...range(siblingsStart, siblingsEnd));
+    if (siblingsEnd < count - boundaryCount - 1)
+        out.push("ellipsis-end");
+    else if (count - boundaryCount > boundaryCount)
+        out.push(count - boundaryCount);
+    out.push(...endPages);
+    return out;
+}
+/** Memoised `paginationRange` for components. */
+export function usePaginationRange(options) {
+    const { page, pageCount, siblingCount, boundaryCount } = options;
+    return React.useMemo(() => paginationRange({ page, pageCount, siblingCount, boundaryCount }), [page, pageCount, siblingCount, boundaryCount]);
+}
+const SizeContext = React.createContext("md");
+const itemSize = {
+    sm: "h-8 min-w-8 px-2 text-[13px] rounded-ui-sm [&_svg]:size-3.5",
+    md: "h-(--control-h) min-w-(--control-h) px-2.5 text-sm rounded-ui [&_svg]:size-4",
+};
+/** The `<ul>` of page items. */
+export const PaginationList = React.forwardRef(function PaginationList({ className, ...props }, ref) {
+    return _jsx("ul", { ref: ref, "data-slot": "pagination-list", className: cn("flex items-center gap-1", className), ...props });
+});
+/** One `<li>`. */
+export const PaginationItem = React.forwardRef(function PaginationItem({ className, ...props }, ref) {
+    return _jsx("li", { ref: ref, "data-slot": "pagination-item", className: cn("inline-flex", className), ...props });
+});
+/** A page number, or the shell for Previous / Next. Router `Link` when `href` is set, else a button. */
+export const PaginationLink = React.forwardRef(function PaginationLink({ href, isActive, disabled, loading, className, children, onClick, ...props }, ref) {
+    const Link = useLink();
+    const size = React.useContext(SizeContext);
+    const classes = cn(buttonVariants({ variant: "ghost" }), itemSize[size], "tabular font-normal text-fg-muted hover:text-fg", isActive && "bg-selected font-semibold text-fg hover:bg-selected", className);
+    const content = loading ? (_jsxs(_Fragment, { children: [_jsx("span", { className: "invisible", children: children }), _jsx(Spinner, { size: "xs", className: "absolute" })] })) : (children);
+    if (href !== undefined && !disabled) {
+        return (_jsx(Link, { ref: ref, href: href, "aria-current": isActive ? "page" : undefined, "aria-busy": loading || undefined, className: classes, "data-slot": "pagination-link", onClick: onClick, ...props, children: content }));
+    }
+    if (href !== undefined && disabled) {
+        // A disabled link: no href, so it isn't focusable or followable.
+        return (_jsx("a", { ref: ref, role: "link", "aria-disabled": "true", className: classes, "data-slot": "pagination-link", ...props, children: content }));
+    }
+    return (_jsx("button", { ref: ref, type: "button", "aria-current": isActive ? "page" : undefined, "aria-busy": loading || undefined, disabled: disabled, className: classes, "data-slot": "pagination-link", onClick: onClick, ...props, children: content }));
+});
+/** Previous-page control. The arrow flips in RTL. */
+export const PaginationPrevious = React.forwardRef(function PaginationPrevious({ showLabel, labels, className, ...props }, ref) {
+    const t = useLabels("pagination", paginationLabels, labels);
+    return (_jsxs(PaginationLink, { ref: ref, "aria-label": t("previousPage"), className: cn(showLabel && "gap-1 ps-2 pe-3", className), "data-slot": "pagination-previous", ...props, children: [_jsx(ChevronLeft, { "aria-hidden": true, className: "rtl:-scale-x-100" }), showLabel ? _jsx("span", { children: t("previous") }) : null] }));
+});
+/** Next-page control. The arrow flips in RTL. */
+export const PaginationNext = React.forwardRef(function PaginationNext({ showLabel, labels, className, ...props }, ref) {
+    const t = useLabels("pagination", paginationLabels, labels);
+    return (_jsxs(PaginationLink, { ref: ref, "aria-label": t("nextPage"), className: cn(showLabel && "gap-1 ps-3 pe-2", className), "data-slot": "pagination-next", ...props, children: [showLabel ? _jsx("span", { children: t("next") }) : null, _jsx(ChevronRight, { "aria-hidden": true, className: "rtl:-scale-x-100" })] }));
+});
+/** "…" between page numbers. */
+export function PaginationEllipsis({ className, labels, ...props }) {
+    const t = useLabels("pagination", paginationLabels, labels);
+    const size = React.useContext(SizeContext);
+    return (_jsxs("span", { "data-slot": "pagination-ellipsis", className: cn("inline-flex items-center justify-center text-fg-subtle", size === "sm" ? "h-8 w-6 [&_svg]:size-3.5" : "h-(--control-h) w-7 [&_svg]:size-4", className), ...props, children: [_jsx(MoreHorizontal, { "aria-hidden": true }), _jsx("span", { className: "sr-only", children: t("morePages") })] }));
+}
+/**
+ * Page through a long list. 1-based `page`, props line up with TanStack Table state.
+ *
+ * ```tsx
+ * <Pagination page={page} pageCount={52} onPageChange={setPage} />
+ * <Pagination page={3} pageCount={12} getHref={(p) => `/blog?page=${p}`} />   // SEO links
+ * ```
+ *
+ * Moving focus to the top of the list after a page change is the consumer's job.
+ */
+export const Pagination = React.forwardRef(function Pagination({ page, pageCount, onPageChange, getHref, siblingCount, boundaryCount, variant = "numbers", size = "md", hideOnSinglePage = true, loading, labels, className, ...props }, ref) {
+    const t = useLabels("pagination", paginationLabels, labels);
+    const range = usePaginationRange({ page, pageCount, siblingCount, boundaryCount });
+    if (pageCount < 1 || (hideOnSinglePage && pageCount <= 1))
+        return null;
+    const current = Math.min(Math.max(1, page), pageCount);
+    const go = (p) => (e) => {
+        if (loading) {
+            e.preventDefault();
+            return;
+        }
+        if (p !== current)
+            onPageChange?.(p);
+    };
+    const linkProps = (p) => (getHref ? { href: getHref(p) } : {});
+    const compact = (_jsxs("span", { className: "tabular px-2 text-[13px] text-fg-muted", "aria-live": "polite", children: [_jsx("span", { className: "sr-only", children: t("page", { page: current, total: pageCount }) }), _jsxs("span", { "aria-hidden": true, children: [_jsx("span", { className: "font-medium text-fg", children: current }), " / ", pageCount] })] }));
+    return (_jsx(SizeContext.Provider, { value: size, children: _jsx("nav", { ref: ref, "aria-label": t("label"), "data-slot": "pagination", "data-variant": variant, className: cn("flex", className), ...props, children: _jsxs(PaginationList, { children: [_jsx(PaginationItem, { children: _jsx(PaginationPrevious, { disabled: current <= 1 || loading, onClick: go(current - 1), showLabel: variant === "simple", labels: labels, ...linkProps(current - 1) }) }), variant === "numbers"
+                        ? range.map((item) => typeof item === "number" ? (_jsx(PaginationItem, { className: "max-sm:hidden", children: _jsx(PaginationLink, { isActive: item === current, loading: loading && item === current, "aria-label": t("goTo", { page: item }), onClick: go(item), ...linkProps(item), children: item }) }, item)) : (_jsx(PaginationItem, { className: "max-sm:hidden", children: _jsx(PaginationEllipsis, { labels: labels }) }, item)))
+                        : null, variant === "numbers" ? _jsx(PaginationItem, { className: "sm:hidden", children: compact }) : null, variant === "compact" ? _jsx(PaginationItem, { children: compact }) : null, _jsx(PaginationItem, { children: _jsx(PaginationNext, { disabled: current >= pageCount || loading, onClick: go(current + 1), showLabel: variant === "simple", labels: labels, ...linkProps(current + 1) }) })] }) }) }));
+});
+/**
+ * The table footer: "1–20 of 312" + rows per page + page numbers. Changing the page size keeps the
+ * first visible row on screen (the page is recomputed) — the consumer receives both callbacks.
+ */
+export const PaginationBar = React.forwardRef(function PaginationBar({ total, pageSize, pageSizeOptions = [10, 20, 50, 100], onPageSizeChange, page, onPageChange, labels, size = "md", className, style, id, ...props }, ref) {
+    const t = useLabels("pagination", paginationLabels, labels);
+    const f = useFormat();
+    const selectId = React.useId();
+    const pageCount = Math.max(1, Math.ceil(total / Math.max(1, pageSize)));
+    const current = Math.min(Math.max(1, page), pageCount);
+    const from = total === 0 ? 0 : (current - 1) * pageSize + 1;
+    const to = Math.min(total, current * pageSize);
+    const options = pageSizeOptions.includes(pageSize) || pageSizeOptions.length === 0 ? pageSizeOptions : [...pageSizeOptions, pageSize].sort((a, b) => a - b);
+    return (_jsxs("div", { ref: ref, id: id, style: style, "data-slot": "pagination-bar", className: cn("flex flex-wrap items-center gap-x-6 gap-y-2 text-[13px] text-fg-muted", className), children: [_jsx("p", { className: "tabular me-auto", "aria-live": "polite", children: total === 0 ? t("empty") : t("range", { from: f.number(from), to: f.number(to), total: f.number(total) }) }), options.length > 0 && onPageSizeChange ? (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("label", { htmlFor: selectId, className: "whitespace-nowrap", children: t("pageSize") }), _jsxs("div", { className: "relative", children: [_jsx("select", { id: selectId, value: pageSize, onChange: (e) => {
+                                    const next = Number(e.target.value);
+                                    onPageSizeChange(next);
+                                    // keep the first visible row on screen
+                                    const nextPage = Math.floor((from > 0 ? from - 1 : 0) / next) + 1;
+                                    if (nextPage !== current)
+                                        onPageChange?.(nextPage);
+                                }, className: cn(controlVariants({ size: "sm" }), "tabular w-auto appearance-none pe-7 text-fg"), children: options.map((o) => (_jsx("option", { value: o, children: f.number(o) }, o))) }), _jsx(ChevronDown, { "aria-hidden": true, className: "pointer-events-none absolute end-2 top-1/2 size-3.5 -translate-y-1/2 text-fg-subtle" })] })] })) : null, _jsx(Pagination, { page: current, pageCount: pageCount, onPageChange: onPageChange, labels: labels, size: size, hideOnSinglePage: false, ...props })] }));
+});
+/** Previous / Next for cursor APIs where the total is unknown. */
+export const CursorPagination = React.forwardRef(function CursorPagination({ hasPrev, hasNext, onPrev, onNext, loading, status, size = "md", labels, className, ...props }, ref) {
+    const t = useLabels("pagination", paginationLabels, labels);
+    const [pressed, setPressed] = React.useState(null);
+    React.useEffect(() => {
+        if (!loading)
+            setPressed(null);
+    }, [loading]);
+    const btn = cn(buttonVariants({ variant: "secondary", size: size === "sm" ? "sm" : "md" }), "gap-1");
+    return (_jsxs("nav", { ref: ref, "aria-label": t("label"), "data-slot": "cursor-pagination", className: cn("flex items-center gap-3", className), ...props, children: [_jsxs("button", { type: "button", className: cn(btn, "ps-2.5"), disabled: !hasPrev || loading, "aria-busy": (loading && pressed === "prev") || undefined, onClick: () => {
+                    setPressed("prev");
+                    onPrev?.();
+                }, children: [loading && pressed === "prev" ? _jsx(Spinner, { size: "xs" }) : _jsx(ChevronLeft, { "aria-hidden": true, className: "rtl:-scale-x-100" }), t("previous")] }), status ? _jsx("span", { className: "tabular text-[13px] text-fg-muted", children: status }) : null, _jsxs("button", { type: "button", className: cn(btn, "pe-2.5"), disabled: !hasNext || loading, "aria-busy": (loading && pressed === "next") || undefined, onClick: () => {
+                    setPressed("next");
+                    onNext?.();
+                }, children: [t("next"), loading && pressed === "next" ? _jsx(Spinner, { size: "xs" }) : _jsx(ChevronRight, { "aria-hidden": true, className: "rtl:-scale-x-100" })] })] }));
+});

package/dist/components/phone-input.d.ts

@@ -0,0 +1,49 @@
+import * as React from "react";
+import { type BaseFormattedProps } from "./formatted-input.js";
+type PhoneLib = typeof import("libphonenumber-js/min");
+/**
+ * Loads the phone metadata (`libphonenumber-js/min`, ~80 kB) once. PhoneInput calls it on mount;
+ * call it earlier (e.g. on hover of "Add contact") to have formatting ready on first keystroke.
+ */
+export declare function preloadPhoneInput(): Promise<PhoneLib>;
+declare const phoneInputLabels: {
+    country: string;
+    suggested: string;
+    allCountries: string;
+    invalid: string;
+    invalidFor: string;
+    tooShort: string;
+    tooLong: string;
+};
+export type PhoneInputLabels = typeof phoneInputLabels;
+export interface PhoneInputProps extends BaseFormattedProps<string | null> {
+    /** Selected country (ISO 3166-1 alpha-2), controlled. */
+    country?: string;
+    /** Initial country. Default `"TR"` for Turkish locales, else the locale's region, else `"US"`. */
+    defaultCountry?: string;
+    onCountryChange?: (country: string) => void;
+    /** Limit the country list. */
+    countries?: string[];
+    /** Shown first, under "Suggested". */
+    preferredCountries?: string[];
+    /**
+     * How a complete number is shown after blur: `"national"` ("0532 123 45 67") when it belongs to
+     * the selected country, or `"international"` ("+90 532 123 45 67"). Default `"national"`.
+     */
+    display?: "national" | "international";
+    /** Hide the country picker (single-country forms). */
+    hideCountry?: boolean;
+    labels?: Partial<PhoneInputLabels>;
+}
+/**
+ * Phone number entry with a country picker. Formats as you type for the selected country,
+ * accepts what people actually type ("0532…", "532…", "90532…", "+90 (532)…", "0090…") and
+ * emits **E.164** (`"+905321234567"`). Typing `+` and a calling code switches the country.
+ * Parsing uses `libphonenumber-js` (min metadata), loaded lazily.
+ *
+ * ```tsx
+ * <Field label="Mobile"><PhoneInput defaultCountry="TR" onValueChange={(e164) => save(e164)} /></Field>
+ * ```
+ */
+export declare const PhoneInput: React.ForwardRefExoticComponent<PhoneInputProps & React.RefAttributes<HTMLInputElement>>;
+export {};

package/dist/components/phone-input.js

@@ -0,0 +1,266 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as React from "react";
+import { ChevronDown } from "lucide-react";
+import { cn } from "../lib/cn.js";
+import { useComposedRefs } from "../lib/compose-refs.js";
+import { useLabels } from "../lib/labels.js";
+import { useLocale } from "../lib/locale.js";
+import { compareText } from "../lib/text.js";
+import { useControllableState } from "../lib/use-controllable-state.js";
+import { useFormattedInput } from "../lib/use-formatted-input.js";
+import { Input } from "./input.js";
+import { WithoutFieldName, useFormattedValidity, useSubmitName } from "./formatted-input.js";
+let libPromise;
+let libLoaded = null;
+/**
+ * Loads the phone metadata (`libphonenumber-js/min`, ~80 kB) once. PhoneInput calls it on mount;
+ * call it earlier (e.g. on hover of "Add contact") to have formatting ready on first keystroke.
+ */
+export function preloadPhoneInput() {
+    libPromise ??= import("libphonenumber-js/min").then((m) => {
+        const lib = (m.default?.AsYouType ? m.default : m);
+        libLoaded = lib;
+        return lib;
+    });
+    return libPromise;
+}
+const phoneInputLabels = {
+    country: "Country",
+    suggested: "Suggested",
+    allCountries: "All countries",
+    invalid: "Enter a valid phone number",
+    invalidFor: "Enter a valid phone number for {country}",
+    tooShort: "This number is too short",
+    tooLong: "This number is too long",
+};
+function regionOfLocale(locale) {
+    try {
+        return new Intl.Locale(locale).maximize().region;
+    }
+    catch {
+        return undefined;
+    }
+}
+const accept = (ch) => (ch >= "0" && ch <= "9") || ch === "+";
+/**
+ * Phone number entry with a country picker. Formats as you type for the selected country,
+ * accepts what people actually type ("0532…", "532…", "90532…", "+90 (532)…", "0090…") and
+ * emits **E.164** (`"+905321234567"`). Typing `+` and a calling code switches the country.
+ * Parsing uses `libphonenumber-js` (min metadata), loaded lazily.
+ *
+ * ```tsx
+ * <Field label="Mobile"><PhoneInput defaultCountry="TR" onValueChange={(e164) => save(e164)} /></Field>
+ * ```
+ */
+export const PhoneInput = React.forwardRef(function PhoneInput(props, forwardedRef) {
+    const { country: countryProp, defaultCountry, onCountryChange, countries, preferredCountries, display: displayMode = "national", hideCountry, value, defaultValue, onValueChange, validateOn = "blur", onValidate, mono, labels, name, invalid, inputClassName, onBlur, onKeyDown, disabled, readOnly, size, ...rest } = props;
+    const { locale } = useLocale();
+    const t = useLabels("phoneInput", phoneInputLabels, labels);
+    const [lib, setLib] = React.useState(libLoaded);
+    const libRef = React.useRef(lib);
+    libRef.current = lib;
+    const fallbackCountry = (defaultCountry ?? (locale.toLowerCase().startsWith("tr") ? "TR" : regionOfLocale(locale)) ?? "US").toUpperCase();
+    const [country, setCountry] = useControllableState({ value: countryProp?.toUpperCase(), defaultValue: fallbackCountry, onChange: onCountryChange, name: "PhoneInput" });
+    const countryRef = React.useRef(country);
+    countryRef.current = country;
+    const v = useFormattedValidity(validateOn, onValidate);
+    const regionNames = React.useMemo(() => {
+        try {
+            return new Intl.DisplayNames([locale], { type: "region" });
+        }
+        catch {
+            return null;
+        }
+    }, [locale]);
+    const countryName = (c) => regionNames?.of(c) ?? c;
+    /* ---------------- parsing (pure helpers over the loaded lib) ---------------- */
+    const digitsOf = (s) => {
+        let plus = /^\s*\+/.test(s);
+        let d = s.replace(/\D/g, "");
+        if (!plus && d.startsWith("00")) {
+            plus = true;
+            d = d.slice(2);
+        }
+        return { plus, d };
+    };
+    const parseNumber = (text) => {
+        const l = libRef.current;
+        if (!l)
+            return undefined;
+        const { plus, d } = digitsOf(text);
+        if (!d)
+            return undefined;
+        const c = countryRef.current;
+        const primary = plus ? l.parsePhoneNumberFromString(`+${d}`) : l.parsePhoneNumberFromString(d, c);
+        if (primary?.isValid())
+            return primary;
+        if (!plus) {
+            // "90532…" with the calling code but without "+"
+            const alt = l.parsePhoneNumberFromString(`+${d}`);
+            if (alt?.isValid())
+                return alt;
+        }
+        return primary;
+    };
+    const format = (typed) => {
+        const { plus, d } = digitsOf(typed);
+        const l = libRef.current;
+        if (!d)
+            return plus ? "+" : "";
+        if (!l)
+            return (plus ? "+" : "") + d.slice(0, 15);
+        if (plus)
+            return new l.AsYouType().input(`+${d.slice(0, 15)}`);
+        return new l.AsYouType(countryRef.current).input(d.slice(0, 17));
+    };
+    const parse = (display) => {
+        const l = libRef.current;
+        const { plus, d } = digitsOf(display);
+        if (!d)
+            return null;
+        if (!l)
+            return plus && d.length >= 7 ? `+${d}` : null;
+        const p = parseNumber(display);
+        return p && p.isPossible() ? p.number : null;
+    };
+    const pretty = (display) => {
+        const p = parseNumber(display);
+        if (!p || !p.isValid())
+            return display;
+        return displayMode === "national" && p.country === countryRef.current ? p.formatNational() : p.formatInternational();
+    };
+    const toDisplay = (raw) => {
+        if (!raw)
+            return "";
+        if (!libRef.current)
+            return raw;
+        return pretty(raw.startsWith("+") ? raw : `+${raw}`);
+    };
+    const check = (display) => {
+        const l = libRef.current;
+        const { d } = digitsOf(display);
+        if (!d)
+            return { valid: true };
+        if (!l)
+            return d.length >= 7 ? { valid: true } : { valid: false, reason: "tooShort", message: t("tooShort") };
+        const p = parseNumber(display);
+        if (p?.isValid())
+            return { valid: true };
+        const { plus } = digitsOf(display);
+        const len = plus ? l.validatePhoneNumberLength(`+${d}`) : l.validatePhoneNumberLength(d, countryRef.current);
+        if (len === "TOO_SHORT")
+            return { valid: false, reason: "tooShort", message: t("tooShort") };
+        if (len === "TOO_LONG")
+            return { valid: false, reason: "tooLong", message: t("tooLong") };
+        return { valid: false, reason: "invalid", message: plus ? t("invalid") : t("invalidFor", { country: countryName(countryRef.current) }) };
+    };
+    const engine = useFormattedInput({
+        value,
+        defaultValue,
+        accept,
+        format,
+        parse,
+        toDisplay,
+        formatOnBlur: pretty,
+        onValueChange: (raw, formatted) => {
+            const c = check(formatted);
+            v.report(c, "change");
+            // "+44 20…" typed into a TR field: follow the number's country.
+            const l = libRef.current;
+            if (l && formatted.trim().startsWith("+")) {
+                const detected = parseNumber(formatted)?.country;
+                if (detected && detected !== countryRef.current && (!countries || countries.includes(detected)))
+                    setCountry(detected);
+            }
+            onValueChange?.(raw, { valid: c.valid, reason: c.reason, formatted, kind: raw ? parseNumber(formatted)?.country : undefined });
+        },
+    });
+    const ref = useComposedRefs(forwardedRef, engine.ref);
+    const submitName = useSubmitName(name);
+    const engineRef = React.useRef(engine);
+    engineRef.current = engine;
+    // Load metadata, then re-format whatever is there.
+    React.useEffect(() => {
+        if (libRef.current)
+            return;
+        let alive = true;
+        preloadPhoneInput().then((l) => {
+            if (!alive)
+                return;
+            libRef.current = l;
+            setLib(l);
+            const e = engineRef.current;
+            const raw = e.raw;
+            if (raw)
+                e.setDisplay(toDisplay(raw));
+            else if (e.display)
+                e.setDisplay(e.display);
+        });
+        return () => {
+            alive = false;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const changeCountry = (next) => {
+        const prev = countryRef.current;
+        setCountry(next);
+        countryRef.current = next;
+        const e = engineRef.current;
+        const l = libRef.current;
+        if (!e.display)
+            return;
+        const { plus } = digitsOf(e.display);
+        // Keep the local part when switching country ("0532…" stays, "+90 532…" → national under the new country).
+        let national = e.display.replace(/\D/g, "");
+        if (l && plus) {
+            const p = parseNumber(e.display);
+            national = p?.nationalNumber ?? national;
+        }
+        else if (l && prev !== next) {
+            const p = l.parsePhoneNumberFromString(national, prev);
+            if (p)
+                national = p.nationalNumber;
+        }
+        e.setDisplay(national);
+    };
+    /* ---------------- country list ---------------- */
+    const list = React.useMemo(() => {
+        const all = (countries ?? lib?.getCountries() ?? [country]).map((c) => c.toUpperCase());
+        if (!all.includes(country))
+            all.unshift(country);
+        const cmp = compareText(locale);
+        return all.map((c) => ({ code: c, name: countryName(c) })).sort((a, b) => cmp(a.name, b.name));
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [countries, lib, locale, country, regionNames]);
+    const preferred = preferredCountries?.map((c) => c.toUpperCase()).filter((c) => list.some((x) => x.code === c));
+    const callingCode = (c) => {
+        try {
+            return lib ? `+${lib.getCountryCallingCode(c)}` : "";
+        }
+        catch {
+            return "";
+        }
+    };
+    const optionText = (c) => `${c.name} ${callingCode(c.code)}`.trim();
+    const picker = hideCountry ? null : (_jsxs("span", { "data-slot": "phone-input-country", className: "relative -mx-3 flex h-full items-center gap-1.5 px-3 font-mono text-[12px] tabular text-fg-muted has-[select:focus-visible]:bg-hover has-[select:focus-visible]:text-fg", children: [_jsx("span", { "aria-hidden": true, className: "font-semibold tracking-[0.04em] text-fg", children: country }), _jsx("span", { "aria-hidden": true, className: "text-fg-subtle", children: callingCode(country) }), !readOnly ? _jsx(ChevronDown, { "aria-hidden": true, className: "size-3 text-fg-subtle" }) : null, !readOnly ? (_jsxs("select", { "aria-label": t("country"), value: country, disabled: disabled, onChange: (e) => changeCountry(e.currentTarget.value), className: "absolute inset-0 cursor-pointer appearance-none bg-transparent opacity-0 outline-none disabled:cursor-not-allowed", children: [preferred?.length ? (_jsx("optgroup", { label: t("suggested"), children: preferred.map((c) => (_jsx("option", { value: c, children: optionText({ code: c, name: countryName(c) }) }, `p-${c}`))) })) : null, preferred?.length ? (_jsx("optgroup", { label: t("allCountries"), children: list.map((c) => (_jsx("option", { value: c.code, children: optionText(c) }, c.code))) })) : (list.map((c) => (_jsx("option", { value: c.code, children: optionText(c) }, c.code))))] })) : null] }));
+    return (_jsxs(_Fragment, { children: [_jsx(WithoutFieldName, { children: _jsx(Input, { ref: ref, ...rest, ...engine.inputProps, size: size, type: "tel", inputMode: "tel", autoComplete: "tel", dir: "ltr", disabled: disabled, readOnly: readOnly, invalid: invalid || v.invalid, addonStart: picker ?? undefined, inputClassName: cn("tabular", mono && "font-mono", inputClassName), "data-slot": "phone-input", "data-country": country, placeholder: rest.placeholder ?? (lib ? exampleFor(lib, country, displayMode) : undefined), onKeyDown: (e) => {
+                        onKeyDown?.(e);
+                        engine.inputProps.onKeyDown(e);
+                    }, onBlur: (e) => {
+                        engine.inputProps.onBlur(e);
+                        v.report(check(e.currentTarget.value), "blur");
+                        onBlur?.(e);
+                    } }) }), submitName ? _jsx("input", { type: "hidden", name: submitName, value: engine.raw ?? "", disabled: disabled }) : null] }));
+});
+/** A typed-looking placeholder per country, derived from the metadata (no example numbers in /min). */
+function exampleFor(lib, country, mode) {
+    const samples = { TR: "5321234567", US: "2015550123", GB: "7400123456", DE: "15123456789", NL: "612345678", FR: "612345678" };
+    const n = samples[country];
+    if (!n)
+        return undefined;
+    const p = lib.parsePhoneNumberFromString(n, country);
+    if (!p)
+        return undefined;
+    return mode === "national" ? p.formatNational() : p.formatInternational();
+}

package/dist/components/pin-map.d.ts

@@ -0,0 +1,58 @@
+import * as React from "react";
+export type MapPinTone = "accent" | "neutral" | "info" | "success" | "warning" | "danger";
+export interface MapPin {
+    id: string;
+    lat: number;
+    lng: number;
+    /** Accessible name and callout title. */
+    label: string;
+    /** Callout body (address, status, ETA). */
+    description?: React.ReactNode;
+    tone?: MapPinTone;
+    /** Size for `variant="bubble"` (visitors, orders). */
+    value?: number;
+    /** Live ring — vehicles en route, new visitors. Off under reduced motion. */
+    pulse?: boolean;
+    /** Small glyph inside the marker (pin variant), e.g. a 12px icon or initials. */
+    icon?: React.ReactNode;
+}
+export interface PinMapBounds {
+    north: number;
+    south: number;
+    west: number;
+    east: number;
+}
+export interface PinMapProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    pins: MapPin[];
+    /** Visible area. Omit to fit every pin. Expanded to match `aspectRatio` so nothing distorts. */
+    bounds?: PinMapBounds;
+    /** Width ÷ height. Default `16 / 10`. */
+    aspectRatio?: number;
+    /** `"pin"` (default) markers, small `"dot"`s, or value-sized `"bubble"`s. */
+    variant?: "pin" | "dot" | "bubble";
+    selectedId?: string | null;
+    defaultSelectedId?: string | null;
+    onSelectedIdChange?: (id: string | null) => void;
+    /** Callout for the selected pin. Default: label + description. `false` hides it. */
+    callout?: false | ((pin: MapPin) => React.ReactNode);
+    /** Always show labels next to markers (few pins only). */
+    showLabels?: boolean;
+    /** Replace the drawn sheet with your own layer (a static tile image, an SVG of districts). */
+    backdrop?: React.ReactNode;
+    /** Hide the coordinate ticks and scale bar. */
+    bare?: boolean;
+    /** Required: what the map shows ("Stores in Istanbul"). */
+    "aria-label": string;
+}
+/**
+ * Markers on a projected sheet — stores, field jobs, vehicles, live visitors — without a tile
+ * provider. Pins are positioned in Web Mercator inside `bounds`; pass a `backdrop` to lay them
+ * over your own static map. Selection is controlled or not; arrow keys move to the nearest pin
+ * in that direction, Enter selects, Escape clears.
+ *
+ * ```tsx
+ * <PinMap aria-label="Stores" pins={stores.map((s) => ({ id: s.id, lat: s.lat, lng: s.lng, label: s.name }))}
+ *   selectedId={selected} onSelectedIdChange={setSelected} />
+ * ```
+ */
+export declare const PinMap: React.ForwardRefExoticComponent<PinMapProps & React.RefAttributes<HTMLDivElement>>;