@traky-app/ui 1.6.3 → 1.6.4

package/src/lib/geo-csc.ts

@@ -0,0 +1,82 @@
+/**
+ * Catálogo geo vía `@countrystatecity/countries-browser` (CDN / fetch).
+ * Países, provincias y ciudades; sin JSON embebido en el repo.
+ */
+import {
+  getCitiesOfState,
+  getCountries,
+  getStatesOfCountry,
+} from "@countrystatecity/countries-browser";
+
+export type GeoApiOption = {
+  code: string;
+  name: string;
+};
+
+export type GeoApiCityOption = GeoApiOption & {
+  stateCode?: string;
+  stateName?: string;
+};
+
+export async function getGeoCountries(): Promise<GeoApiOption[]> {
+  try {
+    const countries = await getCountries();
+    return (countries ?? []).map((c) => ({
+      code: c.iso2,
+      name: c.name,
+    }));
+  } catch (error) {
+    console.error("getGeoCountries:", error);
+    return [];
+  }
+}
+
+export async function getGeoStates(
+  countryCode: string,
+): Promise<GeoApiOption[]> {
+  const cc = countryCode.trim().toUpperCase();
+  if (!cc) return [];
+  try {
+    const states = await getStatesOfCountry(cc);
+    return (states ?? [])
+      .filter((s) => Boolean(s.iso2?.trim() && s.name?.trim()))
+      .map((s) => ({
+        code: s.iso2.trim(),
+        name: s.name.trim(),
+      }));
+  } catch (error) {
+    console.error("getGeoStates:", cc, error);
+    return [];
+  }
+}
+
+export async function getGeoCities(params: {
+  countryCode: string;
+  stateCode?: string | null;
+  q?: string | null;
+  limit?: number;
+}): Promise<GeoApiCityOption[]> {
+  const cc = params.countryCode.trim().toUpperCase();
+  const stateCode = params.stateCode?.trim();
+  if (!cc || !stateCode) return [];
+
+  try {
+    const cities = await getCitiesOfState(cc, stateCode);
+    const q = params.q?.trim().toLowerCase();
+    let list = cities ?? [];
+    if (q && q.length >= 2) {
+      list = list.filter((c) => c.name.toLowerCase().includes(q));
+    }
+    if (params.limit != null && params.limit > 0) {
+      list = list.slice(0, params.limit);
+    }
+    return list.map((c) => ({
+      code: c.name,
+      name: c.name,
+      stateCode,
+    }));
+  } catch (error) {
+    console.error("getGeoCities:", error);
+    return [];
+  }
+}

package/src/lib/geo-locations.ts

