@joelbarron/react-web-dev-kit 0.1.9 → 0.1.10

package/dist/hooks/useJBEntityFormController.js

@@ -0,0 +1,156 @@
+import { useEffect, useRef, useState } from 'react';
+const DEFAULT_MESSAGES = {
+    loadError: 'No se pudo cargar el registro.',
+    saveError: 'No se pudo guardar el registro.',
+    deleteError: 'No se pudo eliminar el registro.',
+    createSuccess: 'Registro creado correctamente.',
+    updateSuccess: 'Registro actualizado correctamente.',
+    deleteSuccess: 'Registro eliminado correctamente.'
+};
+export function useJBEntityFormController(options) {
+    const { isNew, itemId, defaultValues, retrieveQuery, reset, mapRetrieveToValues, createItem, updateItem, deleteItem, navigateToList, navigateToEdit, onShowError, onShowSuccess, getCreatedId, messages } = options;
+    const mapRetrieveToValuesRef = useRef(mapRetrieveToValues);
+    const onShowErrorRef = useRef(onShowError);
+    const navigateToListRef = useRef(navigateToList);
+    useEffect(() => {
+        mapRetrieveToValuesRef.current = mapRetrieveToValues;
+    }, [mapRetrieveToValues]);
+    useEffect(() => {
+        onShowErrorRef.current = onShowError;
+    }, [onShowError]);
+    useEffect(() => {
+        navigateToListRef.current = navigateToList;
+    }, [navigateToList]);
+    const resolvedMessages = {
+        ...DEFAULT_MESSAGES,
+        ...messages
+    };
+    const [formDisabled, setFormDisabled] = useState(!isNew);
+    const [loadedValues, setLoadedValues] = useState(defaultValues);
+    const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+    const skipRetrieveErrorAfterDeleteRef = useRef(false);
+    useEffect(() => {
+        if (isNew) {
+            reset(defaultValues);
+            setLoadedValues(defaultValues);
+            setFormDisabled(false);
+            return;
+        }
+        if (retrieveQuery.isError) {
+            if (skipRetrieveErrorAfterDeleteRef.current) {
+                return;
+            }
+            onShowErrorRef.current(retrieveQuery.error, resolvedMessages.loadError);
+            navigateToListRef.current();
+            return;
+        }
+        if (!retrieveQuery.data) {
+            return;
+        }
+        const values = mapRetrieveToValuesRef.current(retrieveQuery.data);
+        setLoadedValues(values);
+        reset(values);
+        setFormDisabled(true);
+    }, [
+        defaultValues,
+        isNew,
+        reset,
+        resolvedMessages.loadError,
+        retrieveQuery.data,
+        retrieveQuery.error,
+        retrieveQuery.isError
+    ]);
+    const handleSave = async (formData) => {
+        try {
+            if (isNew) {
+                const response = await createItem(formData);
+                onShowSuccess?.(resolvedMessages.createSuccess);
+                const createdId = getCreatedId?.(response) ?? response?.data?.id;
+                if (createdId !== undefined && createdId !== null) {
+                    navigateToEdit(createdId);
+                }
+                return;
+            }
+            if (!itemId) {
+                return;
+            }
+            await updateItem(itemId, formData);
+            setLoadedValues(formData);
+            setFormDisabled(true);
+            onShowSuccess?.(resolvedMessages.updateSuccess);
+        }
+        catch (error) {
+            onShowError(error, resolvedMessages.saveError);
+        }
+    };
+    const handleDelete = async () => {
+        if (!itemId) {
+            return;
+        }
+        try {
+            skipRetrieveErrorAfterDeleteRef.current = true;
+            await deleteItem(itemId);
+            setDeleteDialogOpen(false);
+            onShowSuccess?.(resolvedMessages.deleteSuccess);
+            navigateToList();
+        }
+        catch (error) {
+            skipRetrieveErrorAfterDeleteRef.current = false;
+            onShowError(error, resolvedMessages.deleteError);
+        }
+    };
+    const handleStartEdit = () => {
+        setFormDisabled(false);
+    };
+    const handleCancelEdit = () => {
+        if (isNew) {
+            return;
+        }
+        reset(loadedValues);
+        setFormDisabled(true);
+    };
+    const handleSubmitOnEnter = (event, submit) => {
+        if (event.key !== 'Enter') {
+            return;
+        }
+        if (event.defaultPrevented) {
+            return;
+        }
+        if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) {
+            return;
+        }
+        if (formDisabled || deleteDialogOpen) {
+            return;
+        }
+        const targetElement = event.target;
+        if (targetElement instanceof HTMLElement) {
+            const tagName = targetElement.tagName.toLowerCase();
+            const inputType = targetElement.getAttribute('type')?.toLowerCase();
+            const role = targetElement.getAttribute('role')?.toLowerCase();
+            const ariaAutocomplete = targetElement.getAttribute('aria-autocomplete')?.toLowerCase();
+            if (tagName === 'textarea' ||
+                tagName === 'button' ||
+                role === 'button' ||
+                role === 'combobox' ||
+                ariaAutocomplete === 'list' ||
+                targetElement.isContentEditable ||
+                inputType === 'submit' ||
+                inputType === 'button') {
+                return;
+            }
+        }
+        event.preventDefault();
+        submit();
+    };
+    return {
+        formDisabled,
+        loadedValues,
+        deleteDialogOpen,
+        setDeleteDialogOpen,
+        handleStartEdit,
+        handleCancelEdit,
+        handleSave,
+        handleDelete,
+        handleSubmitOnEnter
+    };
+}

