@m4l/gclick 0.3.0 → 0.3.1-beta.1

package/components/maps/components/GpsMap/hooks/useDisableClickEvents/index.d.ts

@@ -4,3 +4,4 @@
  * @param nodeElement
  */
 export declare function useDisableClickEvents(nodeElement: HTMLDivElement | null): void;
+//# sourceMappingURL=index.d.ts.map

package/components/maps/components/GpsMap/hooks/useDisableClickEvents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useDisableClickEvents/index.tsx"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,cAAc,GAAG,IAAI,QAqBvE"}

package/components/maps/components/GpsMap/hooks/useDisableMapEventsOnFlag/index.d.ts

@@ -4,3 +4,4 @@
  * @param nodeElement
  */
 export declare function useDisableMapEventsOnFlag(flag: boolean): void;
+//# sourceMappingURL=index.d.ts.map

package/components/maps/components/GpsMap/hooks/useDisableMapEventsOnFlag/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useDisableMapEventsOnFlag/index.tsx"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,OAAO,QA+BtD"}

package/components/maps/components/GpsMap/hooks/useDisableMapEventsOnFlag/index.js

@@ -1,31 +1,11 @@
-import { useRef, useEffect } from "react";
-import { useMap } from "react-leaflet";
-function useDisableMapEventsOnFlag(flag) {
-  const map = useMap();
-  const refPreviousFlag = useRef(false);
-  useEffect(() => {
-    if (!map || refPreviousFlag.current === flag) {
-      return;
-    }
-    if (flag) {
-      refPreviousFlag.current = true;
-      map.dragging.disable();
-      map.doubleClickZoom.disable();
-      map.scrollWheelZoom.disable();
-      map.touchZoom.disable();
-      map.boxZoom.disable();
-      map.keyboard.disable();
-    } else {
-      map.dragging.enable();
-      map.scrollWheelZoom.enable();
-      map.doubleClickZoom.enable();
-      map.touchZoom.enable();
-      map.boxZoom.enable();
-      map.keyboard.enable();
-    }
-    refPreviousFlag.current = flag;
-  }, [map, flag]);
+import { useRef as r, useEffect as a } from "react";
+import { useMap as b } from "react-leaflet";
+function i(o) {
+  const e = b(), l = r(!1);
+  a(() => {
+    !e || l.current === o || (o ? (l.current = !0, e.dragging.disable(), e.doubleClickZoom.disable(), e.scrollWheelZoom.disable(), e.touchZoom.disable(), e.boxZoom.disable(), e.keyboard.disable()) : (e.dragging.enable(), e.scrollWheelZoom.enable(), e.doubleClickZoom.enable(), e.touchZoom.enable(), e.boxZoom.enable(), e.keyboard.enable()), l.current = o);
+  }, [e, o]);
 }
 export {
-  useDisableMapEventsOnFlag as u
+  i as useDisableMapEventsOnFlag
 };

package/components/maps/components/GpsMap/hooks/useDisableMapEventsOnMouseOver/index.d.ts

@@ -4,3 +4,4 @@
  * @param nodeElement
  */
 export declare function useDisableMapEventsOnMouseOver(nodeElement: HTMLDivElement | null): void;
+//# sourceMappingURL=index.d.ts.map

package/components/maps/components/GpsMap/hooks/useDisableMapEventsOnMouseOver/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useDisableMapEventsOnMouseOver/index.tsx"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,cAAc,GAAG,IAAI,QAwChF"}

package/components/maps/components/GpsMap/hooks/useDisableMapEventsOnMouseOver/index.js

