@mint-ui/map 1.2.0-test.8 → 1.2.0

package/dist/components/mint-map/core/advanced/shared/helpers.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * 이벤트 유효성 검증 및 좌표 변환
+ *
+ * @param event 이벤트 파라미터
+ * @param context CanvasContext 인스턴스
+ * @param controller MintMapController 인스턴스
+ * @returns 유효한 화면 좌표 또는 null
+ */
+var validateEvent = function (event, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+context, controller) {
+  var _a;
+
+  if (context) return null;
+  if (!((_a = event === null || event === void 0 ? void 0 : event.param) === null || _a === void 0 ? void 0 : _a.position)) return null;
+
+  try {
+    return controller.positionToOffset(event.param.position);
+  } catch (error) {
+    console.error('[CanvasLayer] validateEvent error:', error);
+    return null;
+  }
+};
+/**
+ * Map의 values를 배열로 변환
+ *
+ * @template T Map 값의 타입
+ * @param map 변환할 Map
+ * @returns Map의 값 배열
+ */
+
+var mapValuesToArray = function (map) {
+  if (map.size === 0) return [];
+  return Array.from(map.values());
+};
+
+exports.mapValuesToArray = mapValuesToArray;
+exports.validateEvent = validateEvent;

package/dist/components/mint-map/core/advanced/shared/hooks.d.ts

@@ -0,0 +1,74 @@
+import { MutableRefObject } from 'react';
+import type { SpatialHashGrid } from './performance';
+import type { CanvasData } from './types';
+import type { BoundingBox } from './viewport';
+import type { Marker, MarkerOptions } from '../../../types';
+import type { MintMapController } from '../../MintMapController';
+/**
+ * 공통 이벤트 핸들러 의존성 인터페이스
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ *
+ * @remarks
+ * 지도 이벤트 핸들러 생성 시 필요한 모든 의존성을 포함합니다.
+ */
+export interface EventHandlerDeps<T> {
+    boundingBoxCacheRef: MutableRefObject<Map<string, BoundingBox>>;
+    accumTranslateRef: MutableRefObject<{
+        x: number;
+        y: number;
+    }>;
+    containerRef: MutableRefObject<HTMLDivElement | null>;
+    controller: MintMapController;
+    markerRef: MutableRefObject<Marker | undefined>;
+    clearCache: () => void;
+    options: Pick<MarkerOptions, 'anchor' | 'visible' | 'zIndex'>;
+    prevCenterOffsetRef: MutableRefObject<{
+        x: number;
+        y: number;
+    } | null>;
+    renderAllImmediate: () => void;
+}
+/**
+ * 지도 이벤트 핸들러 생성 함수
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param deps 이벤트 핸들러 생성에 필요한 의존성
+ * @returns 지도 이벤트 핸들러 객체
+ */
+export declare const createMapEventHandlers: <T>(deps: EventHandlerDeps<T>) => {
+    handleCenterChanged: () => void;
+    handleDragEnd: () => void;
+    handleDragStart: () => void;
+    handleIdle: () => void;
+    handleZoomEnd: () => void;
+    handleZoomStart: () => void;
+};
+/**
+ * 공간 인덱스 빌드 (빠른 Hit Test를 위한 자료구조)
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param data 공간 인덱스에 삽입할 데이터 배열
+ * @param spatialIndex Spatial Hash Grid 인스턴스
+ * @param computeBoundingBox 바운딩 박스 계산 함수
+ */
+export declare const buildSpatialIndex: <T>(data: CanvasData<T>[], spatialIndex: SpatialHashGrid<CanvasData<T>>, computeBoundingBox: (item: CanvasData<T>) => BoundingBox | null) => void;
+/**
+ * 선택 상태 동기화 (화면 밖 데이터도 선택 상태 유지)
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param data 최신 데이터 배열
+ * @param selectedIds 선택된 항목 ID Set
+ * @param selectedItemsMap 현재 선택된 항목 Map
+ * @returns 업데이트된 선택된 항목 Map
+ */
+export declare const syncSelectedItems: <T>(data: CanvasData<T>[], selectedIds: Set<string>, selectedItemsMap: Map<string, CanvasData<T>>) => Map<string, CanvasData<T>>;
+/**
+ * 외부 selectedItems를 내부 상태로 동기화
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param externalSelectedItems 외부에서 전달된 선택된 항목 배열
+ * @param selectedIdsRef 선택된 ID Set ref
+ * @param selectedItemsMapRef 선택된 항목 Map ref
+ */
+export declare const syncExternalSelectedItems: <T>(externalSelectedItems: CanvasData<T>[] | undefined, selectedIdsRef: MutableRefObject<Set<string>>, selectedItemsMapRef: MutableRefObject<Map<string, CanvasData<T>>>) => void;