@@ -0,0 +1,171 @@
+import { getGeoCities, getGeoStates } from "./geo-csc";
+import { resolveCityCode } from "./geo-city-codes";
+import {
+  filterStatesForCountry,
+  mergeExtraCitiesForState,
+  resolveCscStateCode,
+  resolveStateDisplayName,
+} from "./geo-overrides";
+import {
+  DEPARTMENT_NAME_AS_CITY_COUNTRY_CODES,
+  type GeoCityOption,
+  type GeoOption,
+} from "./geo-types";
+import { normalizeSearchText } from "./utils";
+
+function mapApiCity(
+  countryCode: string,
+  city: {
+    name: string;
+    stateCode?: string;
+    stateName?: string;
+  },
+  stateNameByCode: Map<string, string>,
+): GeoCityOption {
+  const stateCode = city.stateCode ?? "";
+  return {
+    code: resolveCityCode(countryCode, city.name),
+    name: city.name,
+    stateCode: stateCode || undefined,
+    stateName:
+      city.stateName ??
+      (stateCode ? stateNameByCode.get(stateCode) : undefined),
+  };
+}
+
+export async function fetchStates(countryCode: string): Promise<GeoOption[]> {
+  const cc = countryCode.trim().toUpperCase();
+  if (!cc) return [];
+  const states = await getGeoStates(cc);
+  return filterStatesForCountry(
+    cc,
+    states.map((s) => ({ code: s.code, name: s.name })),
+  );
+}
+
+async function fetchCitiesForStateCode(
+  cc: string,
+  stateCode: string,
+): Promise<
+  Array<{ name: string; stateCode?: string; stateName?: string }>
+> {
+  const primary = await getGeoCities({
+    countryCode: cc,
+    stateCode,
+  });
+  if (primary.length > 0) return primary;
+
+  const mapped = resolveCscStateCode(cc, stateCode);
+  if (mapped !== stateCode) {
+    return getGeoCities({
+      countryCode: cc,
+      stateCode: mapped,
+    });
+  }
+  return [];
+}
+
+export async function fetchCities(
+  countryCode: string,
+  stateCode?: string | null,
+): Promise<GeoCityOption[]> {
+  const cc = countryCode.trim().toUpperCase();
+  if (!cc) return [];
+
+  // Sin estado no listamos el país entero (catálogo grande).
+  if (!stateCode?.trim()) return [];
+
+  const code = stateCode.trim();
+  const states = await fetchStates(cc);
+  const stateNameByCode = new Map(
+    states.map((s) => [
+      s.code,
+      resolveStateDisplayName(cc, s.code, s.name),
+    ]),
+  );
+
+  const apiStateCode = resolveCscStateCode(cc, code);
+  const state =
+    states.find((s) => s.code === code) ||
+    states.find((s) => s.code === apiStateCode);
+
+  const fromCatalogRaw = await fetchCitiesForStateCode(cc, code);
+  const fromCatalog = fromCatalogRaw.map((c) =>
+    mapApiCity(cc, c, stateNameByCode),
+  );
+
+  const cities = mergeExtraCitiesForState(
+    cc,
+    code,
+    mergeExtraCitiesForState(cc, apiStateCode, fromCatalog),
+  );
+
+  const withDepartment = (() => {
+    if (
+      !DEPARTMENT_NAME_AS_CITY_COUNTRY_CODES.has(cc) ||
+      !state?.name?.trim()
+    ) {
+      return cities;
+    }
+
+    const departmentName = resolveStateDisplayName(
+      cc,
+      state.code,
+      state.name,
+    ).trim();
+    const alreadyListed = cities.some(
+      (city) => city.name.trim().toLowerCase() === departmentName.toLowerCase(),
+    );
+    if (alreadyListed) return cities;
+
+    return [
+      ...cities,
+      {
+        code: resolveCityCode(cc, departmentName),
+        name: departmentName,
+        stateCode: state.code,
+        stateName: state.name,
+      },
+    ].sort((a, b) => a.name.localeCompare(b.name, "es"));
+  })();
+
+  if (cc === "ES" && code !== apiStateCode) {
+    const postalName = resolveStateDisplayName(
+      cc,
+      code,
+      state?.name ?? code,
+    );
+    return withDepartment.map((city) => ({
+      ...city,
+      stateCode: code,
+      stateName: postalName,
+    }));
+  }
+
+  return withDepartment;
+}
+
+function geoNameKey(value: string): string {
+  return normalizeSearchText(value).replace(/[^a-z0-9]/g, "");
+}
+
+export function findStateByName(
+  states: GeoOption[],
+  name?: string | null,
+): GeoOption | undefined {
+  if (!name?.trim()) return undefined;
+  const q = geoNameKey(name);
+  const code = name.trim().toUpperCase();
+  return states.find(
+    (s) => geoNameKey(s.name) === q || s.code.toUpperCase() === code,
+  );
+}
+
+export function findCityByName(
+  cities: GeoCityOption[],
+  name?: string | null,
+): GeoCityOption | undefined {
+  if (!name?.trim()) return undefined;
+  const q = geoNameKey(name);
+  return cities.find((c) => geoNameKey(c.name) === q);
+}

package/src/lib/geo-overrides.ts

