zenit-sdk 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -1,1218 +0,0 @@
-import {
-  ChevronLeft,
-  ChevronRight,
-  Eye,
-  EyeOff,
-  FloatingChatBox,
-  Layers,
-  Upload,
-  X,
-  ZenitFeatureFilterPanel,
-  ZenitLayerManager,
-  ZenitMap,
-  ZoomIn,
-  applyFilteredGeoJSONStrategy,
-  applyLayerOverrides,
-  centroidFromBBox,
-  clampNumber,
-  clampOpacity,
-  computeBBoxFromFeature,
-  createChatService,
-  extractMapDto,
-  getAccentByLayerId,
-  getEffectiveLayerOpacity,
-  getLayerColor,
-  getLayerZoomOpacityFactor,
-  getStyleByLayerId,
-  getZoomOpacityFactor,
-  initLayerStates,
-  isPolygonLayer,
-  normalizeMapCenter,
-  normalizeMapLayers,
-  resetOverrides,
-  resolveLayerAccent,
-  sendMessage,
-  sendMessageStream,
-  useSendMessage,
-  useSendMessageStream
-} from "./chunk-URDEEWUZ.mjs";
-
-// src/http/HttpClient.ts
-var HttpClient = class {
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.resolveTokens = options.resolveTokens;
-    this.resolveAuthorizationHeader = options.resolveAuthorizationHeader ?? (() => ({}));
-  }
-  /**
-   * Update base URL at runtime (e.g. when a host injects config).
-   */
-  setBaseUrl(baseUrl) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-  }
-  async get(path, options = {}) {
-    const headers = {
-      ...options.headers,
-      ...this.resolveAuthorizationHeader()
-    };
-    return this.request(path, { ...options, method: "GET", headers });
-  }
-  async post(path, body, options = {}) {
-    const headers = {
-      "Content-Type": "application/json",
-      ...options.headers,
-      ...this.resolveAuthorizationHeader()
-    };
-    return this.request(path, {
-      ...options,
-      method: "POST",
-      headers,
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-  }
-  async put(path, body, options = {}) {
-    const headers = {
-      "Content-Type": "application/json",
-      ...options.headers,
-      ...this.resolveAuthorizationHeader()
-    };
-    return this.request(path, {
-      ...options,
-      method: "PUT",
-      headers,
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-  }
-  async patch(path, body, options = {}) {
-    const headers = {
-      "Content-Type": "application/json",
-      ...options.headers,
-      ...this.resolveAuthorizationHeader()
-    };
-    return this.request(path, {
-      ...options,
-      method: "PATCH",
-      headers,
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-  }
-  async delete(path, options = {}) {
-    const headers = {
-      ...options.headers,
-      ...this.resolveAuthorizationHeader()
-    };
-    return this.request(path, { ...options, method: "DELETE", headers });
-  }
-  async request(path, options) {
-    const url = `${this.baseUrl}${path}`;
-    const tokenState = this.resolveTokens?.();
-    const headers = {
-      ...options.headers
-    };
-    if (!headers["Authorization"] && tokenState?.accessToken) {
-      headers["Authorization"] = `Bearer ${tokenState.accessToken}`;
-    }
-    if (tokenState?.sdkToken) {
-      headers["X-SDK-Token"] = tokenState.sdkToken;
-    }
-    const response = await fetch(url, {
-      ...options,
-      headers
-    });
-    const contentType = response.headers.get("content-type");
-    const isJson = contentType?.includes("application/json");
-    const payload = isJson ? await response.json() : await response.text();
-    if (!response.ok) {
-      const normalizedError = {
-        success: false,
-        statusCode: response.status,
-        message: typeof payload === "string" ? payload : payload?.message || "Unknown error",
-        timestamp: typeof payload === "object" ? payload.timestamp : void 0,
-        path: typeof payload === "object" ? payload.path : void 0,
-        method: typeof payload === "object" ? payload.method : void 0,
-        error: typeof payload === "object" ? payload.error : void 0
-      };
-      throw normalizedError;
-    }
-    return payload;
-  }
-};
-
-// src/auth/ZenitAuthClient.ts
-var ZenitAuthClient = class {
-  constructor(http, updateTokens, config) {
-    this.http = http;
-    this.updateTokens = updateTokens;
-    this.config = config;
-  }
-  async login(credentials) {
-    try {
-      const response = await this.http.post("/auth/login", credentials);
-      const accessToken = response?.accessToken ?? response?.data?.accessToken;
-      const refreshToken = response?.refreshToken ?? response?.data?.refreshToken;
-      this.updateTokens({ accessToken, refreshToken });
-      return response;
-    } catch (error) {
-      this.config.onAuthError?.(error);
-      throw error;
-    }
-  }
-  async refresh(refreshToken) {
-    const tokenToUse = refreshToken || this.config.refreshToken;
-    const headers = tokenToUse ? { Authorization: `Bearer ${tokenToUse}` } : void 0;
-    const response = await this.http.post("/auth/refresh", void 0, { headers });
-    const accessToken = response?.accessToken ?? response?.data?.accessToken;
-    const nextRefreshToken = response?.refreshToken ?? response?.data?.refreshToken;
-    this.updateTokens({ accessToken, refreshToken: nextRefreshToken });
-    return response;
-  }
-  async me() {
-    return this.http.get("/auth/me");
-  }
-  async validate() {
-    return this.http.get("/auth/validate");
-  }
-};
-
-// src/sdkAuth/ZenitSdkAuthClient.ts
-var ZenitSdkAuthClient = class {
-  constructor(http, updateAccessToken, config) {
-    this.http = http;
-    this.updateAccessToken = updateAccessToken;
-    this.config = config;
-  }
-  /**
-   * Validate an SDK token. If no token argument is provided, it falls back to config.sdkToken.
-   */
-  async validateSdkToken(token) {
-    const sdkToken = token || this.config.sdkToken;
-    return this.http.post("/sdk-auth/validate", { token: sdkToken });
-  }
-  /**
-   * Exchange an SDK token for an access token. Token can come from method args or config.sdkToken.
-   */
-  async exchangeSdkToken(token) {
-    const sdkToken = token || this.config.sdkToken;
-    const response = await this.http.post("/sdk-auth/exchange", { token: sdkToken });
-    const accessToken = response?.accessToken ?? response?.data?.accessToken;
-    this.updateAccessToken(accessToken);
-    return response;
-  }
-};
-
-// src/maps/ZenitMapsClient.ts
-var ZenitMapsClient = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  async getMap(mapId, includeLayers = true) {
-    const include = includeLayers ? "?includeLayers=true" : "";
-    return this.httpClient.get(`/maps/${mapId}${include}`);
-  }
-};
-
-// src/layers/catalogSupport.ts
-function isPolygonLike(value) {
-  if (!value) {
-    return false;
-  }
-  const normalized = value.toLowerCase();
-  return normalized === "polygon" || normalized === "multipolygon";
-}
-function getCatalogSupport(args) {
-  const { layerType, geometryType } = args;
-  if (layerType !== void 0) {
-    const supported = isPolygonLike(layerType);
-    return {
-      supported,
-      reason: supported ? "supported" : "unsupported-geometry",
-      layerType,
-      geometryType
-    };
-  }
-  if (geometryType !== void 0) {
-    const supported = isPolygonLike(geometryType);
-    return {
-      supported,
-      reason: supported ? "supported" : "unsupported-geometry",
-      geometryType
-    };
-  }
-  return {
-    supported: false,
-    reason: "unknown-geometry"
-  };
-}
-var ZenitCatalogNotSupportedError = class extends Error {
-  constructor(support, message) {
-    super(message ?? "Catalog is not supported for this layer geometry");
-    this.name = "ZenitCatalogNotSupportedError";
-    this.support = support;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-
-// src/engine/PrefilterEngine.ts
-var normalizeString = (value) => value.trim().toLowerCase();
-var isPrefilterValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-var matchesPrefilterValue = (candidate, expected) => {
-  if (typeof expected === "string") {
-    if (candidate === null || candidate === void 0) return false;
-    return normalizeString(String(candidate)) === normalizeString(expected);
-  }
-  return candidate === expected;
-};
-var shouldApplyPrefilters = (prefilters) => !!prefilters && Object.keys(prefilters).length > 0;
-var featureMatchesPrefilters = (feature, prefilters) => {
-  const properties = feature.properties ?? {};
-  return Object.entries(prefilters).every(([key, expected]) => {
-    if (!isPrefilterValue(expected)) return true;
-    return matchesPrefilterValue(properties[key], expected);
-  });
-};
-var applyPrefiltersToFeatureCollection = (featureCollection, prefilters) => {
-  if (!shouldApplyPrefilters(prefilters)) return featureCollection;
-  const nextFeatures = featureCollection.features.filter(
-    (feature) => featureMatchesPrefilters(feature, prefilters)
-  );
-  return {
-    ...featureCollection,
-    features: nextFeatures
-  };
-};
-var decorateFeaturesWithLayerId = (featureCollection, layerId) => {
-  let shouldClone = false;
-  featureCollection.features.forEach((feature) => {
-    const existing = feature.properties?.__zenit_layerId;
-    if (existing !== layerId) {
-      shouldClone = true;
-    }
-  });
-  if (!shouldClone) {
-    return featureCollection;
-  }
-  return {
-    ...featureCollection,
-    features: featureCollection.features.map((feature) => ({
-      ...feature,
-      properties: {
-        ...feature.properties ?? {},
-        __zenit_layerId: layerId
-      }
-    }))
-  };
-};
-
-// src/layers/ZenitLayersClient.ts
-function parseQueryParams(options = {}) {
-  const params = new URLSearchParams();
-  if (options.maxFeatures !== void 0) {
-    params.set("maxFeatures", String(options.maxFeatures));
-  }
-  if (options.simplify !== void 0) {
-    params.set("simplify", String(options.simplify));
-  }
-  return params;
-}
-function serializeFilterValue(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  const serialized = String(value);
-  return serialized.trim().length > 0 ? serialized : void 0;
-}
-function buildLayerFilters(filters) {
-  const query = new URLSearchParams();
-  if (!filters) {
-    return query;
-  }
-  Object.entries(filters).forEach(([key, value]) => {
-    if (Array.isArray(value)) {
-      value.forEach((item) => {
-        const serialized2 = serializeFilterValue(item);
-        if (serialized2 !== void 0) {
-          query.append(key, serialized2);
-        }
-      });
-      return;
-    }
-    const serialized = serializeFilterValue(value);
-    if (serialized !== void 0) {
-      query.set(key, serialized);
-    }
-  });
-  return query;
-}
-function buildFilterMultipleParams(params) {
-  const query = buildLayerFilters(params.filters);
-  if (!Array.isArray(params.layerIds) || params.layerIds.length === 0) {
-    throw new Error("layerIds is required and cannot be empty");
-  }
-  query.set("layerIds", params.layerIds.map((id) => String(id)).join(","));
-  return query;
-}
-function asOptionalNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function createEmptyFeatureCollection() {
-  return { type: "FeatureCollection", features: [] };
-}
-function hasFilters(filters) {
-  return buildLayerFilters(filters).size > 0;
-}
-function mergeLayerFilters(base, extra) {
-  if (!base && !extra) return void 0;
-  const merged = { ...base ?? {}, ...extra ?? {} };
-  return hasFilters(merged) ? merged : void 0;
-}
-var DEFAULT_MAX_FEATURES_FULL_GEOJSON = 5e4;
-function normalizeLayerType(layerType) {
-  return typeof layerType === "string" ? layerType.toLowerCase() : void 0;
-}
-function shouldUseFilterMultiple(layerType) {
-  return normalizeLayerType(layerType) === "multipolygon";
-}
-function shouldSkipGeojsonDownload(layerType, totalFeatures, thresholds = {
-  maxFeatures: DEFAULT_MAX_FEATURES_FULL_GEOJSON
-}) {
-  if (thresholds.allowLargeGeojson) {
-    return false;
-  }
-  const normalizedType = normalizeLayerType(layerType);
-  if (normalizedType === "mixed") {
-    return true;
-  }
-  if (typeof totalFeatures === "number" && totalFeatures > thresholds.maxFeatures) {
-    return true;
-  }
-  return false;
-}
-function parseBbox(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const candidate = value;
-  if (typeof candidate.minLon === "number" && typeof candidate.minLat === "number" && typeof candidate.maxLon === "number" && typeof candidate.maxLat === "number") {
-    return {
-      minLon: candidate.minLon,
-      minLat: candidate.minLat,
-      maxLon: candidate.maxLon,
-      maxLat: candidate.maxLat
-    };
-  }
-  if (Array.isArray(value) && value.length === 4) {
-    const [minLon, minLat, maxLon, maxLat] = value;
-    if (typeof minLon === "number" && typeof minLat === "number" && typeof maxLon === "number" && typeof maxLat === "number") {
-      return { minLon, minLat, maxLon, maxLat };
-    }
-  }
-  return void 0;
-}
-function buildBboxFromFeatureCollection(featureCollection) {
-  const coords = [];
-  const collect = (candidate) => {
-    if (!Array.isArray(candidate)) return;
-    if (candidate.length === 2 && typeof candidate[0] === "number" && typeof candidate[1] === "number" && Number.isFinite(candidate[0]) && Number.isFinite(candidate[1])) {
-      coords.push([candidate[0], candidate[1]]);
-      return;
-    }
-    candidate.forEach((item) => collect(item));
-  };
-  featureCollection.features.forEach((feature) => {
-    collect(feature.geometry?.coordinates);
-  });
-  if (coords.length === 0) return void 0;
-  const [firstLon, firstLat] = coords[0];
-  const bbox = { minLon: firstLon, minLat: firstLat, maxLon: firstLon, maxLat: firstLat };
-  coords.forEach(([lon, lat]) => {
-    bbox.minLon = Math.min(bbox.minLon, lon);
-    bbox.minLat = Math.min(bbox.minLat, lat);
-    bbox.maxLon = Math.max(bbox.maxLon, lon);
-    bbox.maxLat = Math.max(bbox.maxLat, lat);
-  });
-  return bbox;
-}
-function buildGeometryCollectionFromFeatureCollection(featureCollection) {
-  return {
-    type: "GeometryCollection",
-    geometries: featureCollection.features.map((feature) => feature.geometry).filter((geometry) => geometry !== void 0 && geometry !== null)
-  };
-}
-function buildAoiFromFeatureCollection(featureCollection, metadata) {
-  const metadataBbox = parseBbox(metadata?.bbox);
-  const derivedBbox = metadataBbox ?? buildBboxFromFeatureCollection(featureCollection);
-  const hasFeatures = featureCollection.features.length > 0;
-  const geometry = hasFeatures ? buildGeometryCollectionFromFeatureCollection(featureCollection) : void 0;
-  if (!derivedBbox && !geometry) {
-    return null;
-  }
-  return { bbox: derivedBbox, geometry };
-}
-function splitFeatureCollectionByLayerId(featureCollection, layerIds) {
-  const grouped = {};
-  layerIds.forEach((layerId) => {
-    grouped[String(layerId)] = createEmptyFeatureCollection();
-  });
-  featureCollection.features.forEach((feature) => {
-    const properties = feature.properties;
-    const layerId = properties?.layerId ?? properties?.layer_id ?? properties?.__zenit_layerId;
-    if (layerId === void 0 || layerId === null) {
-      return;
-    }
-    const key = String(layerId);
-    if (!grouped[key]) {
-      grouped[key] = createEmptyFeatureCollection();
-    }
-    grouped[key] = {
-      ...grouped[key],
-      features: [...grouped[key].features, feature]
-    };
-  });
-  return grouped;
-}
-function resolveLayerStrategy(params) {
-  const {
-    layerDetail,
-    bbox,
-    filterBBox,
-    filteredGeoJSON,
-    isVisible = true,
-    maxFeaturesFullGeojson,
-    allowLargeGeojson
-  } = params;
-  if (!isVisible) {
-    return { strategy: "geojson", effectiveBBox: bbox };
-  }
-  if (filteredGeoJSON && layerDetail.layerType !== "multipolygon") {
-    return {
-      strategy: "intersect",
-      intersectionGeometry: buildGeometryCollectionFromFeatureCollection(filteredGeoJSON)
-    };
-  }
-  const shouldSkipGeojson = shouldSkipGeojsonDownload(layerDetail.layerType, layerDetail.totalFeatures, {
-    maxFeatures: maxFeaturesFullGeojson ?? DEFAULT_MAX_FEATURES_FULL_GEOJSON,
-    allowLargeGeojson
-  });
-  if (shouldSkipGeojson && (filterBBox ?? bbox)) {
-    return { strategy: "bbox", effectiveBBox: filterBBox ?? bbox };
-  }
-  if ((layerDetail.totalFeatures ?? 0) > 5e3 && (filterBBox ?? bbox)) {
-    return { strategy: "bbox", effectiveBBox: filterBBox ?? bbox };
-  }
-  return { strategy: "geojson", effectiveBBox: bbox };
-}
-function buildLimitedMessage(metadata) {
-  if (!metadata) {
-    return void 0;
-  }
-  const explicit = metadata.limitedMessage;
-  if (typeof explicit === "string" && explicit.trim().length > 0) {
-    return explicit;
-  }
-  const limit = typeof metadata.limit === "number" ? metadata.limit : void 0;
-  const total = typeof metadata.totalFeatures === "number" ? metadata.totalFeatures : void 0;
-  if (limit !== void 0 && total !== void 0 && total > limit) {
-    return `Mostrando ${limit.toLocaleString()} de ${total.toLocaleString()} elementos por l\xEDmite de capa.`;
-  }
-  if (metadata.limited && limit !== void 0) {
-    return `Mostrando un m\xE1ximo de ${limit.toLocaleString()} elementos por l\xEDmite de capa.`;
-  }
-  return void 0;
-}
-var ZenitLayersClient = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  async getLayer(layerId) {
-    const response = await this.httpClient.get(
-      `/layers/${layerId}`
-    );
-    return this.unwrapResponse(response);
-  }
-  async getLayerGeoJson(layerId, options = {}) {
-    const params = parseQueryParams(options);
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const response = await this.httpClient.get(
-      `/layers/${layerId}/geojson${suffix}`
-    );
-    return this.unwrapResponse(response);
-  }
-  async getLayerFeaturesCatalog(layerId, options) {
-    if (options?.strict) {
-      const support = getCatalogSupport({
-        layerType: options.layerType,
-        geometryType: options.geometryType
-      });
-      if (!support.supported) {
-        throw new ZenitCatalogNotSupportedError(
-          support,
-          support.reason === "unknown-geometry" ? "Catalog support cannot be determined without a geometry type" : "Catalog is only supported for polygon or multipolygon geometries"
-        );
-      }
-    }
-    const response = await this.httpClient.get(
-      `/layers/${layerId}/features/catalog`
-    );
-    return this.unwrapResponse(response);
-  }
-  async getLayerFeatures(layerId, featureIds) {
-    if (!Array.isArray(featureIds) || featureIds.length === 0) {
-      throw new Error("featureIds is required and cannot be empty");
-    }
-    const query = featureIds.map(String).join(",");
-    const response = await this.httpClient.get(
-      `/layers/${layerId}/features?featureIds=${encodeURIComponent(query)}`
-    );
-    return this.unwrapResponse(response);
-  }
-  async filterLayerFeatures(layerId, filters) {
-    const query = buildLayerFilters(filters);
-    const suffix = query.toString();
-    const response = await this.httpClient.get(
-      `/layers/${layerId}/features/filter${suffix ? `?${suffix}` : ""}`
-    );
-    return this.unwrapResponse(response);
-  }
-  async filterMultipleLayersFeatures(params) {
-    const query = buildFilterMultipleParams(params);
-    const suffix = query.toString();
-    const response = await this.httpClient.get(`/layers/features/filter-multiple${suffix ? `?${suffix}` : ""}`);
-    return this.unwrapResponse(response);
-  }
-  async filterMultiple(params) {
-    return this.filterMultipleLayersFeatures(params);
-  }
-  /**
-   * Resilient filter-multiple helper:
-   * - Usa filter-multiple SOLO en capas multipolygon.
-   * - Para otras capas aplica filterLayerFeatures o getLayerGeoJson según haya filtros.
-   * - Nunca falla toda la operación por una capa inválida.
-   *
-   * Para mejor detección de layerType, pasa layerMetas con el layerType de cada capa.
-   */
-  async filterMultipleWithFallback(params) {
-    const layerIds = params.layerIds ?? [];
-    const perLayer = {};
-    const warnings = [];
-    const hasLayerMetas = (params.layerMetas ?? []).length > 0;
-    const maxFeaturesFullGeojson = params.maxFeaturesFullGeojson ?? DEFAULT_MAX_FEATURES_FULL_GEOJSON;
-    const allowLargeGeojson = params.allowLargeGeojson ?? false;
-    layerIds.forEach((layerId) => {
-      perLayer[String(layerId)] = createEmptyFeatureCollection();
-    });
-    if (layerIds.length === 0) {
-      return { perLayer };
-    }
-    const globalFilters = hasFilters(params.filters) ? params.filters : void 0;
-    const metaIndex = /* @__PURE__ */ new Map();
-    (params.layerMetas ?? []).forEach((meta) => {
-      metaIndex.set(String(meta.layerId), meta);
-    });
-    let multipolygonIds = [];
-    let otherIds = [];
-    const layerIdsWithData = /* @__PURE__ */ new Set();
-    let aoi = null;
-    const pushWarning = (message) => {
-      warnings.push(message);
-      console.warn(message);
-    };
-    const buildSkipWarning = (layerId, layerType, totalFeatures, reason) => {
-      const typeLabel = layerType ?? "unknown";
-      const totalLabel = typeof totalFeatures === "number" ? ` totalFeatures=${totalFeatures}` : "";
-      const reasonLabel = reason ? ` ${reason}` : "";
-      return `Layer ${layerId} skipped: layerType=${typeLabel}${totalLabel}${reasonLabel}`;
-    };
-    if (hasLayerMetas) {
-      layerIds.forEach((layerId) => {
-        const meta = metaIndex.get(String(layerId));
-        if (shouldUseFilterMultiple(meta?.layerType)) {
-          multipolygonIds.push(layerId);
-        } else {
-          otherIds.push(layerId);
-        }
-      });
-    } else {
-      multipolygonIds = [...layerIds];
-    }
-    let metadata;
-    if (multipolygonIds.length > 0) {
-      try {
-        const response = await this.filterMultipleLayersFeatures({
-          layerIds: multipolygonIds,
-          filters: globalFilters
-        });
-        metadata = response.metadata;
-        const geojson = response.data ?? createEmptyFeatureCollection();
-        if (globalFilters) {
-          aoi = buildAoiFromFeatureCollection(geojson, metadata);
-        }
-        const perLayerFromMultiple = splitFeatureCollectionByLayerId(geojson, layerIds);
-        Object.entries(perLayerFromMultiple).forEach(([layerKey, collection]) => {
-          if (collection.features.length === 0) {
-            return;
-          }
-          perLayer[layerKey] = decorateFeaturesWithLayerId(collection, layerKey);
-          layerIdsWithData.add(layerKey);
-        });
-      } catch {
-        if (hasLayerMetas) {
-          otherIds = [.../* @__PURE__ */ new Set([...otherIds, ...multipolygonIds])];
-        } else {
-          otherIds = [...layerIds];
-        }
-        multipolygonIds = [];
-      }
-    }
-    if (otherIds.length > 0) {
-      const pendingIds = otherIds.filter(
-        (layerId) => !layerIdsWithData.has(String(layerId))
-      );
-      const resolved = await Promise.all(
-        pendingIds.map(async (layerId) => {
-          const meta = metaIndex.get(String(layerId));
-          const layerType = meta?.layerType;
-          const totalFeatures = meta?.totalFeatures;
-          const layerFilters = mergeLayerFilters(globalFilters, meta?.prefilters);
-          const canUseIntersect = !!globalFilters && !shouldUseFilterMultiple(layerType) && !!aoi?.geometry;
-          if (canUseIntersect) {
-            const intersectionGeometry = aoi?.geometry;
-            if (!intersectionGeometry) {
-              pushWarning(
-                buildSkipWarning(
-                  layerId,
-                  layerType,
-                  totalFeatures,
-                  "no AOI geometry available"
-                )
-              );
-              return { layerId, geojson: createEmptyFeatureCollection() };
-            }
-            try {
-              const response = await this.getLayerGeoJsonIntersect({
-                id: layerId,
-                geometry: intersectionGeometry
-              });
-              if (aoi?.bbox) {
-                console.debug(
-                  `Layer ${layerId} fetched by intersect using AOI bbox=${JSON.stringify(
-                    aoi.bbox
-                  )}`
-                );
-              } else {
-                console.debug(`Layer ${layerId} fetched by intersect using AOI geometry`);
-              }
-              const geojson = response.data ?? createEmptyFeatureCollection();
-              return {
-                layerId,
-                geojson: decorateFeaturesWithLayerId(geojson, layerId)
-              };
-            } catch (error) {
-              const message = error instanceof Error ? error.message : "Unknown error";
-              pushWarning(
-                buildSkipWarning(
-                  layerId,
-                  layerType,
-                  totalFeatures,
-                  `intersect failed: ${message}`
-                )
-              );
-              return { layerId, geojson: createEmptyFeatureCollection() };
-            }
-          }
-          if (layerFilters && (hasLayerMetas ? shouldUseFilterMultiple(layerType) : true)) {
-            try {
-              const response = await this.filterLayerFeatures(layerId, layerFilters);
-              const geojson = response.data ?? createEmptyFeatureCollection();
-              return {
-                layerId,
-                geojson: decorateFeaturesWithLayerId(geojson, layerId)
-              };
-            } catch (error) {
-              const message = error instanceof Error ? error.message : "Unknown error";
-              pushWarning(
-                `Layer ${layerId} filter failed: ${message}`
-              );
-              return { layerId, geojson: createEmptyFeatureCollection() };
-            }
-          }
-          if (shouldSkipGeojsonDownload(layerType, totalFeatures, {
-            maxFeatures: maxFeaturesFullGeojson,
-            allowLargeGeojson
-          })) {
-            pushWarning(
-              buildSkipWarning(
-                layerId,
-                layerType,
-                totalFeatures,
-                "not supported by filter endpoint and too large for /geojson; use intersect with AOI"
-              )
-            );
-            return { layerId, geojson: createEmptyFeatureCollection() };
-          }
-          try {
-            const response = await this.getLayerGeoJson(layerId);
-            const geojson = response.data ?? createEmptyFeatureCollection();
-            return {
-              layerId,
-              geojson: decorateFeaturesWithLayerId(geojson, layerId)
-            };
-          } catch (error) {
-            const message = error instanceof Error ? error.message : "Unknown error";
-            pushWarning(
-              buildSkipWarning(layerId, layerType, totalFeatures, `error=${message}`)
-            );
-            return { layerId, geojson: createEmptyFeatureCollection() };
-          }
-        })
-      );
-      resolved.forEach(({ layerId, geojson }) => {
-        perLayer[String(layerId)] = geojson;
-      });
-    }
-    const mergedMetadata = warnings.length > 0 ? {
-      ...metadata ?? {},
-      warnings: [...metadata?.warnings ?? [], ...warnings]
-    } : metadata;
-    return { perLayer, metadata: mergedMetadata, aoi };
-  }
-  async getLayerGeoJsonBBox(request) {
-    const params = new URLSearchParams({
-      minLon: String(request.bbox.minLon),
-      minLat: String(request.bbox.minLat),
-      maxLon: String(request.bbox.maxLon),
-      maxLat: String(request.bbox.maxLat)
-    });
-    parseQueryParams(request).forEach((value, key) => params.set(key, value));
-    const response = await this.httpClient.get(
-      `/layers/${request.id}/geojson/bbox?${params.toString()}`
-    );
-    return this.unwrapResponse(response);
-  }
-  async getLayerGeoJsonIntersect(request) {
-    const params = parseQueryParams(request);
-    const suffix = params.size > 0 ? `?${params.toString()}` : "";
-    const response = await this.httpClient.post(
-      `/layers/${request.id}/geojson/intersects${suffix}`,
-      { geometry: request.geometry }
-    );
-    return this.unwrapResponse(response);
-  }
-  async getLayerTileTemplate(layerId) {
-    const response = await this.httpClient.get(
-      `/layers/${layerId}/tiles/template`
-    );
-    const unwrapped = this.unwrapResponse(response);
-    if (typeof unwrapped.data === "string") {
-      return unwrapped.data;
-    }
-    if (unwrapped.data && typeof unwrapped.data.template === "string") {
-      return unwrapped.data.template;
-    }
-    throw new Error("Invalid tile template response");
-  }
-  async loadLayerData(params) {
-    const { id, layerDetail, bbox, filterBBox, filteredGeoJSON, isVisible = true, ...options } = params;
-    const resolution = resolveLayerStrategy({
-      layerDetail,
-      bbox,
-      filterBBox,
-      filteredGeoJSON,
-      isVisible,
-      maxFeaturesFullGeojson: params.maxFeaturesFullGeojson,
-      allowLargeGeojson: params.allowLargeGeojson
-    });
-    const response = await this.fetchByStrategy(id, resolution, options);
-    const totalFeatures = asOptionalNumber(response.totalFeatures) ?? asOptionalNumber(response.metadata?.totalFeatures) ?? asOptionalNumber(layerDetail.totalFeatures);
-    const limitedMessage = response.limitedMessage ?? buildLimitedMessage(response.metadata);
-    return {
-      geojson: response.data,
-      strategy: resolution.strategy,
-      limitedMessage,
-      totalFeatures,
-      metadata: response.metadata
-    };
-  }
-  async loadFilteredFeatures(params) {
-    const response = await this.filterMultipleLayersFeatures(params);
-    return {
-      geojson: response.data,
-      metadata: response.metadata,
-      totalFeatures: response.metadata?.totalFeatures ?? response.totalFeatures
-    };
-  }
-  async fetchByStrategy(layerId, resolution, options) {
-    switch (resolution.strategy) {
-      case "bbox": {
-        if (!resolution.effectiveBBox) {
-          throw new Error("Bounding box is required for bbox strategy");
-        }
-        return this.getLayerGeoJsonBBox({ id: layerId, bbox: resolution.effectiveBBox, ...options });
-      }
-      case "intersect": {
-        if (!resolution.intersectionGeometry) {
-          throw new Error("Geometry is required for intersect strategy");
-        }
-        return this.getLayerGeoJsonIntersect({
-          id: layerId,
-          geometry: resolution.intersectionGeometry,
-          ...options
-        });
-      }
-      case "geojson":
-      default:
-        return this.getLayerGeoJson(layerId, options);
-    }
-  }
-  unwrapResponse(response) {
-    if (!response || typeof response !== "object" || !("data" in response)) {
-      throw new Error("Invalid API response: missing data field");
-    }
-    if ("success" in response && response.success === false) {
-      throw new Error(response.message ?? "Request was not successful");
-    }
-    return response;
-  }
-};
-
-// src/config/ZenitSdkConfig.ts
-var ZenitClient = class {
-  constructor(config) {
-    this.config = config;
-    this.accessToken = config.accessToken;
-    this.refreshToken = config.refreshToken;
-    this.sdkToken = config.sdkToken;
-    this.defaultFilters = config.defaultFilters;
-    this.httpClient = new HttpClient({
-      baseUrl: config.baseUrl,
-      resolveTokens: () => ({ accessToken: this.accessToken, sdkToken: this.sdkToken }),
-      resolveAuthorizationHeader: this.getAuthorizationHeader.bind(this)
-    });
-    this.auth = new ZenitAuthClient(this.httpClient, this.updateTokens.bind(this), config);
-    this.sdkAuth = new ZenitSdkAuthClient(
-      this.httpClient,
-      this.updateAccessTokenFromSdkExchange.bind(this),
-      config
-    );
-    this.maps = new ZenitMapsClient(this.httpClient);
-    this.layers = new ZenitLayersClient(this.httpClient);
-  }
-  /**
-   * Update tokens in memory and propagate to config callbacks.
-   */
-  updateTokens(tokens) {
-    if (tokens.accessToken) {
-      this.setAccessToken(tokens.accessToken);
-    }
-    if (tokens.refreshToken) {
-      this.setRefreshToken(tokens.refreshToken);
-    }
-    this.config.onTokenRefreshed?.({
-      accessToken: this.accessToken || "",
-      refreshToken: this.refreshToken
-    });
-  }
-  // Se usa cuando /sdk-auth/exchange devuelve un accessToken; pasa a ser el accessToken principal del SDK.
-  updateAccessTokenFromSdkExchange(token) {
-    if (token) {
-      this.setAccessToken(token);
-    }
-  }
-  /**
-   * Update the access token at runtime.
-   */
-  setAccessToken(token) {
-    this.accessToken = token;
-    this.config.accessToken = token;
-  }
-  /**
-   * Update the refresh token at runtime.
-   */
-  setRefreshToken(token) {
-    this.refreshToken = token;
-    this.config.refreshToken = token;
-  }
-  /**
-   * Update the SDK token at runtime.
-   */
-  setSdkToken(token) {
-    this.sdkToken = token;
-    this.config.sdkToken = token;
-  }
-  /**
-   * Update both access token and SDK token at once.
-   */
-  setAuth(params) {
-    if ("accessToken" in params) {
-      this.setAccessToken(params.accessToken);
-    }
-    if ("sdkToken" in params) {
-      this.setSdkToken(params.sdkToken);
-    }
-  }
-  /**
-   * Update base URL at runtime (e.g. injected config from a host app).
-   */
-  setBaseUrl(baseUrl) {
-    this.config.baseUrl = baseUrl;
-    this.httpClient.setBaseUrl(baseUrl);
-  }
-  /**
-   * Store default filters for UI integrations.
-   */
-  setDefaultFilters(filters) {
-    this.defaultFilters = filters;
-    this.config.defaultFilters = filters;
-  }
-  /**
-   * Return default filters for UI integrations.
-   */
-  getDefaultFilters() {
-    return this.defaultFilters ? { ...this.defaultFilters } : void 0;
-  }
-  /**
-   * Get a readonly snapshot of the current SDK config.
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Get a readonly snapshot of runtime config for debugging or host integrations.
-   */
-  getRuntimeConfig() {
-    return {
-      baseUrl: this.config.baseUrl,
-      accessToken: this.accessToken,
-      sdkToken: this.sdkToken,
-      defaultFilters: this.defaultFilters ? { ...this.defaultFilters } : void 0
-    };
-  }
-  /**
-   * Build an authorization header on demand using the current token values.
-   */
-  getAuthorizationHeader() {
-    const header = {};
-    if (this.accessToken) {
-      header.Authorization = `Bearer ${this.accessToken}`;
-    }
-    return header;
-  }
-  getHttpClient() {
-    return this.httpClient;
-  }
-};
-
-// src/config/ZenitRuntimeConfig.ts
-var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var normalizeFilters = (filters) => {
-  if (!isPlainRecord(filters)) {
-    return {};
-  }
-  return { ...filters };
-};
-var mergeFilters = (base = {}, next = {}) => ({
-  ...base,
-  ...next
-});
-var resolveRuntimeConfig = (input) => {
-  if (!isPlainRecord(input)) {
-    return null;
-  }
-  const baseUrl = typeof input.baseUrl === "string" ? input.baseUrl : null;
-  if (!baseUrl) {
-    return null;
-  }
-  const accessToken = typeof input.accessToken === "string" ? input.accessToken : void 0;
-  const sdkToken = typeof input.sdkToken === "string" ? input.sdkToken : void 0;
-  let mapId;
-  if (typeof input.mapId === "number" && !Number.isNaN(input.mapId)) {
-    mapId = input.mapId;
-  } else if (typeof input.mapId === "string" && input.mapId.trim() !== "") {
-    const parsed = Number(input.mapId);
-    if (!Number.isNaN(parsed)) {
-      mapId = parsed;
-    }
-  }
-  let defaultFilters;
-  if (isPlainRecord(input.defaultFilters)) {
-    defaultFilters = normalizeFilters(input.defaultFilters);
-  }
-  return {
-    baseUrl,
-    accessToken,
-    sdkToken,
-    mapId,
-    defaultFilters
-  };
-};
-
-// src/engine/FilterEngine.ts
-var FilterEngine = class {
-  decide(params) {
-    if (params.request) {
-      return { nextRequest: params.request };
-    }
-    if (params.filters && params.layerIds && params.layerIds.length > 1) {
-      return {
-        nextRequest: {
-          type: "filter-multiple",
-          layerIds: params.layerIds,
-          filters: params.filters
-        },
-        reason: "filters+layerIds"
-      };
-    }
-    if (params.filters && params.layerId !== void 0) {
-      return {
-        nextRequest: {
-          type: "filter-layer",
-          layerId: params.layerId,
-          filters: params.filters
-        },
-        reason: "filters+layerId"
-      };
-    }
-    if (params.bbox && params.layerId !== void 0) {
-      return {
-        nextRequest: {
-          type: "bbox",
-          layerId: params.layerId,
-          bbox: params.bbox,
-          options: params.options
-        },
-        reason: "bbox+layerId"
-      };
-    }
-    if (params.geometry && params.layerId !== void 0) {
-      return {
-        nextRequest: {
-          type: "intersect",
-          layerId: params.layerId,
-          geometry: params.geometry,
-          options: params.options
-        },
-        reason: "geometry+layerId"
-      };
-    }
-    if (params.layerId !== void 0) {
-      return {
-        nextRequest: {
-          type: "geojson",
-          layerId: params.layerId,
-          options: params.options
-        },
-        reason: "layerId"
-      };
-    }
-    throw new Error("FilterEngine could not resolve a next request");
-  }
-};
-var filterEngine = new FilterEngine();
-
-// src/ai/normalize.ts
-function normalizeBbox(input) {
-  if (!input) return null;
-  if (Array.isArray(input)) {
-    if (input.length !== 4) {
-      console.warn("[normalizeBbox] Array must have exactly 4 elements, got:", input.length);
-      return null;
-    }
-    const [minLon, minLat, maxLon, maxLat] = input;
-    if (typeof minLon !== "number" || typeof minLat !== "number" || typeof maxLon !== "number" || typeof maxLat !== "number" || !Number.isFinite(minLon) || !Number.isFinite(minLat) || !Number.isFinite(maxLon) || !Number.isFinite(maxLat)) {
-      console.warn("[normalizeBbox] Array contains non-finite numbers:", input);
-      return null;
-    }
-    if (minLon >= maxLon || minLat >= maxLat) {
-      console.warn("[normalizeBbox] Invalid bbox: min must be < max", {
-        minLon,
-        maxLon,
-        minLat,
-        maxLat
-      });
-      return null;
-    }
-    return { minLon, minLat, maxLon, maxLat };
-  }
-  if (typeof input === "object") {
-    const candidate = input;
-    const { minLon, minLat, maxLon, maxLat } = candidate;
-    if (typeof minLon !== "number" || typeof minLat !== "number" || typeof maxLon !== "number" || typeof maxLat !== "number" || !Number.isFinite(minLon) || !Number.isFinite(minLat) || !Number.isFinite(maxLon) || !Number.isFinite(maxLat)) {
-      console.warn("[normalizeBbox] Object missing valid bbox keys or contains non-finite numbers:", input);
-      return null;
-    }
-    if (minLon >= maxLon || minLat >= maxLat) {
-      console.warn("[normalizeBbox] Invalid bbox: min must be < max", {
-        minLon,
-        maxLon,
-        minLat,
-        maxLat
-      });
-      return null;
-    }
-    return { minLon, minLat, maxLon, maxLat };
-  }
-  console.warn("[normalizeBbox] Unsupported bbox format:", typeof input);
-  return null;
-}
-export {
-  ChevronLeft,
-  ChevronRight,
-  DEFAULT_MAX_FEATURES_FULL_GEOJSON,
-  Eye,
-  EyeOff,
-  FilterEngine,
-  FloatingChatBox,
-  HttpClient,
-  Layers,
-  Upload,
-  X,
-  ZenitAuthClient,
-  ZenitCatalogNotSupportedError,
-  ZenitClient,
-  ZenitFeatureFilterPanel,
-  ZenitLayerManager,
-  ZenitLayersClient,
-  ZenitMap,
-  ZenitMapsClient,
-  ZenitSdkAuthClient,
-  ZoomIn,
-  applyFilteredGeoJSONStrategy,
-  applyLayerOverrides,
-  applyPrefiltersToFeatureCollection,
-  buildAoiFromFeatureCollection,
-  buildFilterMultipleParams,
-  buildLayerFilters,
-  buildLimitedMessage,
-  centroidFromBBox,
-  clampNumber,
-  clampOpacity,
-  computeBBoxFromFeature,
-  createChatService,
-  decorateFeaturesWithLayerId,
-  extractMapDto,
-  filterEngine,
-  getAccentByLayerId,
-  getCatalogSupport,
-  getEffectiveLayerOpacity,
-  getLayerColor,
-  getLayerZoomOpacityFactor,
-  getStyleByLayerId,
-  getZoomOpacityFactor,
-  initLayerStates,
-  isPolygonLayer,
-  mergeFilters,
-  normalizeBbox,
-  normalizeFilters,
-  normalizeMapCenter,
-  normalizeMapLayers,
-  resetOverrides,
-  resolveLayerAccent,
-  resolveLayerStrategy,
-  resolveRuntimeConfig,
-  sendMessage,
-  sendMessageStream,
-  shouldSkipGeojsonDownload,
-  shouldUseFilterMultiple,
-  useSendMessage,
-  useSendMessageStream
-};
-//# sourceMappingURL=index.mjs.map