package/dist/components/mint-map/core/advanced/shared/hooks.js

@@ -0,0 +1,196 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+
+/**
+ * 지도 이벤트 핸들러 생성 함수
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param deps 이벤트 핸들러 생성에 필요한 의존성
+ * @returns 지도 이벤트 핸들러 객체
+ */
+
+/* eslint-disable no-restricted-syntax */
+
+var createMapEventHandlers = function (deps) {
+  var accumTranslateRef = deps.accumTranslateRef,
+      boundingBoxCacheRef = deps.boundingBoxCacheRef,
+      clearCache = deps.clearCache,
+      containerRef = deps.containerRef,
+      controller = deps.controller,
+      markerRef = deps.markerRef,
+      options = deps.options,
+      prevCenterOffsetRef = deps.prevCenterOffsetRef,
+      renderAllImmediate = deps.renderAllImmediate; // 지도 이동/줌 완료 시 처리 (캐시 초기화 및 렌더링)
+
+  var handleIdle = function () {
+    prevCenterOffsetRef.current = null;
+    accumTranslateRef.current = {
+      x: 0,
+      y: 0
+    }; // 캐시 정리 (지도 이동/줌으로 좌표 변환 결과가 바뀜)
+
+    clearCache();
+    boundingBoxCacheRef.current.clear(); // 마커 위치 업데이트
+
+    var bounds = controller.getCurrBounds();
+
+    var markerOptions = tslib.__assign(tslib.__assign({}, options), {
+      position: bounds.nw
+    });
+
+    if (markerRef.current) {
+      controller.updateMarker(markerRef.current, markerOptions);
+    } // transform 제거 전에 새 데이터로 즉시 렌더링 (transform 제거 시 잠깐 빈 화면이 보이는 것 방지)
+
+
+    if (containerRef.current) {
+      containerRef.current.style.transform = '';
+      containerRef.current.style.visibility = '';
+    } // 새 위치에서 렌더링 (캐시는 이미 초기화됨)
+
+
+    renderAllImmediate();
+  }; // 줌 시작 시 처리 (일시적으로 숨김)
+
+
+  var handleZoomStart = function () {
+    if (!containerRef.current) return;
+    containerRef.current.style.visibility = 'hidden';
+  }; // 줌 종료 시 처리 (다시 표시)
+
+
+  var handleZoomEnd = function () {
+    if (!containerRef.current) return;
+    containerRef.current.style.visibility = '';
+  }; // 지도 중심 변경 시 처리 (transform으로 이동 추적, 캐시 유지)
+
+
+  var handleCenterChanged = function () {
+    var center = controller.getCurrBounds().getCenter();
+    var curr = controller.positionToOffset(center);
+    var prev = prevCenterOffsetRef.current; // 첫 번째 호출 시 이전 위치 저장만 하고 종료
+
+    if (!prev) {
+      prevCenterOffsetRef.current = {
+        x: curr.x,
+        y: curr.y
+      };
+      return;
+    } // 이전 위치와 현재 위치의 차이 계산 (이동 거리)
+
+
+    var dx = prev.x - curr.x;
+    var dy = prev.y - curr.y; // 누적 이동 거리 저장 (transform으로 화면만 이동, 캐시는 유지하여 성능 최적화)
+
+    accumTranslateRef.current = {
+      x: accumTranslateRef.current.x + dx,
+      y: accumTranslateRef.current.y + dy
+    };
+    prevCenterOffsetRef.current = {
+      x: curr.x,
+      y: curr.y
+    }; // CSS transform으로 컨테이너 이동 (캐시된 좌표는 그대로 유지)
+
+    if (containerRef.current) {
+      containerRef.current.style.transform = "translate(".concat(accumTranslateRef.current.x, "px, ").concat(accumTranslateRef.current.y, "px)");
+    }
+  };
+
+  var handleDragStart = function () {// 커서는 각 컴포넌트에서 처리
+  };
+
+  var handleDragEnd = function () {// 커서는 각 컴포넌트에서 처리
+  };
+
+  return {
+    handleCenterChanged: handleCenterChanged,
+    handleDragEnd: handleDragEnd,
+    handleDragStart: handleDragStart,
+    handleIdle: handleIdle,
+    handleZoomEnd: handleZoomEnd,
+    handleZoomStart: handleZoomStart
+  };
+};
+/**
+ * 공간 인덱스 빌드 (빠른 Hit Test를 위한 자료구조)
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param data 공간 인덱스에 삽입할 데이터 배열
+ * @param spatialIndex Spatial Hash Grid 인스턴스
+ * @param computeBoundingBox 바운딩 박스 계산 함수
+ */
+
+var buildSpatialIndex = function (data, spatialIndex, computeBoundingBox) {
+  spatialIndex.clear();
+
+  for (var _i = 0, data_1 = data; _i < data_1.length; _i++) {
+    var item = data_1[_i];
+    var bbox = computeBoundingBox(item);
+
+    if (bbox) {
+      spatialIndex.insert(item, bbox.minX, bbox.minY, bbox.maxX, bbox.maxY);
+    }
+  }
+};
+/**
+ * 선택 상태 동기화 (화면 밖 데이터도 선택 상태 유지)
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param data 최신 데이터 배열
+ * @param selectedIds 선택된 항목 ID Set
+ * @param selectedItemsMap 현재 선택된 항목 Map
+ * @returns 업데이트된 선택된 항목 Map
+ */
+
+var syncSelectedItems = function (data, selectedIds, selectedItemsMap) {
+  var dataMap = new Map(data.map(function (m) {
+    return [m.id, m];
+  }));
+  var newSelectedItemsMap = new Map();
+  selectedIds.forEach(function (id) {
+    // 현재 data에 있으면 최신 데이터 사용
+    var currentItem = dataMap.get(id);
+
+    if (currentItem) {
+      newSelectedItemsMap.set(id, currentItem);
+    } else {
+      // 화면 밖이면 기존 데이터 유지
+      var prevItem = selectedItemsMap.get(id);
+
+      if (prevItem) {
+        newSelectedItemsMap.set(id, prevItem);
+      }
+    }
+  });
+  return newSelectedItemsMap;
+};
+/**
+ * 외부 selectedItems를 내부 상태로 동기화
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param externalSelectedItems 외부에서 전달된 선택된 항목 배열
+ * @param selectedIdsRef 선택된 ID Set ref
+ * @param selectedItemsMapRef 선택된 항목 Map ref
+ */
+
+var syncExternalSelectedItems = function (externalSelectedItems, selectedIdsRef, selectedItemsMapRef) {
+  if (externalSelectedItems === undefined) return;
+  var newSelectedIds = new Set();
+  var newSelectedItemsMap = new Map();
+  externalSelectedItems.forEach(function (item) {
+    newSelectedIds.add(item.id);
+    newSelectedItemsMap.set(item.id, item);
+  }); // eslint-disable-next-line no-param-reassign
+
+  selectedIdsRef.current = newSelectedIds; // eslint-disable-next-line no-param-reassign
+
+  selectedItemsMapRef.current = newSelectedItemsMap;
+};
+
+exports.buildSpatialIndex = buildSpatialIndex;
+exports.createMapEventHandlers = createMapEventHandlers;
+exports.syncExternalSelectedItems = syncExternalSelectedItems;
+exports.syncSelectedItems = syncSelectedItems;