@@ -0,0 +1,375 @@
+import type { GeoCityOption, GeoOption } from "./geo-types";
+
+/**
+ * Provincias de España (ISO 3166-2) para direcciones postales.
+ * `cscStateCode` es el código de comunidad en el catálogo geo (API / dataset).
+ * Castilla y León no trae ciudades en `CL`; el catálogo las agrupa en `LE`.
+ */
+export const ES_PROVINCES: Array<{
+  code: string;
+  name: string;
+  cscStateCode: string;
+}> = [
+  { code: "C", name: "A Coruña", cscStateCode: "GA" },
+  { code: "VI", name: "Álava", cscStateCode: "PV" },
+  { code: "AB", name: "Albacete", cscStateCode: "CM" },
+  { code: "A", name: "Alicante", cscStateCode: "VC" },
+  { code: "AL", name: "Almería", cscStateCode: "AN" },
+  { code: "O", name: "Asturias", cscStateCode: "AS" },
+  { code: "AV", name: "Ávila", cscStateCode: "LE" },
+  { code: "BA", name: "Badajoz", cscStateCode: "EX" },
+  { code: "PM", name: "Baleares", cscStateCode: "PM" },
+  { code: "B", name: "Barcelona", cscStateCode: "CT" },
+  { code: "BU", name: "Burgos", cscStateCode: "LE" },
+  { code: "CC", name: "Cáceres", cscStateCode: "EX" },
+  { code: "CA", name: "Cádiz", cscStateCode: "AN" },
+  { code: "S", name: "Cantabria", cscStateCode: "CB" },
+  { code: "CS", name: "Castellón", cscStateCode: "VC" },
+  { code: "CE", name: "Ceuta", cscStateCode: "CE" },
+  { code: "CR", name: "Ciudad Real", cscStateCode: "CM" },
+  { code: "CO", name: "Córdoba", cscStateCode: "AN" },
+  { code: "CU", name: "Cuenca", cscStateCode: "CM" },
+  { code: "SS", name: "Gipuzkoa", cscStateCode: "PV" },
+  { code: "GI", name: "Girona", cscStateCode: "CT" },
+  { code: "GR", name: "Granada", cscStateCode: "AN" },
+  { code: "GU", name: "Guadalajara", cscStateCode: "CM" },
+  { code: "H", name: "Huelva", cscStateCode: "AN" },
+  { code: "HU", name: "Huesca", cscStateCode: "AR" },
+  { code: "J", name: "Jaén", cscStateCode: "AN" },
+  { code: "LO", name: "La Rioja", cscStateCode: "RI" },
+  { code: "GC", name: "Las Palmas", cscStateCode: "CN" },
+  { code: "LE", name: "León", cscStateCode: "LE" },
+  { code: "L", name: "Lleida", cscStateCode: "CT" },
+  { code: "LU", name: "Lugo", cscStateCode: "GA" },
+  { code: "M", name: "Madrid", cscStateCode: "MD" },
+  { code: "MA", name: "Málaga", cscStateCode: "AN" },
+  { code: "ML", name: "Melilla", cscStateCode: "ML" },
+  { code: "MU", name: "Murcia", cscStateCode: "MC" },
+  { code: "NA", name: "Navarra", cscStateCode: "NC" },
+  { code: "OR", name: "Ourense", cscStateCode: "GA" },
+  { code: "P", name: "Palencia", cscStateCode: "LE" },
+  { code: "PO", name: "Pontevedra", cscStateCode: "GA" },
+  { code: "SA", name: "Salamanca", cscStateCode: "LE" },
+  { code: "TF", name: "Santa Cruz de Tenerife", cscStateCode: "CN" },
+  { code: "SG", name: "Segovia", cscStateCode: "LE" },
+  { code: "SE", name: "Sevilla", cscStateCode: "AN" },
+  { code: "SO", name: "Soria", cscStateCode: "LE" },
+  { code: "T", name: "Tarragona", cscStateCode: "CT" },
+  { code: "TE", name: "Teruel", cscStateCode: "AR" },
+  { code: "TO", name: "Toledo", cscStateCode: "CM" },
+  { code: "V", name: "Valencia", cscStateCode: "VC" },
+  { code: "VA", name: "Valladolid", cscStateCode: "LE" },
+  { code: "BI", name: "Bizkaia", cscStateCode: "PV" },
+  { code: "ZA", name: "Zamora", cscStateCode: "LE" },
+  { code: "Z", name: "Zaragoza", cscStateCode: "AR" },
+];
+
+/** Limita el selector de región a códigos concretos (p. ej. naciones del Reino Unido). */
+export const STATE_LIST_FILTER_BY_COUNTRY: Partial<Record<string, string[]>> = {
+  GB: ["ENG", "SCT", "WLS", "NIR"],
+  VE: [
+    "Z",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "Y",
+    "A",
+    "I",
+    "J",
+    "X",
+    "K",
+    "M",
+    "N",
+    "L",
+    "O",
+    "P",
+    "R",
+    "T",
+    "S",
+    "U",
+    "V",
+  ],
+};
+
+/** Nombres de región en español para el selector. */
+export const STATE_DISPLAY_NAME_OVERRIDES: Partial<
+  Record<string, Record<string, string>>
+> = {
+  ES: {
+    AN: "Andalucía",
+    AR: "Aragón",
+    AS: "Asturias",
+    PM: "Islas Baleares",
+    PV: "País Vasco",
+    CN: "Canarias",
+    CB: "Cantabria",
+    CL: "Castilla y León",
+    CM: "Castilla-La Mancha",
+    CT: "Cataluña",
+    CE: "Ceuta",
+    EX: "Extremadura",
+    GA: "Galicia",
+    RI: "La Rioja",
+    MD: "Comunidad de Madrid",
+    ML: "Melilla",
+    MC: "Región de Murcia",
+    NC: "Navarra",
+    VC: "Comunidad Valenciana",
+  },
+  VE: {
+    X: "La Guaira",
+  },
+};
+
+/** Ciudades que faltan en el catálogo para una región concreta. */
+export const EXTRA_CITIES_BY_STATE: Partial<
+  Record<string, Partial<Record<string, GeoCityOption[]>>>
+> = {
+  ES: {
+    B: [
+      {
+        code: "LHO",
+        name: "L'Hospitalet de Llobregat",
+        stateCode: "B",
+        stateName: "Barcelona",
+      },
+      {
+        code: "BDL",
+        name: "Badalona",
+        stateCode: "B",
+        stateName: "Barcelona",
+      },
+      {
+        code: "BCN",
+        name: "Barcelona",
+        stateCode: "B",
+        stateName: "Barcelona",
+      },
+    ],
+    AS: [
+      {
+        code: "OVD",
+        name: "Oviedo",
+        stateCode: "AS",
+        stateName: "Asturias",
+      },
+      {
+        code: "GIJ",
+        name: "Gijón",
+        stateCode: "AS",
+        stateName: "Asturias",
+      },
+      {
+        code: "AVS",
+        name: "Avilés",
+        stateCode: "AS",
+        stateName: "Asturias",
+      },
+    ],
+    CL: [
+      {
+        code: "LEN",
+        name: "León",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "BUR",
+        name: "Burgos",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "SLM",
+        name: "Salamanca",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "VLL",
+        name: "Valladolid",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "SEG",
+        name: "Segovia",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "SOR",
+        name: "Soria",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "ZMR",
+        name: "Zamora",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "AVL",
+        name: "Ávila",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+      {
+        code: "PAL",
+        name: "Palencia",
+        stateCode: "CL",
+        stateName: "Castilla y León",
+      },
+    ],
+  },
+  VE: {
+    C: [
+      {
+        code: "SFA",
+        name: "San Fernando de Apure",
+        stateCode: "C",
+        stateName: "Apure",
+      },
+      {
+        code: "GUA",
+        name: "Guasdualito",
+        stateCode: "C",
+        stateName: "Apure",
+      },
+    ],
+    G: [
+      {
+        code: "NGN",
+        name: "Naguanagua",
+        stateCode: "G",
+        stateName: "Carabobo",
+      },
+    ],
+    B: [
+      {
+        code: "LEC",
+        name: "Lechería",
+        stateCode: "B",
+        stateName: "Anzoátegui",
+      },
+    ],
+    F: [
+      {
+        code: "PZO",
+        name: "Puerto Ordaz",
+        stateCode: "F",
+        stateName: "Bolívar",
+      },
+    ],
+  },
+  GB: {
+    NIR: [
+      {
+        code: "BEL",
+        name: "Belfast",
+        stateCode: "NIR",
+        stateName: "Northern Ireland",
+      },
+      {
+        code: "DRY",
+        name: "Derry",
+        stateCode: "NIR",
+        stateName: "Northern Ireland",
+      },
+      {
+        code: "LSB",
+        name: "Lisburn",
+        stateCode: "NIR",
+        stateName: "Northern Ireland",
+      },
+      {
+        code: "NEW",
+        name: "Newry",
+        stateCode: "NIR",
+        stateName: "Northern Ireland",
+      },
+    ],
+  },
+};
+
+export function resolveCscStateCode(
+  countryCode: string,
+  stateCode: string,
+): string {
+  const cc = countryCode.trim().toUpperCase();
+  const code = stateCode.trim();
+  if (!code) return code;
+  if (cc === "ES") {
+    return (
+      ES_PROVINCES.find((province) => province.code === code)?.cscStateCode ??
+      code
+    );
+  }
+  return code;
+}
+
+export function resolveStateDisplayName(
+  countryCode: string,
+  stateCode: string,
+  defaultName: string,
+): string {
+  const cc = countryCode.trim().toUpperCase();
+  const code = stateCode.trim();
+  const provinceName = ES_PROVINCES.find(
+    (province) => cc === "ES" && province.code === code,
+  )?.name;
+  return (
+    provinceName ||
+    STATE_DISPLAY_NAME_OVERRIDES[cc]?.[code]?.trim() ||
+    defaultName
+  );
+}
+
+export function filterStatesForCountry(
+  countryCode: string,
+  states: GeoOption[],
+): GeoOption[] {
+  const cc = countryCode.trim().toUpperCase();
+  if (cc === "ES") {
+    return ES_PROVINCES.map((province) => ({
+      code: province.code,
+      name: province.name,
+    }));
+  }
+
+  const allowed = STATE_LIST_FILTER_BY_COUNTRY[cc];
+  const filtered = allowed?.length
+    ? states.filter((state) => new Set(allowed).has(state.code))
+    : states;
+
+  return filtered.map((state) => ({
+    ...state,
+    name: resolveStateDisplayName(cc, state.code, state.name),
+  }));
+}
+
+export function mergeExtraCitiesForState(
+  countryCode: string,
+  stateCode: string,
+  cities: GeoCityOption[],
+): GeoCityOption[] {
+  const extras = EXTRA_CITIES_BY_STATE[countryCode]?.[stateCode];
+  if (!extras?.length) return cities;
+
+  const seen = new Set(cities.map((city) => city.name.trim().toLowerCase()));
+  const merged = [...cities];
+
+  for (const city of extras) {
+    const key = city.name.trim().toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(city);
+  }
+
+  return merged.sort((a, b) => a.name.localeCompare(b.name, "es"));
+}

package/src/lib/geo-types.ts

@@ -0,0 +1,34 @@
+export type GeoOption = {
+  code: string;
+  name: string;
+};
+
+export type GeoCityOption = GeoOption & {
+  stateCode?: string;
+  stateName?: string;
+};
+
+/**
+ * Países donde el formulario usa catálogo CSC (CDN) con provincia/estado primero.
+ */
+export function usesGeoSearch(countryCode?: string | null): boolean {
+  return Boolean(countryCode?.trim() && countryCode.trim().length === 2);
+}
+
+/** Provincia/estado antes que ciudad (evita listar ciudades de país entero). */
+export function isStateFirstCountry(countryCode?: string | null): boolean {
+  return usesGeoSearch(countryCode);
+}
+
+/**
+ * Países donde el nombre del departamento se ofrece también como ciudad
+ * (p. ej. Chontales en Nicaragua no existe como municipio en el catálogo).
+ */
+export const DEPARTMENT_NAME_AS_CITY_COUNTRY_CODES = new Set([
+  "CO",
+  "ES",
+  "GB",
+  "NI",
+  "PE",
+  "VE",
+]);