zenit-sdk 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1095 @@
+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-RGS6AZWV.mjs";
+
+// src/http/HttpClient.ts
+var HttpClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.resolveTokens = options.resolveTokens;
+    this.resolveAuthorizationHeader = options.resolveAuthorizationHeader ?? (() => ({}));
+  }
+  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 (Array.isArray(value)) {
+    const serialized2 = value.map(String).filter((item) => item.trim().length > 0).join(",");
+    return serialized2.length > 0 ? serialized2 : void 0;
+  }
+  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]) => {
+    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.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);
+    }
+  }
+  setAccessToken(token) {
+    this.accessToken = token;
+    this.config.accessToken = token;
+  }
+  setRefreshToken(token) {
+    this.refreshToken = token;
+    this.config.refreshToken = token;
+  }
+  getAuthorizationHeader() {
+    const header = {};
+    if (this.accessToken) {
+      header.Authorization = `Bearer ${this.accessToken}`;
+    }
+    return header;
+  }
+  getHttpClient() {
+    return this.httpClient;
+  }
+};
+
+// 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,
+  normalizeBbox,
+  normalizeMapCenter,
+  normalizeMapLayers,
+  resetOverrides,
+  resolveLayerAccent,
+  resolveLayerStrategy,
+  sendMessage,
+  sendMessageStream,
+  shouldSkipGeojsonDownload,
+  shouldUseFilterMultiple,
+  useSendMessage,
+  useSendMessageStream
+};
+//# sourceMappingURL=index.mjs.map