package/dist/components/mint-map/core/advanced/{woongCanvas/shared → shared}/index.d.ts

@@ -1,4 +1,7 @@
-export * from './types';
-export * from './utils';
 export * from './context';
+export * from './helpers';
+export * from './hooks';
 export * from './performance';
+export * from './types';
+export * from './utils';
+export * from './viewport';

package/dist/components/mint-map/core/advanced/shared/performance.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 공간 인덱스 그리드 셀 크기 (픽셀 단위)
+ *
+ * @default 200
+ *
+ * @remarks
+ * 셀 크기는 평균 마커 크기의 1.5~2배가 적절합니다.
+ * - 마커가 50px 이하: 50px 권장
+ * - 마커가 60-80px: 100px 권장
+ * - 마커가 100px 이상: 150-200px 권장 (현재 설정)
+ *
+ * 셀 크기가 너무 작으면:
+ * - 한 마커가 여러 셀에 등록되어 메모리 사용량 증가
+ * - 인덱스 빌드 비용 증가
+ *
+ * 셀 크기가 너무 크면:
+ * - 한 셀에 많은 마커가 들어가서 Hit Test 시 후보 항목이 많아짐
+ * - Hit Test 성능 저하
+ */
+export declare const SPATIAL_GRID_CELL_SIZE = 200;
+/**
+ * 뷰포트 컬링 여유 공간 (픽셀 단위)
+ *
+ * @default 100
+ */
+export declare const DEFAULT_CULLING_MARGIN = 100;
+/**
+ * Queue 캐시 최대 항목 수
+ *
+ * @default 30000
+ */
+export declare const DEFAULT_MAX_CACHE_SIZE = 30000;
+/**
+ * Queue Cache (FIFO - First In First Out)
+ *
+ * 좌표 변환 결과를 캐싱하기 위한 캐시 구현
+ * FIFO 방식으로 가장 먼저 저장된 항목부터 제거합니다.
+ *
+ * @template K 캐시 키 타입
+ * @template V 캐시 값 타입
+ */
+export declare class QueueCache<K, V> {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    clear(): void;
+    size(): number;
+    has(key: K): boolean;
+    getAllKeys(): K[];
+    getAllEntries(): Array<[K, V]>;
+}
+/**
+ * Spatial Hash Grid (공간 해시 그리드)
+ *
+ * 빠른 Hit Test를 위한 그리드 기반 공간 인덱싱 자료구조
+ *
+ * @template T 인덱싱할 항목 타입
+ */
+export declare class SpatialHashGrid<T> {
+    private cellSize;
+    private grid;
+    private itemToCells;
+    constructor(cellSize?: number);
+    private getCellKey;
+    private getCellsForBounds;
+    insert(item: T, minX: number, minY: number, maxX: number, maxY: number): void;
+    remove(item: T): void;
+    update(item: T, minX: number, minY: number, maxX: number, maxY: number): void;
+    queryPoint(x: number, y: number): T[];
+    queryBounds(minX: number, minY: number, maxX: number, maxY: number): T[];
+    has(item: T): boolean;
+    clear(): void;
+    stats(): {
+        avgItemsPerCell: number;
+        totalCells: number;
+        totalItems: number;
+    };
+    getAllCells(): Map<string, T[]>;
+    getCellItems(cellKey: string): T[];
+}

