@traky-app/ui 1.6.1 → 1.6.4

package/registry/traky/ui/geo-selectors.tsx

@@ -0,0 +1,162 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { CountrySelect, type Country } from "@/components/ui/country-select";
+import { StateSelect } from "@/components/ui/state-select";
+import { CitySelect } from "@/components/ui/city-select";
+import type { GeoCityOption, GeoOption } from "@/lib/geo-types";
+import { cn } from "@/lib/utils";
+import { Label } from "@/components/ui/label";
+
+export type GeoSelectorLevel = "country" | "state" | "city";
+
+export type GeoSelectorsValue = {
+  country: Country | null;
+  state: GeoOption | null;
+  city: GeoCityOption | null;
+};
+
+const ALL_LEVELS: readonly GeoSelectorLevel[] = ["country", "state", "city"];
+
+const EMPTY_VALUE: GeoSelectorsValue = {
+  country: null,
+  state: null,
+  city: null,
+};
+
+type GeoSelectorsProps = {
+  /**
+   * Niveles visibles. Omite los que no quieras.
+   * Si no está "country", pasa `countryCode`.
+   * Si no está "state" y sí "city", pasa `stateCode`.
+   */
+  levels?: readonly GeoSelectorLevel[];
+  /** País fijo cuando el select de país no se muestra. */
+  countryCode?: string | null;
+  /** Provincia fija cuando el select de provincia no se muestra. */
+  stateCode?: string | null;
+  onChange?: (value: GeoSelectorsValue) => void;
+  disabled?: boolean;
+  className?: string;
+  idPrefix?: string;
+};
+
+export function GeoSelectors({
+  levels = ALL_LEVELS,
+  countryCode,
+  stateCode,
+  onChange,
+  disabled = false,
+  className,
+  idPrefix = "geo",
+}: GeoSelectorsProps) {
+  const showCountry = levels.includes("country");
+  const showState = levels.includes("state");
+  const showCity = levels.includes("city");
+  const [selection, setSelection] = useState<GeoSelectorsValue>(EMPTY_VALUE);
+
+  const resolvedCountry = showCountry
+    ? (selection.country?.code ?? "")
+    : (countryCode?.trim().toUpperCase() ?? "");
+  const resolvedState = showState
+    ? (selection.state?.code ?? "")
+    : (stateCode?.trim() ?? "");
+
+  const externalCountry = countryCode?.trim().toUpperCase() ?? "";
+  const externalState = stateCode?.trim() ?? "";
+
+  useEffect(() => {
+    if (showCountry) return;
+    setSelection((prev) => {
+      if (!prev.state && !prev.city) return prev;
+      return { ...prev, state: null, city: null };
+    });
+  }, [externalCountry, showCountry]);
+
+  useEffect(() => {
+    if (showState) return;
+    setSelection((prev) => {
+      if (!prev.city) return prev;
+      return { ...prev, city: null };
+    });
+  }, [externalState, showState]);
+
+  const publish = (next: GeoSelectorsValue) => {
+    setSelection(next);
+    onChange?.(next);
+  };
+
+  const visible = [showCountry, showState, showCity].filter(Boolean).length;
+  if (visible === 0) return null;
+
+  return (
+    <div
+      className={cn(
+        "grid gap-4",
+        visible >= 3
+          ? "md:grid-cols-3"
+          : visible === 2
+            ? "md:grid-cols-2"
+            : "max-w-sm",
+        className,
+      )}
+    >
+      {showCountry ? (
+        <div className="space-y-1">
+          <Label htmlFor={`${idPrefix}-country`}>País</Label>
+          <CountrySelect
+            id={`${idPrefix}-country`}
+            className="w-full"
+            size="lg"
+            value={selection.country?.code}
+            disabled={disabled}
+            onChange={(country) =>
+              publish({ country, state: null, city: null })
+            }
+            allowClear
+            onClear={() => publish(EMPTY_VALUE)}
+          />
+        </div>
+      ) : null}
+
+      {showState ? (
+        <div className="space-y-1">
+          <Label htmlFor={`${idPrefix}-state`}>Estado / Región / Municipio</Label>
+          <StateSelect
+            id={`${idPrefix}-state`}
+            countryCode={resolvedCountry}
+            value={selection.state?.code ?? ""}
+            disabled={disabled}
+            onChange={(state) =>
+              publish({
+                country: selection.country,
+                state,
+                city: null,
+              })
+            }
+          />
+        </div>
+      ) : null}
+
+      {showCity ? (
+        <div className="space-y-1">
+          <Label htmlFor={`${idPrefix}-city`}>Ciudad / Pueblo / Distrito</Label>
+          <CitySelect
+            id={`${idPrefix}-city`}
+            countryCode={resolvedCountry}
+            stateCode={resolvedState}
+            value={selection.city?.code ?? selection.city?.name ?? ""}
+            disabled={disabled}
+            onChange={(city) =>
+              publish({
+                country: selection.country,
+                state: selection.state,
+                city,
+              })
+            }
+          />
+        </div>
+      ) : null}
+    </div>
+  );
+}

