@controleonline/ui-default 1.0.270 → 1.0.273

package/src/react/hooks/usePostalCodeLookup.js

@@ -0,0 +1,159 @@
+import {useCallback, useEffect, useRef, useState} from 'react';
+import {lookupPostalCode, listStates} from '../services/addressGeo';
+import {
+  clearPostalCodeDerivedFields,
+  isGeocodeMiss,
+  mergePostalCodeData,
+  onlyDigits,
+} from '../services/addressFormUtils';
+
+const DEBOUNCE_MS = 450;
+
+/**
+ * CEP lookup with debounce (8 digits), race-token protection and loading/error state.
+ * Clears number on lookup; clears derived address/coords on failure (#746).
+ * Preserves complement/nickname.
+ */
+export default function usePostalCodeLookup({
+  formCep,
+  setForm,
+  onFormChange,
+  setStates,
+  enabled = true,
+}) {
+  const [loadingCep, setLoadingCep] = useState(false);
+  const [cepError, setCepError] = useState(null);
+  const [geocodeMiss, setGeocodeMiss] = useState(false);
+  const requestIdRef = useRef(0);
+  const debounceRef = useRef(null);
+  const lastRequestedRef = useRef('');
+
+  const runLookup = useCallback(
+    async (rawCep, {preserveFilledFields = false} = {}) => {
+      const digits = onlyDigits(rawCep).slice(0, 8);
+      if (digits.length !== 8) {
+        return null;
+      }
+
+      const requestId = ++requestIdRef.current;
+      lastRequestedRef.current = digits;
+      setLoadingCep(true);
+      setCepError(null);
+      setGeocodeMiss(false);
+
+      try {
+        const data = await lookupPostalCode(digits);
+        if (requestId !== requestIdRef.current) {
+          return null; // stale response
+        }
+        setGeocodeMiss(isGeocodeMiss(data));
+        setForm(prev => {
+          const next = mergePostalCodeData(
+            {...prev, cep: digits},
+            data,
+            {preserveFilledFields},
+          );
+          onFormChange?.(next);
+          return next;
+        });
+        if (data?.uf || data?.state) {
+          try {
+            const country =
+              data.country === 'Brasil' ||
+              data.country === 'Brazil' ||
+              data.country === 'BR'
+                ? 'BR'
+                : data.country || 'BR';
+            const s = await listStates(country);
+            if (requestId === requestIdRef.current) {
+              setStates?.(s);
+            }
+          } catch {
+            // states optional
+          }
+        }
+        return data;
+      } catch (e) {
+        if (requestId !== requestIdRef.current) {
+          return null;
+        }
+        const message =
+          e?.message ||
+          e?.response?.data?.detail ||
+          'CEP inválido ou serviço indisponível';
+        setCepError(message);
+        // CEP não encontrado: zera residual de endereço/coords/número (#746)
+        setForm(prev => {
+          const next = clearPostalCodeDerivedFields(prev);
+          onFormChange?.(next);
+          return next;
+        });
+        return null;
+      } finally {
+        if (requestId === requestIdRef.current) {
+          setLoadingCep(false);
+        }
+      }
+    },
+    [setForm, onFormChange, setStates],
+  );
+
+  // Debounced auto-lookup ONLY when CEP has exactly 8 digits (never partial).
+  useEffect(() => {
+    if (!enabled) {
+      return undefined;
+    }
+    const digits = onlyDigits(formCep).slice(0, 8);
+    if (digits.length !== 8) {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+        debounceRef.current = null;
+      }
+      return undefined;
+    }
+    if (digits === lastRequestedRef.current) {
+      return undefined;
+    }
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+    }
+    debounceRef.current = setTimeout(() => {
+      runLookup(digits);
+    }, DEBOUNCE_MS);
+    return () => {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+    };
+  }, [formCep, enabled, runLookup]);
+
+  const onCepBlur = useCallback(() => {
+    const digits = onlyDigits(formCep);
+    if (digits.length !== 8) {
+      return;
+    }
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+    }
+    runLookup(digits);
+  }, [formCep, runLookup]);
+
+  const cancelPending = useCallback(() => {
+    requestIdRef.current += 1;
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+    }
+    setLoadingCep(false);
+  }, []);
+
+  return {
+    loadingCep,
+    cepError,
+    setCepError,
+    geocodeMiss,
+    setGeocodeMiss,
+    onCepBlur,
+    runLookup,
+    cancelPending,
+  };
+}