package/dist/hooks/useJBRedirect.d.ts

@@ -0,0 +1,10 @@
+import { DependencyList } from 'react';
+export type UseJBRedirectOptions = {
+    enabled?: boolean;
+    shouldRedirect: () => boolean;
+    getTargetPath: () => string;
+    navigate: (path: string) => void;
+    deps?: DependencyList;
+};
+export declare const useJBRedirect: (options: UseJBRedirectOptions) => void;
+//# sourceMappingURL=useJBRedirect.d.ts.map

package/dist/hooks/useJBRedirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useJBRedirect.d.ts","sourceRoot":"","sources":["../../src/hooks/useJBRedirect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAa,MAAM,OAAO,CAAC;AAElD,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,MAAM,OAAO,CAAC;IAC9B,aAAa,EAAE,MAAM,MAAM,CAAC;IAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,oBAAoB,KAAG,IAc7D,CAAC"}

package/dist/hooks/useJBRedirect.js

@@ -0,0 +1,11 @@
+import { useEffect } from 'react';
+export const useJBRedirect = (options) => {
+    const { enabled = true, shouldRedirect, getTargetPath, navigate, deps = [] } = options;
+    useEffect(() => {
+        if (!enabled)
+            return;
+        if (!shouldRedirect())
+            return;
+        navigate(getTargetPath());
+    }, [enabled, getTargetPath, navigate, shouldRedirect, ...deps]);
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './auth';
+export * from './config';
+export * from './core';
+export * from './forms';
+export * from './grid';
+export * from './hooks';
+export * from './query';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './auth';
+export * from './config';
+export * from './core';
+export * from './forms';
+export * from './grid';
+export * from './hooks';
+export * from './query';
+export * from './utils';

package/dist/query/createQueryClient.d.ts

@@ -0,0 +1,8 @@
+import { DefaultOptions, QueryClient, QueryClientConfig } from '@tanstack/react-query';
+export type CreateReactWebQueryClientOptions = {
+    onUnauthorized?: (error: unknown) => void;
+    defaultOptions?: DefaultOptions;
+    config?: Omit<QueryClientConfig, 'defaultOptions' | 'queryCache' | 'mutationCache'>;
+};
+export declare const createReactWebQueryClient: (options?: CreateReactWebQueryClientOptions) => QueryClient;
+//# sourceMappingURL=createQueryClient.d.ts.map

package/dist/query/createQueryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createQueryClient.d.ts","sourceRoot":"","sources":["../../src/query/createQueryClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAGd,WAAW,EACX,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAI/B,MAAM,MAAM,gCAAgC,GAAG;IAC7C,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,MAAM,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,gBAAgB,GAAG,YAAY,GAAG,eAAe,CAAC,CAAC;CACrF,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,UAAU,gCAAgC,KACzC,WAuBF,CAAC"}

package/dist/query/createQueryClient.js

@@ -0,0 +1,25 @@
+import { MutationCache, QueryCache, QueryClient } from '@tanstack/react-query';
+import { isUnauthorizedError } from './http';
+export const createReactWebQueryClient = (options) => {
+    const onError = (error) => {
+        if (options?.onUnauthorized && isUnauthorizedError(error)) {
+            options.onUnauthorized(error);
+        }
+    };
+    return new QueryClient({
+        ...(options?.config ?? {}),
+        defaultOptions: {
+            queries: {
+                retry: 1,
+                refetchOnWindowFocus: false,
+                ...(options?.defaultOptions?.queries ?? {})
+            },
+            mutations: {
+                retry: 0,
+                ...(options?.defaultOptions?.mutations ?? {})
+            }
+        },
+        queryCache: new QueryCache({ onError }),
+        mutationCache: new MutationCache({ onError })
+    });
+};

package/dist/query/http.d.ts

@@ -0,0 +1,3 @@
+export declare const extractHttpStatusCode: (error: unknown) => number | null;
+export declare const isUnauthorizedError: (error: unknown) => boolean;
+//# sourceMappingURL=http.d.ts.map

package/dist/query/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/query/http.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,IAY/D,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,OACf,CAAC"}

package/dist/query/http.js

@@ -0,0 +1,12 @@
+export const extractHttpStatusCode = (error) => {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    const maybeResponse = error.response;
+    if (!maybeResponse || typeof maybeResponse !== 'object') {
+        return null;
+    }
+    const maybeStatus = maybeResponse.status;
+    return typeof maybeStatus === 'number' ? maybeStatus : null;
+};
+export const isUnauthorizedError = (error) => extractHttpStatusCode(error) === 401;

package/dist/query/index.d.ts

@@ -0,0 +1,4 @@
+export * from './http';
+export * from './createQueryClient';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/query/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC"}

package/dist/query/index.js

@@ -0,0 +1,3 @@
+export * from './http';
+export * from './createQueryClient';
+export * from './types';

package/dist/query/types.d.ts

@@ -0,0 +1,7 @@
+export type PaginatedResponse<T> = {
+    count: number;
+    next: string | null;
+    previous: string | null;
+    results: T[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/query/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/query/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,CAAC,EAAE,CAAC;CACd,CAAC"}

package/dist/query/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/errors.d.ts

@@ -0,0 +1,10 @@
+export type ApiErrorData = {
+    detail?: string;
+    message?: string;
+    nonFieldErrors?: string[];
+    non_field_errors?: string[];
+    errors?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+export declare const getApiErrorMessage: (error: unknown, fallback: string) => string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAkBF,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,EAAE,UAAU,MAAM,KAAG,MAgDrE,CAAC"}

package/dist/utils/errors.js

@@ -0,0 +1,55 @@
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const readFirstString = (value) => {
+    if (typeof value === 'string' && value.trim())
+        return value;
+    if (Array.isArray(value)) {
+        const firstString = value.find((item) => typeof item === 'string' && item.trim());
+        return typeof firstString === 'string' ? firstString : undefined;
+    }
+    if (isRecord(value)) {
+        if (typeof value.detail === 'string' && value.detail.trim())
+            return value.detail;
+        if (typeof value.message === 'string' && value.message.trim())
+            return value.message;
+    }
+    return undefined;
+};
+export const getApiErrorMessage = (error, fallback) => {
+    const raw = error;
+    const payload = (raw.response?.data ?? raw.data);
+    if (!payload) {
+        return fallback;
+    }
+    if (typeof payload === 'string' && payload.trim()) {
+        return payload;
+    }
+    if (!isRecord(payload)) {
+        return raw.message?.trim() || fallback;
+    }
+    const data = payload;
+    const detail = readFirstString(data.detail);
+    if (detail)
+        return detail;
+    const message = readFirstString(data.message);
+    if (message)
+        return message;
+    const nonField = readFirstString(data.nonFieldErrors) ?? readFirstString(data.non_field_errors);
+    if (nonField)
+        return nonField;
+    if (isRecord(data.errors)) {
+        for (const value of Object.values(data.errors)) {
+            const nestedMessage = readFirstString(value);
+            if (nestedMessage)
+                return nestedMessage;
+        }
+    }
+    for (const [key, value] of Object.entries(data)) {
+        if (['detail', 'message', 'nonFieldErrors', 'non_field_errors', 'errors'].includes(key)) {
+            continue;
+        }
+        const nestedMessage = readFirstString(value);
+        if (nestedMessage)
+            return nestedMessage;
+    }
+    return raw.message?.trim() || fallback;
+};

package/dist/utils/format.d.ts

@@ -0,0 +1,4 @@
+export declare const formatCurrency: (value: number, currency?: string, locale?: string) => string;
+export declare const formatDate: (date: string | number | Date | null | undefined, locale?: string) => string;
+export declare const formatDateTime: (date: string | number | Date | null | undefined, locale?: string) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/utils/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/utils/format.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,EAAE,iBAAgB,EAAE,eAAgB,KAAG,MAKlF,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,MAAM,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,EAC/C,eAAgB,KACf,MAKF,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,EAC/C,eAAgB,KACf,MAWF,CAAC"}

package/dist/utils/format.js

@@ -0,0 +1,28 @@
+export const formatCurrency = (value, currency = 'USD', locale = 'en-US') => {
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency
+    }).format(value || 0);
+};
+export const formatDate = (date, locale = 'en-US') => {
+    if (!date)
+        return '';
+    const parsed = new Date(date);
+    if (Number.isNaN(parsed.getTime()))
+        return '';
+    return new Intl.DateTimeFormat(locale).format(parsed);
+};
+export const formatDateTime = (date, locale = 'en-US') => {
+    if (!date)
+        return '';
+    const parsed = new Date(date);
+    if (Number.isNaN(parsed.getTime()))
+        return '';
+    return new Intl.DateTimeFormat(locale, {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit'
+    }).format(parsed);
+};

package/dist/utils/geo.d.ts

@@ -0,0 +1,9 @@
+export type JBGeoOption = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+export declare const jbCountryCodeToFlagEmoji: (countryCode: string) => string;
+export declare const getJBCountryOptions: (locale?: string) => JBGeoOption[];
+export declare const getJBStateOptionsByCountry: (countryCode?: string | null) => JBGeoOption[];
+//# sourceMappingURL=geo.d.ts.map

package/dist/utils/geo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geo.d.ts","sourceRoot":"","sources":["../../src/utils/geo.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AA4KF,eAAO,MAAM,wBAAwB,GAAI,aAAa,MAAM,KAAG,MAQ9D,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,eAAgB,KAAG,WAAW,EAkBjE,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,cAAc,MAAM,GAAG,IAAI,KAAG,WAAW,EAOnF,CAAC"}

package/dist/utils/geo.js

@@ -0,0 +1,186 @@
+const COUNTRY_PRIORITY = ['MX', 'US', 'ES', 'AR', 'CO', 'CL', 'PE', 'EC', 'BR', 'CA'];
+const FALLBACK_COUNTRY_CODES = [
+    'MX',
+    'US',
+    'CA',
+    'ES',
+    'AR',
+    'CO',
+    'CL',
+    'PE',
+    'EC',
+    'UY',
+    'PY',
+    'BO',
+    'BR',
+    'FR',
+    'DE',
+    'IT',
+    'GB',
+    'PT'
+];
+const MEXICO_STATES = [
+    { value: 'Aguascalientes', label: 'Aguascalientes' },
+    { value: 'Baja California', label: 'Baja California' },
+    { value: 'Baja California Sur', label: 'Baja California Sur' },
+    { value: 'Campeche', label: 'Campeche' },
+    { value: 'Chiapas', label: 'Chiapas' },
+    { value: 'Chihuahua', label: 'Chihuahua' },
+    { value: 'Ciudad de Mexico', label: 'Ciudad de Mexico' },
+    { value: 'Coahuila', label: 'Coahuila' },
+    { value: 'Colima', label: 'Colima' },
+    { value: 'Durango', label: 'Durango' },
+    { value: 'Estado de Mexico', label: 'Estado de Mexico' },
+    { value: 'Guanajuato', label: 'Guanajuato' },
+    { value: 'Guerrero', label: 'Guerrero' },
+    { value: 'Hidalgo', label: 'Hidalgo' },
+    { value: 'Jalisco', label: 'Jalisco' },
+    { value: 'Michoacan', label: 'Michoacan' },
+    { value: 'Morelos', label: 'Morelos' },
+    { value: 'Nayarit', label: 'Nayarit' },
+    { value: 'Nuevo Leon', label: 'Nuevo Leon' },
+    { value: 'Oaxaca', label: 'Oaxaca' },
+    { value: 'Puebla', label: 'Puebla' },
+    { value: 'Queretaro', label: 'Queretaro' },
+    { value: 'Quintana Roo', label: 'Quintana Roo' },
+    { value: 'San Luis Potosi', label: 'San Luis Potosi' },
+    { value: 'Sinaloa', label: 'Sinaloa' },
+    { value: 'Sonora', label: 'Sonora' },
+    { value: 'Tabasco', label: 'Tabasco' },
+    { value: 'Tamaulipas', label: 'Tamaulipas' },
+    { value: 'Tlaxcala', label: 'Tlaxcala' },
+    { value: 'Veracruz', label: 'Veracruz' },
+    { value: 'Yucatan', label: 'Yucatan' },
+    { value: 'Zacatecas', label: 'Zacatecas' }
+];
+const UNITED_STATES = [
+    { value: 'Alabama', label: 'Alabama' },
+    { value: 'Alaska', label: 'Alaska' },
+    { value: 'Arizona', label: 'Arizona' },
+    { value: 'Arkansas', label: 'Arkansas' },
+    { value: 'California', label: 'California' },
+    { value: 'Colorado', label: 'Colorado' },
+    { value: 'Connecticut', label: 'Connecticut' },
+    { value: 'Delaware', label: 'Delaware' },
+    { value: 'Florida', label: 'Florida' },
+    { value: 'Georgia', label: 'Georgia' },
+    { value: 'Hawaii', label: 'Hawaii' },
+    { value: 'Idaho', label: 'Idaho' },
+    { value: 'Illinois', label: 'Illinois' },
+    { value: 'Indiana', label: 'Indiana' },
+    { value: 'Iowa', label: 'Iowa' },
+    { value: 'Kansas', label: 'Kansas' },
+    { value: 'Kentucky', label: 'Kentucky' },
+    { value: 'Louisiana', label: 'Louisiana' },
+    { value: 'Maine', label: 'Maine' },
+    { value: 'Maryland', label: 'Maryland' },
+    { value: 'Massachusetts', label: 'Massachusetts' },
+    { value: 'Michigan', label: 'Michigan' },
+    { value: 'Minnesota', label: 'Minnesota' },
+    { value: 'Mississippi', label: 'Mississippi' },
+    { value: 'Missouri', label: 'Missouri' },
+    { value: 'Montana', label: 'Montana' },
+    { value: 'Nebraska', label: 'Nebraska' },
+    { value: 'Nevada', label: 'Nevada' },
+    { value: 'New Hampshire', label: 'New Hampshire' },
+    { value: 'New Jersey', label: 'New Jersey' },
+    { value: 'New Mexico', label: 'New Mexico' },
+    { value: 'New York', label: 'New York' },
+    { value: 'North Carolina', label: 'North Carolina' },
+    { value: 'North Dakota', label: 'North Dakota' },
+    { value: 'Ohio', label: 'Ohio' },
+    { value: 'Oklahoma', label: 'Oklahoma' },
+    { value: 'Oregon', label: 'Oregon' },
+    { value: 'Pennsylvania', label: 'Pennsylvania' },
+    { value: 'Rhode Island', label: 'Rhode Island' },
+    { value: 'South Carolina', label: 'South Carolina' },
+    { value: 'South Dakota', label: 'South Dakota' },
+    { value: 'Tennessee', label: 'Tennessee' },
+    { value: 'Texas', label: 'Texas' },
+    { value: 'Utah', label: 'Utah' },
+    { value: 'Vermont', label: 'Vermont' },
+    { value: 'Virginia', label: 'Virginia' },
+    { value: 'Washington', label: 'Washington' },
+    { value: 'West Virginia', label: 'West Virginia' },
+    { value: 'Wisconsin', label: 'Wisconsin' },
+    { value: 'Wyoming', label: 'Wyoming' }
+];
+const STATES_BY_COUNTRY = {
+    MX: MEXICO_STATES,
+    US: UNITED_STATES
+};
+const countryOptionsCache = new Map();
+const isValidCountryCode = (code) => /^[A-Z]{2}$/.test(code);
+const sortCountryCodes = (countryCodes) => {
+    return [...countryCodes].sort((left, right) => {
+        const leftIndex = COUNTRY_PRIORITY.indexOf(left);
+        const rightIndex = COUNTRY_PRIORITY.indexOf(right);
+        if (leftIndex >= 0 && rightIndex >= 0) {
+            return leftIndex - rightIndex;
+        }
+        if (leftIndex >= 0) {
+            return -1;
+        }
+        if (rightIndex >= 0) {
+            return 1;
+        }
+        return left.localeCompare(right);
+    });
+};
+const resolveCountryCodes = () => {
+    const intlValuesOf = Intl.supportedValuesOf;
+    if (typeof intlValuesOf === 'function') {
+        try {
+            // NOTE: "region" is not supported in all runtimes and may throw RangeError.
+            const values = intlValuesOf('region')
+                .map((value) => value.toUpperCase())
+                .filter((value) => isValidCountryCode(value));
+            if (values.length > 0) {
+                return sortCountryCodes(Array.from(new Set(values)));
+            }
+        }
+        catch (_error) {
+            // Fallback list is used when runtime does not support region values.
+        }
+    }
+    return sortCountryCodes(FALLBACK_COUNTRY_CODES);
+};
+const resolveCountryName = (countryCode, locale) => {
+    if (typeof Intl.DisplayNames !== 'function') {
+        return countryCode;
+    }
+    const displayNames = new Intl.DisplayNames([locale], { type: 'region' });
+    return displayNames.of(countryCode) ?? countryCode;
+};
+export const jbCountryCodeToFlagEmoji = (countryCode) => {
+    const normalized = countryCode.trim().toUpperCase();
+    if (!isValidCountryCode(normalized)) {
+        return '🏳️';
+    }
+    const points = [...normalized].map((char) => 127397 + char.charCodeAt(0));
+    return String.fromCodePoint(...points);
+};
+export const getJBCountryOptions = (locale = 'es-MX') => {
+    const cacheKey = locale.toLowerCase();
+    const cached = countryOptionsCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const options = resolveCountryCodes().map((countryCode) => {
+        const countryName = resolveCountryName(countryCode, locale);
+        const flag = jbCountryCodeToFlagEmoji(countryCode);
+        return {
+            value: countryCode,
+            label: `${flag} ${countryName}`
+        };
+    });
+    countryOptionsCache.set(cacheKey, options);
+    return options;
+};
+export const getJBStateOptionsByCountry = (countryCode) => {
+    const normalizedCountry = (countryCode ?? '').trim().toUpperCase();
+    if (!normalizedCountry) {
+        return [];
+    }
+    return STATES_BY_COUNTRY[normalizedCountry] ?? [];
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './query';
+export * from './format';
+export * from './regex';
+export * from './errors';
+export * from './geo';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+export * from './query';
+export * from './format';
+export * from './regex';
+export * from './errors';
+export * from './geo';

package/dist/utils/query.d.ts

@@ -0,0 +1,2 @@
+export declare const objectToQueryString: (obj: Record<string, unknown>) => string;
+//# sourceMappingURL=query.d.ts.map

package/dist/utils/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/utils/query.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAIrD,CAAC"}

package/dist/utils/query.js

@@ -0,0 +1,4 @@
+export const objectToQueryString = (obj) => Object.keys(obj)
+    .filter((key) => obj[key] !== undefined && obj[key] !== null)
+    .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(String(obj[key]))}`)
+    .join('&');

package/dist/utils/regex.d.ts

@@ -0,0 +1,7 @@
+export declare const JB_PHONE_REGEX: RegExp;
+export declare const JB_ZIP_CODE_REGEX: RegExp;
+export declare const JB_NUMBER_REGEX: RegExp;
+export declare const JB_DECIMAL_NUMBER_REGEX: RegExp;
+export declare const JB_EMAIL_REGEX: RegExp;
+export declare const JB_PASSWORD_REGEX: RegExp;
+//# sourceMappingURL=regex.d.ts.map

package/dist/utils/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/utils/regex.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,QACgF,CAAC;AAE5G,eAAO,MAAM,iBAAiB,QAAY,CAAC;AAC3C,eAAO,MAAM,eAAe,QAAa,CAAC;AAC1C,eAAO,MAAM,uBAAuB,QAAoB,CAAC;AACzD,eAAO,MAAM,cAAc,QAAqD,CAAC;AACjF,eAAO,MAAM,iBAAiB,QACiD,CAAC"}