package/registry/traky/ui/google-maps-address-picker.tsx

@@ -0,0 +1,422 @@
+"use client"
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useJsApiLoader, GoogleMap, Marker } from "@react-google-maps/api"
+import { IconLoader } from "@tabler/icons-react"
+
+import { cn } from "@/lib/utils"
+import {
+  parseGoogleAddressComponents,
+  type GoogleMapsAddressSelection,
+} from "@/lib/google-maps-address"
+import { Label } from "@/components/ui/label"
+
+const MAP_LIBRARIES: ("places")[] = ["places"]
+const DEFAULT_CENTER = { lat: -1.8312, lng: -78.1834 }
+const DEFAULT_ZOOM = 6
+const SELECTED_ZOOM = 16
+const MAP_CONTAINER_STYLE = { width: "100%", height: "min(52dvh, 360px)" }
+
+function applyGooglePlacesLightTheme(
+  element: google.maps.places.PlaceAutocompleteElement,
+) {
+  element.style.setProperty("color-scheme", "light")
+  element.style.setProperty("background-color", "#ffffff")
+  element.style.setProperty("color", "#141414")
+  element.style.setProperty("border", "1px solid #e2e8f0")
+  element.style.setProperty("border-radius", "0.375rem")
+  element.style.setProperty("width", "100%")
+  element.style.setProperty("min-height", "2.75rem")
+  element.style.setProperty("font-size", "0.875rem")
+}
+
+function parsePlaceInstance(
+  place: google.maps.places.Place,
+): GoogleMapsAddressSelection | null {
+  const lat = place.location?.lat()
+  const lng = place.location?.lng()
+  if (lat == null || lng == null) return null
+
+  const parsed = parseGoogleAddressComponents(
+    place.addressComponents as Parameters<
+      typeof parseGoogleAddressComponents
+    >[0],
+    place.displayName || place.formattedAddress || "",
+    lat,
+    lng,
+  )
+  if (!parsed) return null
+  return {
+    ...parsed,
+    formattedAddress: place.formattedAddress?.trim() || undefined,
+  }
+}
+
+export type GoogleMapsAddressPickerProps = {
+  onLocationSelect: (address: GoogleMapsAddressSelection) => void
+  onLocationClear?: () => void
+  regionCode?: string
+  className?: string
+  initialLatitude?: number
+  initialLongitude?: number
+  initialFormattedAddress?: string
+  /** Prioridad sobre `NEXT_PUBLIC_GOOGLE_MAPS_API_KEY`. */
+  apiKey?: string
+}
+
+function GoogleMapsAddressPickerInner({
+  onLocationSelect,
+  onLocationClear,
+  regionCode,
+  className,
+  initialLatitude,
+  initialLongitude,
+  initialFormattedAddress,
+}: Omit<GoogleMapsAddressPickerProps, "apiKey">) {
+  const autocompleteHostRef = useRef<HTMLDivElement>(null)
+  const autocompleteElementRef =
+    useRef<google.maps.places.PlaceAutocompleteElement | null>(null)
+  const geocoderRef = useRef<google.maps.Geocoder | null>(null)
+
+  const [searchLabel, setSearchLabel] = useState("")
+  const [isGeocoding, setIsGeocoding] = useState(false)
+  const [geocodeError, setGeocodeError] = useState<string | null>(null)
+  const [marker, setMarker] = useState<google.maps.LatLngLiteral | null>(() => {
+    if (
+      typeof initialLatitude === "number" &&
+      typeof initialLongitude === "number"
+    ) {
+      return { lat: initialLatitude, lng: initialLongitude }
+    }
+    return null
+  })
+  const [mapCenter, setMapCenter] = useState<google.maps.LatLngLiteral>(
+    marker ?? DEFAULT_CENTER,
+  )
+  const [mapZoom, setMapZoom] = useState(marker ? SELECTED_ZOOM : DEFAULT_ZOOM)
+
+  useEffect(() => {
+    const lat =
+      typeof initialLatitude === "number" && Number.isFinite(initialLatitude)
+        ? initialLatitude
+        : null
+    const lng =
+      typeof initialLongitude === "number" && Number.isFinite(initialLongitude)
+        ? initialLongitude
+        : null
+    if (lat == null || lng == null) return
+    const position = { lat, lng }
+    setMarker(position)
+    setMapCenter(position)
+    setMapZoom(SELECTED_ZOOM)
+  }, [initialLatitude, initialLongitude])
+
+  useEffect(() => {
+    const label = initialFormattedAddress?.trim()
+    if (!label) return
+    setSearchLabel(label)
+    if (autocompleteElementRef.current) {
+      autocompleteElementRef.current.value = label
+    }
+  }, [initialFormattedAddress])
+
+  const mapOptions = useMemo<google.maps.MapOptions>(
+    () => ({
+      streetViewControl: false,
+      mapTypeControl: false,
+      fullscreenControl: false,
+      zoomControl: true,
+    }),
+    [],
+  )
+
+  const applySelection = useCallback(
+    (address: GoogleMapsAddressSelection, label: string) => {
+      const position = { lat: address.latitude, lng: address.longitude }
+      setMarker(position)
+      setMapCenter(position)
+      setMapZoom(SELECTED_ZOOM)
+      setSearchLabel(label)
+      setGeocodeError(null)
+      if (autocompleteElementRef.current) {
+        autocompleteElementRef.current.value = label
+      }
+      onLocationSelect({
+        ...address,
+        formattedAddress: label.trim() || address.formattedAddress,
+      })
+    },
+    [onLocationSelect],
+  )
+
+  const reverseGeocode = useCallback(
+    (position: google.maps.LatLngLiteral) =>
+      new Promise<{ address: GoogleMapsAddressSelection; label: string } | null>(
+        (resolve) => {
+          if (!geocoderRef.current) {
+            geocoderRef.current = new google.maps.Geocoder()
+          }
+          geocoderRef.current.geocode({ location: position }, (results, status) => {
+            if (status !== "OK" || !results?.[0]) {
+              resolve(null)
+              return
+            }
+            const result = results[0]
+            const parsed = parseGoogleAddressComponents(
+              result.address_components,
+              result.formatted_address || "",
+              position.lat,
+              position.lng,
+            )
+            if (!parsed) {
+              resolve(null)
+              return
+            }
+            const label = result.formatted_address?.trim() || ""
+            resolve({
+              address: {
+                ...parsed,
+                formattedAddress: label || undefined,
+              },
+              label,
+            })
+          })
+        },
+      ),
+    [],
+  )
+
+  const handlePositionChange = useCallback(
+    async (position: google.maps.LatLngLiteral) => {
+      setMarker(position)
+      setMapCenter(position)
+      setMapZoom(SELECTED_ZOOM)
+      setIsGeocoding(true)
+      setGeocodeError(null)
+
+      const resolved = await reverseGeocode(position)
+      setIsGeocoding(false)
+
+      if (resolved) {
+        applySelection(resolved.address, resolved.label)
+        return
+      }
+
+      setGeocodeError(
+        "No pudimos resolver esa ubicación. Elige una dirección en el buscador o activa Geocoding API en Google Cloud.",
+      )
+    },
+    [applySelection, reverseGeocode],
+  )
+
+  useEffect(() => {
+    const host = autocompleteHostRef.current
+    if (!host) return
+
+    let cancelled = false
+    let placeAutocomplete: google.maps.places.PlaceAutocompleteElement | null =
+      null
+
+    const onSelect: EventListener = (event) => {
+      void (async () => {
+        const selectEvent =
+          event as google.maps.places.PlacePredictionSelectEvent
+        const place = selectEvent.placePrediction.toPlace()
+        await place.fetchFields({
+          fields: [
+            "displayName",
+            "formattedAddress",
+            "location",
+            "addressComponents",
+          ],
+        })
+
+        const parsed = parsePlaceInstance(place)
+        if (!parsed) return
+
+        const label =
+          place.formattedAddress?.trim() ||
+          [
+            parsed.streetNumber,
+            parsed.street,
+            parsed.city,
+            parsed.state,
+            parsed.postalCode,
+          ]
+            .filter(Boolean)
+            .join(", ")
+
+        applySelection(parsed, label)
+      })()
+    }
+
+    void (async () => {
+      await google.maps.importLibrary("places")
+
+      if (cancelled || !autocompleteHostRef.current) return
+
+      const region = regionCode?.trim().toLowerCase()
+      placeAutocomplete = new google.maps.places.PlaceAutocompleteElement({
+        ...(region ? { includedRegionCodes: [region] } : {}),
+        placeholder: "Busca tu dirección en Google Maps…",
+      })
+
+      placeAutocomplete.className = "gmp-place-autocomplete-host block w-full"
+      applyGooglePlacesLightTheme(placeAutocomplete)
+
+      const savedLabel = initialFormattedAddress?.trim()
+      if (savedLabel) {
+        placeAutocomplete.value = savedLabel
+        setSearchLabel(savedLabel)
+      }
+
+      host.replaceChildren(placeAutocomplete)
+      autocompleteElementRef.current = placeAutocomplete
+      placeAutocomplete.addEventListener("gmp-select", onSelect)
+    })()
+
+    return () => {
+      cancelled = true
+      if (placeAutocomplete) {
+        placeAutocomplete.removeEventListener("gmp-select", onSelect)
+      }
+      host.replaceChildren()
+      autocompleteElementRef.current = null
+    }
+  }, [applySelection, initialFormattedAddress, regionCode])
+
+  const handleClear = () => {
+    setMarker(null)
+    setSearchLabel("")
+    setGeocodeError(null)
+    setIsGeocoding(false)
+    setMapCenter(DEFAULT_CENTER)
+    setMapZoom(DEFAULT_ZOOM)
+    if (autocompleteElementRef.current) {
+      autocompleteElementRef.current.value = ""
+    }
+    onLocationClear?.()
+  }
+
+  return (
+    <div className={cn("space-y-3", className)}>
+      <div className="space-y-1.5">
+        <Label>Buscar dirección</Label>
+        <div
+          ref={autocompleteHostRef}
+          className="gmp-autocomplete-wrapper w-full rounded-md bg-background"
+        />
+      </div>
+
+      <div className="overflow-hidden rounded-lg border border-border">
+        <GoogleMap
+          mapContainerStyle={MAP_CONTAINER_STYLE}
+          center={mapCenter}
+          zoom={mapZoom}
+          onClick={(event) => {
+            const latLng = event.latLng
+            if (!latLng) return
+            void handlePositionChange({ lat: latLng.lat(), lng: latLng.lng() })
+          }}
+          options={mapOptions}
+        >
+          {marker ? (
+            <Marker
+              position={marker}
+              draggable
+              onDragEnd={(event) => {
+                const latLng = event.latLng
+                if (!latLng) return
+                void handlePositionChange({
+                  lat: latLng.lat(),
+                  lng: latLng.lng(),
+                })
+              }}
+            />
+          ) : null}
+        </GoogleMap>
+      </div>
+
+      {geocodeError ? (
+        <p className="text-xs text-destructive">{geocodeError}</p>
+      ) : null}
+
+      {marker ? (
+        <div className="flex flex-wrap items-center justify-between gap-2 text-xs text-muted-foreground">
+          <span className="min-w-0 break-words">
+            {isGeocoding ? (
+              <>
+                <IconLoader className="mr-1 inline size-3 animate-spin" />
+                Actualizando dirección…
+              </>
+            ) : (
+              searchLabel ||
+              `${marker.lat.toFixed(5)}, ${marker.lng.toFixed(5)}`
+            )}
+          </span>
+          <button
+            type="button"
+            className="shrink-0 text-primary underline underline-offset-2"
+            onClick={handleClear}
+          >
+            Limpiar
+          </button>
+        </div>
+      ) : (
+        <p className="text-xs text-muted-foreground">
+          Busca una dirección o haz clic en el mapa para fijar el punto.
+        </p>
+      )}
+    </div>
+  )
+}
+
+function resolveGoogleMapsApiKey(apiKey?: string): string {
+  if (apiKey?.trim()) return apiKey.trim()
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY?.trim() ?? ""
+  }
+  return ""
+}
+
+export function GoogleMapsAddressPicker({
+  apiKey,
+  ...props
+}: GoogleMapsAddressPickerProps) {
+  const resolvedKey = resolveGoogleMapsApiKey(apiKey)
+
+  const { isLoaded, loadError } = useJsApiLoader({
+    googleMapsApiKey: resolvedKey,
+    libraries: MAP_LIBRARIES,
+  })
+
+  if (!resolvedKey) {
+    return (
+      <div className="rounded-lg border border-dashed border-border bg-muted/30 p-4 text-sm text-muted-foreground">
+        Configura{" "}
+        <code className="text-xs">NEXT_PUBLIC_GOOGLE_MAPS_API_KEY</code> (solo
+        desarrollo) para usar búsqueda y mapa de Google.
+      </div>
+    )
+  }
+
+  if (loadError) {
+    return (
+      <div className="rounded-lg border border-destructive/40 bg-destructive/10 p-4 text-sm text-destructive">
+        No se pudo cargar Google Maps. Habilita Maps JavaScript API, Places API
+        (New) y Geocoding API para esta clave.
+      </div>
+    )
+  }
+
+  if (!isLoaded) {
+    return (
+      <div className="flex h-[min(52dvh,360px)] items-center justify-center rounded-lg border bg-muted/30 text-sm text-muted-foreground">
+        <IconLoader className="mr-2 size-4 animate-spin" />
+        Cargando mapa…
+      </div>
+    )
+  }
+
+  return <GoogleMapsAddressPickerInner {...props} />
+}