package/src/react/index.js

@@ -1,10 +1,16 @@
 // React entrypoint kept after Vue removal.
 import DefaultFile from './components/files/DefaultFile';
+import DefaultFeatherIconPicker from './components/inputs/DefaultFeatherIconPicker';
+import DefaultUpload from './components/upload/DefaultUpload';
 
 const moduleEntry = {
   DefaultFile,
+  DefaultFeatherIconPicker,
+  DefaultUpload,
 };
 
 export {DefaultFile};
+export {DefaultFeatherIconPicker};
+export {DefaultUpload};
 
 export default moduleEntry;

package/src/react/services/addressFormUtils.js

@@ -0,0 +1,262 @@
+const onlyDigits = value => String(value || '').replace(/\D+/g, '');
+
+export const emptyAddressForm = {
+  nickname: '',
+  cep: '',
+  street: '',
+  number: '',
+  complement: '',
+  district: '',
+  city: '',
+  uf: '',
+  stateName: '',
+  countryCode: 'BR',
+  countryName: 'Brazil',
+  latitude: null,
+  longitude: null,
+  mapStaticUrl: null,
+  facadeUrl: null,
+  provider: null,
+};
+
+export function hydrateAddressFromRow(row) {
+  if (!row || typeof row !== 'object') {
+    return {...emptyAddressForm};
+  }
+  const street = row?.street?.street || row?.street || '';
+  const district = row?.street?.district?.district || row?.district || '';
+  const city = row?.street?.district?.city?.city || row?.city || '';
+  const stateEntity = row?.street?.district?.city?.state || row?.state;
+  const countryEntity = stateEntity?.country || row?.country;
+  return {
+    ...emptyAddressForm,
+    nickname: row?.nickname || '',
+    cep: String(row?.street?.cep?.cep || row?.cep || row?.postal_code || ''),
+    street: typeof street === 'string' ? street : '',
+    number: row?.number != null ? String(row.number) : '',
+    complement: row?.complement || '',
+    district,
+    city,
+    uf: stateEntity?.uf || row?.uf || '',
+    stateName: stateEntity?.state || '',
+    countryCode: countryEntity?.countrycode || countryEntity?.code || 'BR',
+    countryName: countryEntity?.countryname || countryEntity?.name || 'Brazil',
+    latitude: row?.latitude ?? null,
+    longitude: row?.longitude ?? null,
+  };
+}
+
+export function hasAddressText(form) {
+  return [
+    form?.street,
+    form?.number,
+    form?.district,
+    form?.city,
+    form?.uf,
+    form?.cep,
+  ].some(value => String(value || '').trim().length > 0);
+}
+
+export function hasCoordinates(form) {
+  const lat = Number(form?.latitude);
+  const lng = Number(form?.longitude);
+  // 0,0 is the API/entity default for "no coordinates"
+  return (
+    Number.isFinite(lat) &&
+    Number.isFinite(lng) &&
+    !(Math.abs(lat) < 0.000001 && Math.abs(lng) < 0.000001)
+  );
+}
+
+/**
+ * Merge postal-code API payload into form state.
+ * Preserves complement and nickname (manual).
+ * On CEP lookup (preserveFilledFields=false): clears number and replaces
+ * auto-filled address/coords — no residual from previous CEP (#746).
+ * When preserveFilledFields is true, also keeps non-empty street/city/etc.
+ */
+export function mergePostalCodeData(
+  prev,
+  data,
+  {preserveFilledFields = false} = {},
+) {
+  const pick = (key, nextValue) => {
+    if (preserveFilledFields && String(prev[key] || '').trim()) {
+      return prev[key];
+    }
+    if (
+      nextValue !== undefined &&
+      nextValue !== null &&
+      String(nextValue).trim() !== ''
+    ) {
+      return nextValue;
+    }
+    // Fresh CEP lookup must not keep residual street/city/etc.
+    if (!preserveFilledFields) {
+      return nextValue == null ? '' : String(nextValue);
+    }
+    return prev[key] || '';
+  };
+
+  const countryRaw = data?.country;
+  const isBrazil =
+    countryRaw === 'Brasil' || countryRaw === 'Brazil' || countryRaw === 'BR';
+
+  const latitude =
+    data?.latitude !== undefined
+      ? data.latitude
+      : data?.map?.latitude !== undefined
+        ? data.map.latitude
+        : preserveFilledFields
+          ? prev.latitude
+          : null;
+  const longitude =
+    data?.longitude !== undefined
+      ? data.longitude
+      : data?.map?.longitude !== undefined
+        ? data.map.longitude
+        : preserveFilledFields
+          ? prev.longitude
+          : null;
+
+  return {
+    ...prev,
+    // Número do imóvel anterior não se aplica ao novo CEP (#746)
+    number: preserveFilledFields ? prev.number : '',
+    complement: prev.complement,
+    nickname: prev.nickname,
+    cep: onlyDigits(data?.cep || prev.cep),
+    street: pick('street', data?.street),
+    district: pick('district', data?.district),
+    city: pick('city', data?.city),
+    uf: pick('uf', data?.uf || data?.state),
+    stateName: pick('stateName', data?.state),
+    countryCode: isBrazil ? 'BR' : countryRaw || prev.countryCode || 'BR',
+    countryName: isBrazil
+      ? 'Brazil'
+      : countryRaw || prev.countryName || 'Brazil',
+    latitude,
+    longitude,
+    mapStaticUrl: preserveFilledFields
+      ? data?.map?.staticUrl || prev.mapStaticUrl || null
+      : data?.map?.staticUrl || null,
+    facadeUrl: preserveFilledFields
+      ? data?.facade?.streetViewUrl || prev.facadeUrl || null
+      : data?.facade?.streetViewUrl || null,
+    provider: data?.provider || (preserveFilledFields ? prev.provider : null) || null,
+  };
+}
+
+/** Clear fields derived from a previous CEP when lookup fails (#746). */
+export function clearPostalCodeDerivedFields(prev) {
+  return {
+    ...prev,
+    number: '',
+    street: '',
+    district: '',
+    city: '',
+    uf: '',
+    stateName: '',
+    latitude: null,
+    longitude: null,
+    mapStaticUrl: null,
+    facadeUrl: null,
+    provider: null,
+  };
+}
+
+export function buildMapMarkerPayload(form) {
+  if (!hasAddressText(form) && !hasCoordinates(form)) {
+    return null;
+  }
+  const addressLine = [form.street, form.number].filter(Boolean).join(', ');
+  const addressExtra = [
+    form.district,
+    [form.city, form.uf].filter(Boolean).join(' - '),
+    form.countryName || form.countryCode,
+    form.cep,
+  ]
+    .filter(Boolean)
+    .join(' • ');
+
+  return {
+    id: 'default-address-preview',
+    title: form.nickname || 'Endereco',
+    addressLine: addressLine || addressExtra || 'Endereco',
+    addressExtra,
+    latitude: form.latitude,
+    longitude: form.longitude,
+    geocodeQuery: [
+      addressLine,
+      form.district,
+      [form.city, form.uf].filter(Boolean).join(' - '),
+      form.countryName || form.countryCode,
+      form.cep,
+    ]
+      .filter(Boolean)
+      .join(', '),
+  };
+}
+
+export {onlyDigits};
+
+export const GEOCODE_MISS_MESSAGE =
+  'Não foi possível obter a localização no mapa para este endereço. Você pode ajustar latitude e longitude manualmente.';
+
+export function parseOptionalCoordinate(value) {
+  if (value === null || value === undefined || value === '') {
+    return null;
+  }
+
+  const parsed = Number(String(value).trim().replace(',', '.'));
+
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+/** True when CEP/address text arrived but Nominatim (or API) left coords empty. */
+export function isGeocodeMiss(data) {
+  if (!data || typeof data !== 'object') {
+    return false;
+  }
+  const hasText = [
+    data.street,
+    data.district,
+    data.city,
+    data.uf,
+    data.state,
+  ].some(value => String(value || '').trim().length > 0);
+  if (!hasText) {
+    return false;
+  }
+  const lat = data.latitude ?? data.map?.latitude;
+  const lon = data.longitude ?? data.map?.longitude;
+  return !Number.isFinite(Number(lat)) || !Number.isFinite(Number(lon));
+}
+
+export function getCurrentCoordinates() {
+  return new Promise(resolve => {
+    const geolocation =
+      typeof navigator !== 'undefined' ? navigator.geolocation : null;
+
+    if (!geolocation?.getCurrentPosition) {
+      resolve(null);
+      return;
+    }
+
+    geolocation.getCurrentPosition(
+      position => {
+        const latitude = Number(position?.coords?.latitude);
+        const longitude = Number(position?.coords?.longitude);
+
+        if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+          resolve(null);
+          return;
+        }
+
+        resolve({latitude, longitude});
+      },
+      () => resolve(null),
+      {enableHighAccuracy: true, timeout: 8000, maximumAge: 60000},
+    );
+  });
+}