package/dist/components/mint-map/core/advanced/shared/performance.js

@@ -0,0 +1,288 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable max-classes-per-file */
+
+/* eslint-disable no-restricted-syntax */
+
+/**
+ * 공간 인덱스 그리드 셀 크기 (픽셀 단위)
+ *
+ * @default 200
+ *
+ * @remarks
+ * 셀 크기는 평균 마커 크기의 1.5~2배가 적절합니다.
+ * - 마커가 50px 이하: 50px 권장
+ * - 마커가 60-80px: 100px 권장
+ * - 마커가 100px 이상: 150-200px 권장 (현재 설정)
+ *
+ * 셀 크기가 너무 작으면:
+ * - 한 마커가 여러 셀에 등록되어 메모리 사용량 증가
+ * - 인덱스 빌드 비용 증가
+ *
+ * 셀 크기가 너무 크면:
+ * - 한 셀에 많은 마커가 들어가서 Hit Test 시 후보 항목이 많아짐
+ * - Hit Test 성능 저하
+ */
+var SPATIAL_GRID_CELL_SIZE = 200;
+/**
+ * 뷰포트 컬링 여유 공간 (픽셀 단위)
+ *
+ * @default 100
+ */
+
+var DEFAULT_CULLING_MARGIN = 100;
+/**
+ * Queue 캐시 최대 항목 수
+ *
+ * @default 30000
+ */
+
+var DEFAULT_MAX_CACHE_SIZE = 30000;
+/**
+ * Queue Cache (FIFO - First In First Out)
+ *
+ * 좌표 변환 결과를 캐싱하기 위한 캐시 구현
+ * FIFO 방식으로 가장 먼저 저장된 항목부터 제거합니다.
+ *
+ * @template K 캐시 키 타입
+ * @template V 캐시 값 타입
+ */
+
+var QueueCache =
+/** @class */
+function () {
+  function QueueCache(maxSize) {
+    if (maxSize === void 0) {
+      maxSize = 10000;
+    }
+
+    this.cache = new Map();
+    this.maxSize = maxSize;
+  } // 캐시에서 값 조회
+
+
+  QueueCache.prototype.get = function (key) {
+    return this.cache.get(key);
+  }; // 캐시에 값 저장 (FIFO eviction)
+
+
+  QueueCache.prototype.set = function (key, value) {
+    var exists = this.cache.has(key);
+
+    if (exists) {
+      this.cache.set(key, value);
+      return;
+    }
+
+    if (this.cache.size >= this.maxSize) {
+      var firstKey = this.cache.keys().next().value;
+
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+
+    this.cache.set(key, value);
+  }; // 캐시 초기화
+
+
+  QueueCache.prototype.clear = function () {
+    this.cache.clear();
+  }; // 캐시 크기 반환
+
+
+  QueueCache.prototype.size = function () {
+    return this.cache.size;
+  }; // 키 존재 여부 확인
+
+
+  QueueCache.prototype.has = function (key) {
+    return this.cache.has(key);
+  }; // 모든 캐시 키 반환 (디버깅/모니터링용)
+
+
+  QueueCache.prototype.getAllKeys = function () {
+    return Array.from(this.cache.keys());
+  }; // 모든 캐시 항목 반환 (디버깅/모니터링용)
+
+
+  QueueCache.prototype.getAllEntries = function () {
+    return Array.from(this.cache.entries());
+  };
+
+  return QueueCache;
+}();
+/**
+ * Spatial Hash Grid (공간 해시 그리드)
+ *
+ * 빠른 Hit Test를 위한 그리드 기반 공간 인덱싱 자료구조
+ *
+ * @template T 인덱싱할 항목 타입
+ */
+
+var SpatialHashGrid =
+/** @class */
+function () {
+  function SpatialHashGrid(cellSize) {
+    if (cellSize === void 0) {
+      cellSize = SPATIAL_GRID_CELL_SIZE;
+    }
+
+    this.cellSize = cellSize;
+    this.grid = new Map();
+    this.itemToCells = new Map();
+  } // 셀 키 생성 (x, y 좌표 → 그리드 셀 ID)
+
+
+  SpatialHashGrid.prototype.getCellKey = function (x, y) {
+    // 좌표를 셀 크기로 나눈 몫으로 셀 인덱스 계산
+    var cellX = Math.floor(x / this.cellSize);
+    var cellY = Math.floor(y / this.cellSize);
+    return "".concat(cellX, ",").concat(cellY);
+  }; // 바운딩 박스가 걸치는 모든 셀 키 배열 반환
+
+
+  SpatialHashGrid.prototype.getCellsForBounds = function (minX, minY, maxX, maxY) {
+    var cells = []; // 바운딩 박스가 걸치는 셀 범위 계산
+
+    var startCellX = Math.floor(minX / this.cellSize);
+    var startCellY = Math.floor(minY / this.cellSize);
+    var endCellX = Math.floor(maxX / this.cellSize);
+    var endCellY = Math.floor(maxY / this.cellSize); // 바운딩 박스가 걸치는 모든 셀을 배열에 추가
+
+    for (var x = startCellX; x <= endCellX; x++) {
+      for (var y = startCellY; y <= endCellY; y++) {
+        cells.push("".concat(x, ",").concat(y));
+      }
+    }
+
+    return cells;
+  }; // 항목 추가 (바운딩 박스 기반, 중복 삽입 방지)
+
+
+  SpatialHashGrid.prototype.insert = function (item, minX, minY, maxX, maxY) {
+    // 기존 항목 제거 (중복 삽입 방지: 같은 항목을 여러 번 insert 해도 안전)
+    this.remove(item); // 바운딩 박스가 걸치는 모든 셀에 항목 등록
+
+    var cells = this.getCellsForBounds(minX, minY, maxX, maxY);
+    this.itemToCells.set(item, cells); // 항목과 셀의 매핑 저장 (제거 시 필요)
+
+    for (var _i = 0, cells_1 = cells; _i < cells_1.length; _i++) {
+      var cell = cells_1[_i];
+
+      if (!this.grid.has(cell)) {
+        this.grid.set(cell, []);
+      }
+
+      this.grid.get(cell).push(item);
+    }
+  }; // 항목 제거 (모든 셀에서 참조 제거)
+
+
+  SpatialHashGrid.prototype.remove = function (item) {
+    var prevCells = this.itemToCells.get(item);
+    if (!prevCells) return; // 항목이 등록된 모든 셀에서 참조 제거 (메모리 누수 방지)
+
+    for (var _i = 0, prevCells_1 = prevCells; _i < prevCells_1.length; _i++) {
+      var cell = prevCells_1[_i];
+      var cellItems = this.grid.get(cell);
+
+      if (cellItems) {
+        var index = cellItems.indexOf(item);
+
+        if (index !== -1) {
+          cellItems.splice(index, 1);
+        } // 빈 셀 정리 (메모리 효율: 사용하지 않는 셀 제거)
+
+
+        if (cellItems.length === 0) {
+          this.grid.delete(cell);
+        }
+      }
+    } // 항목과 셀의 매핑 제거
+
+
+    this.itemToCells.delete(item);
+  }; // 항목 위치 업데이트 (remove + insert)
+
+
+  SpatialHashGrid.prototype.update = function (item, minX, minY, maxX, maxY) {
+    this.insert(item, minX, minY, maxX, maxY);
+  }; // 점 주변의 항목 조회 (Hit Test용)
+
+
+  SpatialHashGrid.prototype.queryPoint = function (x, y) {
+    // 클릭 위치가 속한 셀의 모든 항목 조회 (O(1) 수준의 빠른 조회)
+    var cellKey = this.getCellKey(x, y);
+    var items = this.grid.get(cellKey); // 빈 배열 재사용 (메모리 할당 최소화)
+
+    return items || [];
+  }; // 영역 내 항목 조회 (Viewport Culling용)
+
+
+  SpatialHashGrid.prototype.queryBounds = function (minX, minY, maxX, maxY) {
+    // 영역이 걸치는 모든 셀 찾기
+    var cells = this.getCellsForBounds(minX, minY, maxX, maxY);
+    var results = new Set(); // 중복 제거를 위해 Set 사용
+    // 각 셀의 모든 항목을 결과에 추가
+
+    for (var _i = 0, cells_2 = cells; _i < cells_2.length; _i++) {
+      var cell = cells_2[_i];
+      var items = this.grid.get(cell);
+
+      if (items) {
+        for (var _a = 0, items_1 = items; _a < items_1.length; _a++) {
+          var item = items_1[_a];
+          results.add(item); // Set이므로 중복 자동 제거
+        }
+      }
+    }
+
+    return Array.from(results);
+  }; // 항목 존재 여부 확인
+
+
+  SpatialHashGrid.prototype.has = function (item) {
+    return this.itemToCells.has(item);
+  }; // 전체 초기화
+
+
+  SpatialHashGrid.prototype.clear = function () {
+    this.grid.clear();
+    this.itemToCells.clear();
+  }; // 통계 정보 반환
+
+
+  SpatialHashGrid.prototype.stats = function () {
+    var totalCellItems = 0;
+    this.grid.forEach(function (items) {
+      totalCellItems += items.length;
+    });
+    return {
+      // 고유 항목 수 (정확)
+      avgItemsPerCell: this.grid.size > 0 ? totalCellItems / this.grid.size : 0,
+      totalCells: this.grid.size,
+      totalItems: this.itemToCells.size
+    };
+  }; // 모든 그리드 셀 데이터 반환 (디버깅/모니터링용)
+
+
+  SpatialHashGrid.prototype.getAllCells = function () {
+    return new Map(this.grid);
+  }; // 특정 셀의 항목 조회
+
+
+  SpatialHashGrid.prototype.getCellItems = function (cellKey) {
+    return this.grid.get(cellKey) || [];
+  };
+
+  return SpatialHashGrid;
+}();
+
+exports.DEFAULT_CULLING_MARGIN = DEFAULT_CULLING_MARGIN;
+exports.DEFAULT_MAX_CACHE_SIZE = DEFAULT_MAX_CACHE_SIZE;
+exports.QueueCache = QueueCache;
+exports.SPATIAL_GRID_CELL_SIZE = SPATIAL_GRID_CELL_SIZE;
+exports.SpatialHashGrid = SpatialHashGrid;