package/registry/traky/ui/internal-chat-mention.ts

@@ -1,6 +1,6 @@
 import type { Icon } from "@tabler/icons-react";
 
-export type InternalChatMentionKind = "guide" | "package";
+export type InternalChatMentionKind = "guide" | "package" | "ai";
 
 export type InternalChatMentionItem = {
   id: string;
@@ -15,6 +15,8 @@ export type InternalChatMentionCategoryMeta = {
   label: string;
   hint: string;
   keywords: string[];
+  /** Visible en el menú de tipo pero no seleccionable (p. ej. próximamente). */
+  disabled?: boolean;
 };
 
 export type InternalChatMentionListEntry =
@@ -24,12 +26,26 @@ export type InternalChatMentionListEntry =
       label: string;
       hint: string;
       icon: Icon;
+      disabled?: boolean;
     }
   | { type: "item"; data: InternalChatMentionItem };
 
+export type InternalChatMentionCatalogState = {
+  open: boolean;
+  phase: "category" | "item";
+  kind?: InternalChatMentionKind;
+  filter: string;
+};
+
+export type BuildMentionListOptions = {
+  /** Si true, los ítems ya vienen filtrados del servidor (sin filtro local por texto). */
+  serverFilteredItems?: boolean;
+};
+
 export const DEFAULT_MENTION_KIND_ORDER: InternalChatMentionKind[] = [
   "guide",
   "package",
+  "ai",
 ];
 
 export const DEFAULT_MENTION_KIND_LABEL: Record<