@@ -1,37 +1,19 @@
-import { useCallback, useEffect } from "react";
-import { useMap } from "react-leaflet";
-import L__default from "leaflet";
-function useDisableMapEventsOnMouseOver(nodeElement) {
-  const map = useMap();
-  const disableMapEvents = useCallback(() => {
-    map.dragging.disable();
-    map.doubleClickZoom.disable();
-    map.scrollWheelZoom.disable();
-    map.touchZoom.disable();
-    map.boxZoom.disable();
-    map.keyboard.disable();
-  }, [map]);
-  const enableMapEvents = useCallback(() => {
-    map.dragging.enable();
-    map.doubleClickZoom.enable();
-    map.scrollWheelZoom.enable();
-    map.touchZoom.enable();
-    map.boxZoom.enable();
-    map.keyboard.enable();
-  }, [map]);
-  useEffect(() => {
-    if (!map || !nodeElement) {
-      return;
-    }
-    L__default.DomEvent.disableClickPropagation(nodeElement);
-    nodeElement.addEventListener("mouseover", disableMapEvents);
-    nodeElement.addEventListener("mouseleave", enableMapEvents);
-    return () => {
-      nodeElement.removeEventListener("mouseover", disableMapEvents);
-      nodeElement.removeEventListener("mouseleave", enableMapEvents);
-    };
-  }, [disableMapEvents, enableMapEvents, map, nodeElement]);
+import { useCallback as r, useEffect as l } from "react";
+import { useMap as i } from "react-leaflet";
+import b from "leaflet";
+function m(o) {
+  const e = i(), a = r(() => {
+    e.dragging.disable(), e.doubleClickZoom.disable(), e.scrollWheelZoom.disable(), e.touchZoom.disable(), e.boxZoom.disable(), e.keyboard.disable();
+  }, [e]), s = r(() => {
+    e.dragging.enable(), e.doubleClickZoom.enable(), e.scrollWheelZoom.enable(), e.touchZoom.enable(), e.boxZoom.enable(), e.keyboard.enable();
+  }, [e]);
+  l(() => {
+    if (!(!e || !o))
+      return b.DomEvent.disableClickPropagation(o), o.addEventListener("mouseover", a), o.addEventListener("mouseleave", s), () => {
+        o.removeEventListener("mouseover", a), o.removeEventListener("mouseleave", s);
+      };
+  }, [a, s, e, o]);
 }
 export {
-  useDisableMapEventsOnMouseOver as u
+  m as useDisableMapEventsOnMouseOver
 };

package/components/maps/components/GpsMap/hooks/useMapStore/index.d.ts

@@ -4,3 +4,4 @@ import { MapStateWithActions } from '../../contexts/MapContext/types';
  */
 export declare function useMapStore<T>(selector: (state: MapStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;
 export default useMapStore;
+//# sourceMappingURL=index.d.ts.map

package/components/maps/components/GpsMap/hooks/useMapStore/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useMapStore/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAQtE;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,CAAC,EAC3C,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,GAC1C,CAAC,CAIH;AACD,eAAe,WAAW,CAAC"}

package/components/maps/components/GpsMap/hooks/useMapStore/index.js

@@ -1,13 +1,13 @@
-import { useContext } from "react";
-import { useStore } from "zustand";
-import { M as MapContext } from "../../contexts/MapContext/MapContext.js";
-function useMapStore(selector, equalityFn) {
-  const context = useContext(MapContext);
-  if (!context) {
+import { useContext as r } from "react";
+import { useStore as n } from "zustand";
+import { MapContext as s } from "../../contexts/MapContext/MapContext.js";
+function m(e, o) {
+  const t = r(s);
+  if (!t)
     throw new Error("useMapStore context must be use inside MapContext");
-  }
-  return useStore(context, selector, equalityFn);
+  return n(t, e, o);
 }
 export {
-  useMapStore as u
+  m as default,
+  m as useMapStore
 };

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/GridDebugVisualization.d.ts

@@ -0,0 +1,10 @@
+import { GridCell } from './types';
+interface GridDebugVisualizationProps {
+    cells: GridCell[];
+}
+/**
+ * Componente temporal para visualizar la grilla de muestreo (solo para debug)
+ */
+export declare function GridDebugVisualization({ cells }: GridDebugVisualizationProps): null;
+export {};
+//# sourceMappingURL=GridDebugVisualization.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/GridDebugVisualization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridDebugVisualization.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/GridDebugVisualization.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,UAAU,2BAA2B;IACnC,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,KAAK,EAAE,EAAE,2BAA2B,QA+C5E"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/constants.d.ts

@@ -0,0 +1,6 @@
+import { ZoomBasedFilterConfig } from './types';
+import { PixelPathFilterConfig } from './createPixelPathDecimationFilter/types';
+export declare const DEFAULT_CONFIG: Required<ZoomBasedFilterConfig>;
+export declare const PIXEL_PATH_DEFAULT_CONFIG: Required<PixelPathFilterConfig>;
+export declare const USE_FILTER_DECIMATION_DEFAULT_DEBOUNCE_MS = 150;
+//# sourceMappingURL=constants.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAErF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,qBAAqB,CAa1D,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,qBAAqB,CAMrE,CAAC;AAEF,eAAO,MAAM,yCAAyC,MAAM,CAAC"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/constants.js

@@ -0,0 +1,11 @@
+const t = {
+  enabled: !0,
+  viewportOffsetFactor: 1.2,
+  minPixelDistance: 40,
+  alwaysShowFirstAndLast: !0,
+  maxMarkers: 500
+}, e = 150;
+export {
+  t as PIXEL_PATH_DEFAULT_CONFIG,
+  e as USE_FILTER_DECIMATION_DEFAULT_DEBOUNCE_MS
+};

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByConcentrationGrid.d.ts

@@ -0,0 +1,14 @@
+import { FeatureWithCoords } from '../types';
+/**
+ * Decima un conjunto de IDs cuando superan `maxMarkers`, usando una grilla espacial sobre
+ * el bbox (minLng, minLat, maxLng, maxLat).
+ *
+ * Divide el área en una grilla de aproximadamente sqrt(maxMarkers) × sqrt(maxMarkers) celdas
+ * y mantiene como máximo una marca por celda. Preserva el orden original y, si se pasa
+ * `firstAndLast`, prioriza siempre el primer y último punto del path.
+ */
+export declare function decimateByConcentrationGrid(orderedIds: (string | number)[], idToPoint: Map<string | number, FeatureWithCoords>, minLng: number, minLat: number, maxLng: number, maxLat: number, maxMarkers: number, firstAndLast?: {
+    firstId: string | number;
+    lastId: string | number;
+}): (string | number)[];
+//# sourceMappingURL=decimateByConcentrationGrid.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByConcentrationGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimateByConcentrationGrid.d.ts","sourceRoot":"","sources":["../../../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByConcentrationGrid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAC/B,SAAS,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,iBAAiB,CAAC,EAClD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE;IAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GACnE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAiDrB"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByConcentrationGrid.js

@@ -0,0 +1,36 @@
+function x(c, h, u, g, w, v, a, p) {
+  if (c.length <= a)
+    return c;
+  const d = w - u, r = v - g;
+  if (d <= 0 || r <= 0)
+    return c.slice(0, a);
+  const i = Math.max(1, Math.floor(Math.sqrt(a))), s = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set(), e = [];
+  function M(t, o) {
+    const n = Math.min(i - 1, Math.max(0, Math.floor((o - u) / d * i)));
+    return Math.min(i - 1, Math.max(0, Math.floor((t - g) / r * i))) * i + n;
+  }
+  if (p) {
+    const { firstId: t, lastId: o } = p;
+    for (const n of [t, o]) {
+      if (n === void 0 || f.has(n))
+        continue;
+      const l = h.get(n);
+      l !== void 0 && (f.add(n), e.push(n), s.add(M(l.lat, l.lng)));
+    }
+  }
+  for (const t of c) {
+    if (f.has(t))
+      continue;
+    if (e.length >= a)
+      break;
+    const o = h.get(t);
+    if (o === void 0)
+      continue;
+    const n = M(o.lat, o.lng);
+    s.has(n) || (s.add(n), f.add(t), e.push(t));
+  }
+  return e.sort((t, o) => c.indexOf(t) - c.indexOf(o));
+}
+export {
+  x as decimateByConcentrationGrid
+};

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByPixelDistanceAlongPath.d.ts

@@ -0,0 +1,15 @@
+import { Map as LeafletMap } from 'leaflet';
+import { FeatureWithCoords } from '../types';
+/**
+ * Decima una secuencia ordenada de puntos manteniendo solo aquellos que distan al menos
+ * `minPixelDistance` píxeles del anterior en el path (en coordenadas de pantalla).
+ *
+ * Recorre `indicesInRouteOrder` (orden del recorrido), proyecta cada punto a píxeles con
+ * map.latLngToLayerPoint, y añade al resultado solo si la distancia euclídea al último
+ * punto seleccionado supera el umbral. Usa distancia al cuadrado para evitar Math.sqrt.
+ *
+ * Si `alwaysShowFirstAndLast` es true, garantiza que el primer y último punto del path
+ * estén en el resultado aunque no cumplan la distancia mínima.
+ */
+export declare function decimateByPixelDistanceAlongPath(map: LeafletMap, indicesInRouteOrder: number[], points: FeatureWithCoords[], minPixelDistance: number, alwaysShowFirstAndLast: boolean): (string | number)[];
+//# sourceMappingURL=decimateByPixelDistanceAlongPath.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByPixelDistanceAlongPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimateByPixelDistanceAlongPath.d.ts","sourceRoot":"","sources":["../../../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByPixelDistanceAlongPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,UAAU,EACf,mBAAmB,EAAE,MAAM,EAAE,EAC7B,MAAM,EAAE,iBAAiB,EAAE,EAC3B,gBAAgB,EAAE,MAAM,EACxB,sBAAsB,EAAE,OAAO,GAC9B,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAuCrB"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/decimateByPixelDistanceAlongPath.js

@@ -0,0 +1,18 @@
+function r(i, x, a, l, u) {
+  const s = [];
+  let n = null;
+  const y = l * l;
+  for (const d of x) {
+    const o = a[d], t = i.latLngToLayerPoint([o.lat, o.lng]);
+    if (n === null) {
+      s.push(o.id), n = { x: t.x, y: t.y };
+      continue;
+    }
+    const c = t.x - n.x, e = t.y - n.y;
+    c * c + e * e >= y && (s.push(o.id), n = { x: t.x, y: t.y });
+  }
+  return s;
+}
+export {
+  r as decimateByPixelDistanceAlongPath
+};

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export { decimateByConcentrationGrid } from './decimateByConcentrationGrid';
+export { decimateByPixelDistanceAlongPath } from './decimateByPixelDistanceAlongPath';
+//# sourceMappingURL=index.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/index.d.ts

@@ -0,0 +1,65 @@
+import { DecimationFilter, PixelPathFilterConfig } from './types';
+/**
+ * Factory que crea una función de decimación para reducir marcadores en capas de mapa
+ * con secuencias ordenadas de puntos (p. ej. historial GPS, rutas, waypoints).
+ *
+ * ## Propósito
+ *
+ * Cuando una capa tiene miles de puntos (p. ej. un recorrido GPS de muchas horas),
+ * renderizar todos degrada el rendimiento. Esta función retorna un filtro que reduce
+ * los puntos visibles manteniendo la forma visual del path y priorizando los que
+ * están en el viewport actual.
+ *
+ * ## Algoritmo (en orden)
+ *
+ * 1. **Índice espacial (KDBush)**: Construye un índice para consultas de rango O(log n).
+ * Se cachea mientras featureIds/featuresWithCoords no cambien.
+ *
+ * 2. **Orden del path**: Ordena los puntos según el orden de featureIds (orden temporal
+ * del recorrido, no espacial).
+ *
+ * 3. **Decimación por distancia en píxeles**: Recorre el path en orden y mantiene solo
+ * puntos que distan al menos `minPixelDistance` píxeles del anterior. Evita
+ * saturar zonas con muchos puntos cercanos.
+ *
+ * 4. **Filtro por viewport**: Usa KDBush.range() para quedarse solo con puntos dentro
+ * del bounds visible (ampliado por viewportOffsetFactor). Los que están fuera no
+ * se renderizan.
+ *
+ * 5. **Primero y último del path**: Si `alwaysShowFirstAndLast`, añade el primer y
+ * último punto del recorrido solo si están en viewport, aunque no cumplan la distancia
+ * mínima, para no cortar visualmente el inicio/fin.
+ *
+ * 6. **Límite por concentración (opcional)**: Si tras lo anterior hay más de `maxMarkers`,
+ * aplica una grilla espacial para distribuir las marcas y no saturar zonas densas.
+ *
+ * ## Uso típico
+ *
+ * ```ts
+ * addLayer({
+ * layerId: 'points',
+ * renderFeature: HistoryMarkerRender,
+ * decimationConfig: {
+ * decimationFilter: createPixelPathDecimationFilter({
+ * minPixelDistance: 80,
+ * maxMarkers: 500,
+ * }),
+ * },
+ * });
+ * ```
+ *
+ * ## Cache
+ *
+ * Si el hook pasa `params.cache`, se reutilizan:
+ * - El índice KDBush y los mapas auxiliares entre llamadas (zoom/pan).
+ * - El resultado de decimateByPixelDistanceAlongPath **por nivel de zoom**: al volver
+ * a un zoom ya visitado, se devuelve el resultado cacheado sin recalcular.
+ *
+ * La cache se invalida cuando cambian featureIds o featuresWithCoords.
+ * @param config - Opciones de decimación (minPixelDistance, viewportOffsetFactor, etc.).
+ *                 Si no se pasa, se usan los valores por defecto.
+ * @returns Una DecimationFilter que recibe viewport, zoom, featureIds, etc. y devuelve
+ *          los featureIds que deben renderizarse.
+ */
+export declare function createPixelPathDecimationFilter(config?: PixelPathFilterConfig): DecimationFilter;
+//# sourceMappingURL=index.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAGhB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAOjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,CAAC,EAAE,qBAAqB,GAC7B,gBAAgB,CAqJlB"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/index.js

@@ -0,0 +1,69 @@
+import k from "kdbush";
+import { PIXEL_PATH_DEFAULT_CONFIG as H } from "../constants.js";
+import { decimateByConcentrationGrid as z } from "./helpers/decimateByConcentrationGrid.js";
+import { decimateByPixelDistanceAlongPath as G } from "./helpers/decimateByPixelDistanceAlongPath.js";
+function j(M) {
+  const h = { ...H, ...M };
+  return (B) => {
+    const { featureIds: u, bounds: n, map: C, featuresWithCoords: D, cache: c, zoom: R } = B;
+    if (u.length === 0)
+      return [];
+    if (D.length === 0)
+      return [...u];
+    const s = D, f = h.viewportOffsetFactor ?? 1, S = (n.getNorth() - n.getSouth()) / 2, L = (n.getEast() - n.getWest()) / 2, I = (n.getWest() + n.getEast()) / 2 - L * f, x = (n.getSouth() + n.getNorth()) / 2 - S * f, P = (n.getWest() + n.getEast()) / 2 + L * f, w = (n.getSouth() + n.getNorth()) / 2 + S * f, T = (e, i) => e >= x && e <= w && i >= I && i <= P, A = () => {
+      const e = /* @__PURE__ */ new Map();
+      for (let t = 0; t < u.length; t++)
+        e.set(u[t], t);
+      const i = Array.from({ length: s.length }, (t, o) => o).sort(
+        (t, o) => (e.get(s[t].id) ?? -1) - (e.get(s[o].id) ?? -1)
+      ), m = new Map(
+        s.map((t) => [t.id, t])
+      ), a = [...s].sort((t, o) => t.lat !== o.lat ? t.lat - o.lat : t.lng !== o.lng ? t.lng - o.lng : String(t.id).localeCompare(String(o.id))), d = new k(a.length, 9);
+      return a.forEach((t) => d.add(t.lng, t.lat)), d.finish(), {
+        idToRouteIndex: e,
+        allIndicesInRouteOrder: i,
+        idToPoint: m,
+        spatialIndex: { index: d, points: a }
+      };
+    }, {
+      idToRouteIndex: _,
+      allIndicesInRouteOrder: l,
+      idToPoint: v,
+      spatialIndex: y
+    } = c ? c.get("pixelPathDecimation", A) : A(), N = h.minPixelDistance ?? 40, E = h.alwaysShowFirstAndLast ?? !0, F = () => G(
+      C,
+      l,
+      s,
+      N
+    ), O = c != null ? c.get(`pixelPathDecimation_decimated_zoom_${R}`, F) : F(), V = y.index.range(
+      I,
+      x,
+      P,
+      w
+    ), W = new Set(
+      V.map((e) => y.points[e].id)
+    );
+    let p = O.filter((e) => W.has(e));
+    if (E && l.length > 0) {
+      const e = s[l[0]], i = s[l[l.length - 1]], m = e.id, a = i.id, d = new Set(p), t = [], o = [];
+      T(e.lat, e.lng) && !d.has(m) && t.push(m), a !== m && T(i.lat, i.lng) && !d.has(a) && o.push(a), p = [...t, ...p, ...o];
+    }
+    let r = [...p].sort(
+      (e, i) => (_.get(e) ?? -1) - (_.get(i) ?? -1)
+    );
+    const g = h.maxMarkers;
+    return g != null && g > 0 && r.length > g && (r = z(
+      r,
+      v,
+      I,
+      x,
+      P,
+      w,
+      g,
+      E && r.length > 0 ? { firstId: r[0], lastId: r[r.length - 1] } : void 0
+    )), r;
+  };
+}
+export {
+  j as createPixelPathDecimationFilter
+};

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/types.d.ts

@@ -0,0 +1,42 @@
+export type { DecimationFilter, DecimationFilterParams, FeatureWithCoords, } from '../../../contexts/MapContext/types';
+/**
+ * Configuración para el filtro de decimación basado en distancia en píxeles a lo largo del path.
+ *
+ * Usado por `createPixelPathDecimationFilter` para reducir marcadores en capas con secuencias
+ * ordenadas de puntos (recorridos GPS, rutas). El filtro se recalcula en zoom/pan (con debounce);
+ * respeta la distancia mínima entre marcas consecutivas y opcionalmente aplica un tope máximo
+ * mediante grilla espacial.
+ */
+export interface PixelPathFilterConfig {
+    /**
+     * Si es false, el filtro no se aplica y se devuelven todos los featureIds sin filtrar.
+     * Por defecto true (filtrado activo).
+     */
+    enabled?: boolean;
+    /**
+     * Factor de expansión del viewport para el bbox de consulta espacial.
+     * 1 = solo área visible; 1.2 = 20% más en cada dirección (evita marcas que aparecen/desaparecen
+     * en el borde al hacer pan).
+     */
+    viewportOffsetFactor?: number;
+    /**
+     * Distancia mínima en píxeles entre marcas consecutivas a lo largo del path (orden featureIds).
+     * Puntos más cercanos se descartan para evitar saturación visual. Valores típicos: 40–100.
+     */
+    minPixelDistance?: number;
+    /**
+     * Si true, siempre incluye el primer y último punto del path aunque no cumplan minPixelDistance,
+     * para no cortar visualmente el inicio/fin del recorrido.
+     *
+     * Solo se añaden cuando están dentro del viewport visible (ampliado por viewportOffsetFactor).
+     * Si están fuera del área visible, no se renderizan.
+     */
+    alwaysShowFirstAndLast?: boolean;
+    /**
+     * Límite máximo de marcas a mostrar. Si tras la decimación por path y viewport hay más, se aplica
+     * decimación por concentración (grilla espacial: como máximo una marca por celda).
+     * Opcional; si no se define, no se aplica tope.
+     */
+    maxMarkers?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/createPixelPathDecimationFilter/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,oCAAoC,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Configuración para el filtrado de marcas basado en zoom y viewport (RBush)
+ */
+export interface ZoomBasedFilterConfig {
+    /**
+     * Nivel de zoom mínimo donde se muestran todas las marcas en viewport
+     * Por debajo de este zoom, se aplica el filtrado
+     */
+    minZoomForAllMarkers?: number;
+    /**
+     * Límite máximo de marcas a mostrar cuando el zoom está alejado
+     */
+    maxMarkersAtMinZoom?: number;
+    /**
+     * Si es true, usa muestreo espacial (grid) cuando hay más marcas que el límite
+     */
+    useSpatialSampling?: boolean;
+    /**
+     * Si es true, retorna información de la grilla para visualización (solo para debug)
+     */
+    showGridDebug?: boolean;
+    /**
+     * Factor de expansión del viewport para el bounding box (1 = solo visible, 1.2 = 20% más en cada lado)
+     */
+    viewportOffsetFactor?: number;
+    /**
+     * Milisegundos de debounce para moveend/zoomend (evita saturar el pintado en movimientos intensos)
+     */
+    debounceMs?: number;
+    /**
+     * Si es true, usa decimación por distancia (geokdbush): mínima distancia entre marcas según zoom.
+     * Más fluido que grilla: a mayor zoom menos distancia mínima = más marcas.
+     */
+    useDistanceDecimation?: boolean;
+    /**
+     * Distancia mínima entre marcas (m) cuando el zoom está bajo. A mayor zoom la distancia se reduce.
+     * Solo aplica si useDistanceDecimation es true.
+     */
+    minDistanceMetersAtLowZoom?: number;
+    /**
+     * Distancia mínima entre marcas (m) cuando el zoom está alto.
+     * Solo aplica si useDistanceDecimation es true.
+     */
+    minDistanceMetersAtHighZoom?: number;
+    /**
+     * Nivel de zoom considerado "bajo" para minDistanceMetersAtLowZoom.
+     */
+    lowZoomLevel?: number;
+    /**
+     * Nivel de zoom considerado "alto" para minDistanceMetersAtHighZoom.
+     */
+    highZoomLevel?: number;
+    /**
+     * Si es true, al decimar se distribuyen los puntos a lo largo de la distancia total del recorrido
+     * (orden de featureIds), no se toman solo los primeros. Evita que queden "pegados" al inicio.
+     */
+    distributeByPathDistance?: boolean;
+}
+/**
+ * Configuración transversal del hook useFilterDecimation.
+ * Afecta cómo se programa la recomputación ante zoom/pan, no a la lógica de decimación.
+ */
+export interface UseFilterDecimationConfig {
+    /**
+     * Debounce en ms antes de recalcular tras zoomend/moveend.
+     * Si hay zoom o movimiento continuo, se cancela el cálculo pendiente y se programa uno nuevo.
+     * 0 = sin debounce (ejecución inmediata). Por defecto 150.
+     */
+    debounceMs?: number;
+}
+/**
+ * Información de una celda de la grilla para visualización
+ */
+export interface GridCell {
+    bounds: {
+        north: number;
+        south: number;
+        east: number;
+        west: number;
+    };
+    featureCount: number;
+    selected: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;OAEG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC;;;OAGG;IACH,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;CACnB"}

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/useFilterDecimation.d.ts

@@ -0,0 +1,12 @@
+import { DecimationFilter } from '../../contexts/MapContext/types';
+import { UseFilterDecimationConfig } from './types';
+/**
+ * Hook que filtra featureIds según la función decimationFilter de la capa.
+ * Si decimationFilter está definida: la invoca con viewport, zoom, featureIds, etc.
+ * en cada zoom/pan y retorna los ids filtrados.
+ * Si no está definida: retorna todos los featureIds sin filtrar.
+ *
+ * config: configuración transversal (debounce en zoom/pan), no afecta la lógica de decimación.
+ */
+export declare function useFilterDecimation(featureIds: (string | number)[], layerId: string, decimationFilter?: DecimationFilter, config?: UseFilterDecimationConfig): (string | number)[];
+//# sourceMappingURL=useFilterDecimation.d.ts.map

package/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/useFilterDecimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFilterDecimation.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMap/hooks/useZoomBasedMarkerFilter/useFilterDecimation.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAKzD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAC/B,OAAO,EAAE,MAAM,EACf,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,MAAM,CAAC,EAAE,yBAAyB,GACjC,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAiIrB"}