@traky-app/ui 1.6.1 → 1.6.4

package/registry/traky/lib/geo-city-codes.ts

@@ -0,0 +1,234 @@
+/**
+ * Códigos cortos de ciudad (logística / etiquetas).
+ * Clave: `{ISO2}:{NombreCiudad}` → código de 3 letras.
+ */
+const CITY_CODE_OVERRIDES: Record<string, string> = {
+  // Ecuador
+  "EC:Guayaquil": "GYE",
+  "EC:Quito": "UIO",
+  "EC:Cuenca": "CUE",
+  "EC:Machala": "MCH",
+  "EC:Manta": "MEC",
+  "EC:Portoviejo": "PVO",
+  "EC:Ambato": "ATF",
+  "EC:Loja": "LOH",
+  "EC:Esmeraldas": "ESM",
+  "EC:Ibarra": "IBB",
+  "EC:Riobamba": "RIB",
+  "EC:Santo Domingo": "STD",
+  "EC:Milagro": "MLG",
+  "EC:Durán": "DUR",
+  "EC:Samborondón": "SBO",
+  // Colombia
+  "CO:Bogotá": "BOG",
+  "CO:Bogota": "BOG",
+  "CO:Medellín": "MDE",
+  "CO:Medellin": "MDE",
+  "CO:Cali": "CAL",
+  "CO:Barranquilla": "BAQ",
+  "CO:Cartagena": "CTG",
+  "CO:Bucaramanga": "BGA",
+  "CO:Pereira": "PEI",
+  "CO:Manizales": "MZL",
+  "CO:Cúcuta": "CUC",
+  "CO:Cucuta": "CUC",
+  "CO:Ibagué": "IBE",
+  "CO:Ibague": "IBE",
+  "CO:Santa Marta": "SMR",
+  // México
+  "MX:Ciudad de México": "CDM",
+  "MX:Guadalajara": "GDL",
+  "MX:Monterrey": "MTY",
+  "MX:Puebla": "PBC",
+  "MX:Tijuana": "TIJ",
+  "MX:León": "BJX",
+  "MX:Leon": "BJX",
+  // Perú
+  "PE:Lima": "LIM",
+  "PE:Arequipa": "AQP",
+  "PE:Trujillo": "TRU",
+  "PE:Cusco": "CUZ",
+  // Chile
+  "CL:Santiago": "SCL",
+  "CL:Valparaíso": "VAP",
+  "CL:Valparaiso": "VAP",
+  "CL:Concepción": "CCP",
+  "CL:Concepcion": "CCP",
+  // Argentina
+  "AR:Buenos Aires": "BUE",
+  "AR:Córdoba": "COR",
+  "AR:Cordoba": "COR",
+  "AR:Rosario": "ROS",
+  "AR:Mendoza": "MDZ",
+  // USA (casilleros)
+  "US:Miami": "MIA",
+  "US:New York": "NYC",
+  "US:Los Angeles": "LAX",
+  "US:Houston": "HOU",
+  "US:Chicago": "ORD",
+  // Nicaragua
+  "NI:Chontales": "CHO",
+  "NI:Juigalpa": "JUI",
+  "NI:Managua": "MGA",
+  "NI:León": "LEN",
+  "NI:Leon": "LEN",
+  "NI:Granada": "GRA",
+  "NI:Masaya": "MSY",
+  "NI:Matagalpa": "MTG",
+  // Reino Unido
+  "GB:London": "LON",
+  "GB:Greater London": "LON",
+  "GB:Manchester": "MAN",
+  "GB:Birmingham": "BHX",
+  "GB:Liverpool": "LIV",
+  "GB:Leeds": "LDS",
+  "GB:Glasgow": "GLA",
+  "GB:Edinburgh": "EDI",
+  "GB:Cardiff": "CDF",
+  "GB:Belfast": "BEL",
+  "GB:England": "ENG",
+  "GB:Scotland": "SCT",
+  "GB:Wales": "WLS",
+  "GB:Northern Ireland": "NIR",
+  // España
+  "ES:Madrid": "MAD",
+  "ES:Barcelona": "BCN",
+  "ES:L'Hospitalet de Llobregat": "LHO",
+  "ES:LHospitalet de Llobregat": "LHO",
+  "ES:Hospitalet de Llobregat": "LHO",
+  "ES:Valencia": "VLC",
+  "ES:Sevilla": "SVQ",
+  "ES:Zaragoza": "ZAZ",
+  "ES:Bilbao": "BIO",
+  "ES:Malaga": "AGP",
+  "ES:Málaga": "AGP",
+  "ES:Murcia": "MJV",
+  "ES:Palma": "PMI",
+  "ES:Las Palmas de Gran Canaria": "LPA",
+  "ES:Las Palmas": "LPA",
+  "ES:Alicante": "ALC",
+  "ES:Cordoba": "COR",
+  "ES:Córdoba": "COR",
+  "ES:Valladolid": "VLL",
+  "ES:Vigo": "VGO",
+  "ES:Gijon": "GIJ",
+  "ES:Gijón": "GIJ",
+  "ES:Oviedo": "OVD",
+  "ES:Leon": "LEN",
+  "ES:León": "LEN",
+  "ES:Burgos": "BUR",
+  "ES:Salamanca": "SLM",
+  "ES:San Sebastian": "EAS",
+  "ES:San Sebastián": "EAS",
+  "ES:Santander": "SDR",
+  "ES:Pamplona": "PNA",
+  "ES:Granada": "GRX",
+  "ES:Toledo": "TOL",
+  "ES:Badajoz": "BJZ",
+  "ES:Castilla y Leon": "CLY",
+  "ES:Castilla y León": "CLY",
+  "ES:Andalucia": "AND",
+  "ES:Andalucía": "AND",
+  "ES:Cataluna": "CAT",
+  "ES:Cataluña": "CAT",
+  "ES:Comunidad Valenciana": "VAL",
+  "ES:Comunidad de Madrid": "MAD",
+  "ES:Region de Murcia": "MUR",
+  "ES:Región de Murcia": "MUR",
+  "ES:Pais Vasco": "PV",
+  "ES:País Vasco": "PV",
+  "ES:Galicia": "GAL",
+  "ES:Extremadura": "EXT",
+  "ES:Asturias": "AST",
+  "ES:Navarra": "NAV",
+  "ES:Cantabria": "CAN",
+  "ES:La Rioja": "RIO",
+  "ES:Islas Baleares": "BAL",
+  "ES:Canarias": "CNR",
+  "ES:Ceuta": "CEU",
+  "ES:Melilla": "MEL",
+  // Venezuela
+  "VE:Caracas": "CCS",
+  "VE:Maracaibo": "MAR",
+  "VE:Valencia": "VLN",
+  "VE:Barquisimeto": "BRM",
+  "VE:Maracay": "MYC",
+  "VE:San Cristobal": "SCI",
+  "VE:San Cristóbal": "SCI",
+  "VE:Puerto La Cruz": "PLC",
+  "VE:Maturin": "MUN",
+  "VE:Maturín": "MUN",
+  "VE:Barcelona": "BLA",
+  "VE:Ciudad Guayana": "CGY",
+  "VE:Puerto Ordaz": "PZO",
+  "VE:Merida": "MER",
+  "VE:Mérida": "MER",
+  "VE:Punto Fijo": "PFJ",
+  "VE:Porlamar": "PMV",
+  "VE:San Fernando de Apure": "SFA",
+  "VE:Naguanagua": "NGN",
+  "VE:Lecheria": "LEC",
+  "VE:Lechería": "LEC",
+  "VE:Cumana": "CUM",
+  "VE:Cumaná": "CUM",
+  "VE:Coro": "COR",
+  "VE:Barinas": "BAR",
+  "VE:Trujillo": "TRU",
+  "VE:Valera": "VLR",
+  "VE:San Felipe": "SFP",
+  "VE:La Guaira": "LGR",
+  "VE:Maiquetia": "MAI",
+  "VE:Maiquetía": "MAI",
+  "VE:Distrito Capital": "CCS",
+  "VE:Apure": "APU",
+  "VE:Anzoategui": "ANZ",
+  "VE:Anzoátegui": "ANZ",
+  "VE:Aragua": "ARA",
+  "VE:Bolivar": "BOL",
+  "VE:Bolívar": "BOL",
+  "VE:Carabobo": "CAR",
+  "VE:Miranda": "MIR",
+  "VE:Zulia": "ZUL",
+  "VE:Tachira": "TAC",
+  "VE:Táchira": "TAC",
+  "VE:Lara": "LAR",
+  "VE:Monagas": "MON",
+  "VE:Nueva Esparta": "NEP",
+  "VE:Falcon": "FAL",
+  "VE:Falcón": "FAL",
+  "VE:Guarico": "GUA",
+  "VE:Guárico": "GUA",
+  "VE:Portuguesa": "POR",
+  "VE:Sucre": "SUC",
+  "VE:Yaracuy": "YAR",
+  "VE:Amazonas": "AMZ",
+  "VE:Cojedes": "COJ",
+  "VE:Delta Amacuro": "DAM",
+};
+
+function normalizeCityKey(cityName: string): string {
+  return cityName
+    .normalize("NFD")
+    .replace(/\p{M}/gu, "")
+    .replace(/[''`´’]/g, "")
+    .trim();
+}
+
+function fallbackCityCode(cityName: string): string {
+  const letters = normalizeCityKey(cityName).replace(/[^a-zA-Z]/g, "");
+  if (letters.length >= 3) return letters.slice(0, 3).toUpperCase();
+  return letters.toUpperCase().padEnd(3, "X");
+}
+
+export function resolveCityCode(
+  countryCode: string,
+  cityName: string,
+): string {
+  const cc = countryCode.trim().toUpperCase();
+  const normalized = normalizeCityKey(cityName);
+  const direct = CITY_CODE_OVERRIDES[`${cc}:${normalized}`];
+  if (direct) return direct;
+  const withoutAccents = CITY_CODE_OVERRIDES[`${cc}:${cityName.trim()}`];
+  if (withoutAccents) return withoutAccents;
+  return fallbackCityCode(cityName);
+}

package/registry/traky/lib/geo-countries.ts

@@ -0,0 +1,75 @@
+/** Países para UI: nombres vía Intl; catálogo vía `@countrystatecity/countries-browser`. */
+
+export interface CountryOption {
+  code: string;
+  short: string;
+  long: string;
+}
+
+/** @deprecated Usar `CountryOption`. */
+export type LatinCountry = CountryOption;
+
+export function spanishCountryName(isoCode: string, fallback?: string): string {
+  const code = isoCode.trim().toUpperCase();
+  if (!code) return fallback?.trim() || "";
+  try {
+    const name = new Intl.DisplayNames(["es"], { type: "region" }).of(code);
+    return name?.trim() || fallback?.trim() || code;
+  } catch {
+    return fallback?.trim() || code;
+  }
+}
+
+/** Mapea la respuesta CSC a opciones de UI (nombre en español, orden A–Z). */
+export function mapGeoCountries(
+  apiCountries: Array<{ code: string; name: string }>,
+): CountryOption[] {
+  const byCode = new Map<string, CountryOption>();
+
+  for (const c of apiCountries) {
+    const code = c.code.trim().toUpperCase();
+    if (!code) continue;
+    byCode.set(code, {
+      code,
+      short: code,
+      long: spanishCountryName(code, c.name),
+    });
+  }
+
+  return [...byCode.values()].sort((a, b) =>
+    a.long.localeCompare(b.long, "es"),
+  );
+}
+
+/** @deprecated Usar `mapGeoCountries`. */
+export const mergeGeoCountries = mapGeoCountries;
+
+export function getCountryByCode(
+  countryCode?: string | null,
+): CountryOption | undefined {
+  if (!countryCode?.trim()) return undefined;
+  const normalized = countryCode.trim().toUpperCase();
+  return {
+    code: normalized,
+    short: normalized,
+    long: spanishCountryName(normalized, normalized),
+  };
+}
+
+/** Nombre en español a partir del código ISO; si no hay match, usa el fallback o el código. */
+export function getCountryDisplayName(
+  countryCode?: string | null,
+  fallbackName?: string | null,
+): string {
+  if (!countryCode?.trim()) {
+    if (fallbackName?.trim()) return fallbackName.trim();
+    return "—";
+  }
+  return spanishCountryName(countryCode, fallbackName ?? undefined);
+}
+
+/** Fax en oficinas/direcciones cuando hay país ISO-2. */
+export function isCommonFaxCountry(countryCode?: string | null): boolean {
+  const code = countryCode?.trim().toUpperCase();
+  return Boolean(code && /^[A-Z]{2}$/.test(code));
+}

package/registry/traky/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/registry/traky/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);
+}