@@ -38,6 +54,7 @@ export const DEFAULT_MENTION_KIND_LABEL: Record<
 > = {
   guide: "Guías",
   package: "Paquetes",
+  ai: "Asistencia de IA",
 };
 
 export type InternalChatMentionConfig = {
@@ -64,6 +81,9 @@ function resolveKindAlias(
     paquete: "package",
     paquetes: "package",
     package: "package",
+    ia: "ai",
+    ai: "ai",
+    asistencia: "ai",
     ...config.kindAliases,
   };
 
@@ -129,6 +149,7 @@ function filterCategoryEntries(
     label: config.categoryMeta[kind].label,
     hint: config.categoryMeta[kind].hint,
     icon: config.kindIcons[kind],
+    disabled: config.categoryMeta[kind].disabled,
   }));
   if (!q) return rows;
   const byAlias = resolveKindAlias(q, config);
@@ -149,10 +170,11 @@ function filterItemsByKind(
   kind: InternalChatMentionKind,
   filterText: string,
   catalog: InternalChatMentionItem[],
+  skipTextFilter = false,
 ): InternalChatMentionListEntry[] {
   const q = filterText.trim().toLowerCase();
   let items = catalog.filter((i) => i.kind === kind);
-  if (q) {
+  if (!skipTextFilter && q) {
     items = items.filter(
       (item) =>
         item.label.toLowerCase().includes(q) ||
@@ -168,13 +190,22 @@ export function buildMentionList(
   guideItems: InternalChatMentionItem[],
   packageItems: InternalChatMentionItem[],
   config: InternalChatMentionConfig,
+  options?: BuildMentionListOptions,
 ): InternalChatMentionListEntry[] {
   const seg = parseMentionSegment(query, config);
   if (seg.phase === "category") {
     return filterCategoryEntries(seg.filter, config);
   }
+  if (seg.kind === "ai" || config.categoryMeta[seg.kind]?.disabled) {
+    return [];
+  }
   const pool = seg.kind === "guide" ? guideItems : packageItems;
-  return filterItemsByKind(seg.kind, seg.filter, pool);
+  return filterItemsByKind(
+    seg.kind,
+    seg.filter,
+    pool,
+    Boolean(options?.serverFilteredItems),
+  );
 }
 
 export function roomInitialLetter(name: string): string {