package/src/react/services/addressGeo.js

@@ -0,0 +1,230 @@
+import {api} from '@controleonline/ui-common/src/api';
+
+const onlyDigits = value => String(value || '').replace(/\D+/g, '');
+
+const hasText = value => String(value || '').trim().length > 0;
+
+export function isValidCoord(value) {
+  if (value === null || value === undefined || value === '') {
+    return false;
+  }
+  const n = Number(value);
+  return Number.isFinite(n) && Math.abs(n) > 0.000001;
+}
+
+export function isPostalLookupIncomplete(data) {
+  if (!data || typeof data !== 'object') {
+    return true;
+  }
+  const missingText = !hasText(data.street) || !hasText(data.city);
+  const missingCoords =
+    !isValidCoord(data.latitude ?? data?.map?.latitude) ||
+    !isValidCoord(data.longitude ?? data?.map?.longitude);
+  return missingText || missingCoords;
+}
+
+export function mergePostalLookupPayload(base, extra, providerSuffix) {
+  const src = extra && typeof extra === 'object' ? extra : {};
+  const next = {...(base && typeof base === 'object' ? base : {})};
+  const fill = (key, value) => {
+    if (!hasText(next[key]) && hasText(value)) {
+      next[key] = value;
+    }
+  };
+  fill('street', src.street);
+  fill('district', src.district);
+  fill('city', src.city);
+  fill('state', src.state || src.uf);
+  fill('uf', src.uf || src.state);
+  fill('country', src.country);
+  if (!isValidCoord(next.latitude) && isValidCoord(src.latitude)) {
+    next.latitude = Number(src.latitude);
+  }
+  if (!isValidCoord(next.longitude) && isValidCoord(src.longitude)) {
+    next.longitude = Number(src.longitude);
+  }
+  if (providerSuffix) {
+    const current = String(next.provider || '').trim();
+    next.provider = current
+      ? `${current}+${providerSuffix}`
+      : providerSuffix;
+  }
+  return next;
+}
+
+function mapViaCepPayload(json, digits) {
+  if (!json || json.erro) {
+    return null;
+  }
+  return {
+    cep: digits,
+    street: json.logradouro || '',
+    district: json.bairro || '',
+    city: json.localidade || '',
+    state: json.uf || '',
+    uf: json.uf || '',
+    country: 'Brasil',
+    provider: 'viacep-client',
+  };
+}
+
+export async function lookupViaCep(cep) {
+  const digits = onlyDigits(cep);
+  if (digits.length !== 8) {
+    throw new Error('CEP deve ter 8 dígitos');
+  }
+  const response = await fetch(`https://viacep.com.br/ws/${digits}/json/`);
+  if (!response.ok) {
+    throw new Error(`ViaCEP HTTP ${response.status}`);
+  }
+  const json = await response.json();
+  const mapped = mapViaCepPayload(json, digits);
+  if (!mapped) {
+    throw new Error('CEP não encontrado');
+  }
+  return mapped;
+}
+
+function buildNominatimQuery(data, digits) {
+  const cepFormatted =
+    digits.length === 8 ? `${digits.slice(0, 5)}-${digits.slice(5)}` : digits;
+  return [
+    data?.street,
+    data?.district,
+    data?.city,
+    data?.uf || data?.state,
+    cepFormatted,
+    'Brasil',
+  ]
+    .map(part => String(part || '').trim())
+    .filter(Boolean)
+    .join(', ');
+}
+
+export async function lookupNominatimCoords(data, digits) {
+  const q = buildNominatimQuery(data, digits);
+  if (!q) {
+    return null;
+  }
+  const url = `https://nominatim.openstreetmap.org/search?format=json&limit=1&q=${encodeURIComponent(q)}`;
+  const response = await fetch(url, {
+    headers: {
+      Accept: 'application/json',
+      'User-Agent': 'ControleOnline-ui-default/task-637',
+    },
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const rows = await response.json();
+  if (!Array.isArray(rows) || !rows[0]?.lat || !rows[0]?.lon) {
+    return null;
+  }
+  return {
+    latitude: Number(rows[0].lat),
+    longitude: Number(rows[0].lon),
+    formatted: rows[0].display_name || null,
+    provider: 'nominatim-client',
+  };
+}
+
+export async function lookupPostalCode(cep) {
+  const digits = onlyDigits(cep);
+  if (digits.length !== 8) {
+    throw new Error('CEP deve ter 8 dígitos');
+  }
+
+  let payload = {cep: digits};
+  let apiError = null;
+
+  try {
+    const apiData = await api.fetch(`postal-codes/${digits}`, {method: 'GET'});
+    if (apiData && typeof apiData === 'object') {
+      payload = {...payload, ...apiData, cep: digits};
+    }
+  } catch (e) {
+    apiError = e;
+  }
+
+  if (!hasText(payload.street) || !hasText(payload.city)) {
+    try {
+      const viaCep = await lookupViaCep(digits);
+      payload = mergePostalLookupPayload(payload, viaCep, viaCep.provider);
+    } catch (e) {
+      // ViaCEP "CEP não encontrado" (or HTTP error) must surface so the form
+      // clears residual address/coords/number (#746) — do not swallow.
+      if (isPostalLookupIncomplete(payload)) {
+        throw new Error(
+          e?.message ||
+            apiError?.message ||
+            apiError?.response?.data?.detail ||
+            'CEP inválido ou serviço indisponível',
+        );
+      }
+    }
+  }
+
+  if (
+    !isValidCoord(payload.latitude ?? payload?.map?.latitude) ||
+    !isValidCoord(payload.longitude ?? payload?.map?.longitude)
+  ) {
+    try {
+      const geo = await lookupNominatimCoords(payload, digits);
+      if (geo) {
+        payload = mergePostalLookupPayload(payload, geo, geo.provider);
+      }
+    } catch {
+      // coords optional if text fields already filled
+    }
+  }
+
+  // No usable address text after all providers → treat as not found (#746)
+  if (!hasText(payload.street) && !hasText(payload.city)) {
+    throw new Error(
+      apiError?.message ||
+        apiError?.response?.data?.detail ||
+        'CEP não encontrado',
+    );
+  }
+
+  return payload;
+}
+
+export async function listCountries(q = '') {
+  const params = q ? {q} : {};
+  const data = await api.fetch('address-geo/countries', {method: 'GET', params});
+  return Array.isArray(data?.member) ? data.member : [];
+}
+
+export async function listStates(country = 'BR') {
+  const data = await api.fetch('address-geo/states', {
+    method: 'GET',
+    params: {country},
+  });
+  return Array.isArray(data?.member) ? data.member : [];
+}
+
+export function buildAddressSavePayload(form, peopleIri) {
+  const payload = {
+    street: form.street || '',
+    city: form.city || '',
+    district: form.district || '',
+    state: form.uf || form.state || '',
+    country: form.countryCode || form.country || 'BR',
+    people: peopleIri,
+    number: form.number ?? '',
+    complement: form.complement || '',
+    nickname: form.nickname || '',
+    cep: onlyDigits(form.cep),
+    latitude: form.latitude ?? 0,
+    longitude: form.longitude ?? 0,
+  };
+
+  if (Array.isArray(form.categories)) {
+    payload.categories = form.categories;
+  } else if (Array.isArray(form.category)) {
+    payload.category = form.category;
+  }
+
+  return payload;
+}