@mint-ui/map 1.2.0-test.35 → 1.2.0-test.36

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

@@ -2,80 +2,33 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-// ============================================================================
-// 성능 최적화 상수 (30,000개 마커/폴리곤 기준 최적화)
-// ============================================================================
-
 /**
- * 공간 인덱스 그리드 셀 크기 (px)
- *
- * 최적값 계산:
- * - 목표: 클릭 시 셀당 10~30개 항목만 체크 (빠른 Hit Test)
- * - 화면 크기: 1920×1080 기준
- * - 30,000개 항목 → 50px 셀 크기 = 약 800개 셀 = 셀당 ~37개
- *
- * 성능 비교 (30,000개 기준):
- * - 200px: 셀당 ~577개 → Hit Test O(577) ❌ 느림
- * - 50px:  셀당 ~37개  → Hit Test O(37)  ✅ 15배 빠름!
+ * 공간 인덱스 그리드 셀 크기 (픽셀 단위)
  *
- * 트레이드오프:
- * - 작을수록: Hit Test 빠름, 메모리 사용량 증가
- * - 클수록: 메모리 효율적, Hit Test 느림
+ * @default 50
  */
 var SPATIAL_GRID_CELL_SIZE = 50;
 /**
- * 뷰포트 컬링 여유 공간 (px)
+ * 뷰포트 컬링 여유 공간 (픽셀 단위)
  *
- * 화면 밖 100px까지 렌더링하여 스크롤 시 부드러운 전환
- * 30,000개 중 실제 렌더링: 화면에 보이는 1,000~3,000개만
+ * @default 100
  */
 
 var DEFAULT_CULLING_MARGIN = 100;
 /**
  * LRU 캐시 최대 항목 수
  *
- * 좌표 변환 결과 캐싱 (positionToOffset 연산 비용 절약)
- *
- * 최적값 계산:
- * - 전체 항목: 30,000개
- * - 캐시 크기: 30,000개 → 100% 히트율 (메모리: ~2.4MB)
- *
- * 메모리 사용량 (항목당 ~80 bytes):
- * - 10,000개: ~800KB  → 캐시 히트율 33% ❌
- * - 30,000개: ~2.4MB  → 캐시 히트율 100% ✅
- *
- * zoom/pan 시 어차피 clear() 호출되므로 메모리 누적 없음
+ * @default 30000
  */
 
 var DEFAULT_MAX_CACHE_SIZE = 30000;
 /**
- * LRU (Least Recently Used) Cache
+ * LRU Cache (Least Recently Used)
  *
- * 메모리 제한을 위한 캐시 구현입니다. WoongCanvas 컴포넌트에서 좌표 변환 결과를 캐싱하는데 사용됩니다.
+ * 좌표 변환 결과를 캐싱하기 위한 캐시 구현
  *
  * @template K 캐시 키 타입
  * @template V 캐시 값 타입
- *
- * @remarks
- * **개선 사항**:
- * 1. get() 성능 향상: 접근 빈도 추적 없이 단순 조회만 수행 (delete+set 제거)
- * 2. set() 버그 수정: 기존 키 업데이트 시 maxSize 체크 로직 개선
- * 3. 메모리 효율: 단순 FIFO 캐시로 동작하여 오버헤드 최소화
- *
- * **트레이드오프**:
- * - 장점: 읽기 성능 대폭 향상 (10,000번 get → 이전보다 2배 빠름)
- * - 단점: 접근 빈도가 아닌 삽입 순서 기반 eviction (FIFO)
- *
- * WoongCanvasMarker 사용 사례에 최적:
- * - 좌표 변환 결과는 zoom/pan 시 어차피 전체 초기화
- * - 접근 빈도 추적보다 빠른 조회가 더 중요
- *
- * @example
- * ```typescript
- * const cache = new LRUCache<string, Offset>(30000);
- * cache.set(item.id, offset);
- * const cached = cache.get(item.id);
- * ```
  */
 
 var LRUCache =
@@ -88,63 +41,43 @@ function () {
 
     this.cache = new Map();
     this.maxSize = maxSize;
-  }
-  /**
-   * 캐시에서 값 조회
-   *
-   * @param key 조회할 키
-   * @returns 캐시된 값 또는 undefined (캐시 미스 시)
-   *
-   * @remarks
-   * - 성능: O(1) 해시 조회
-   * - 최적화: delete+set 제거로 읽기 성능 대폭 향상
-   */
+  } // 캐시에서 값 조회
 
 
   LRUCache.prototype.get = function (key) {
     return this.cache.get(key);
-  };
-  /**
-   * 캐시에 값 저장
-   *
-   * @param key 저장할 키
-   * @param value 저장할 값
-   *
-   * @remarks
-   * - 기존 키 업데이트: 단순 덮어쓰기 (크기 변화 없음)
-   * - 신규 키 추가: 크기 체크 후 필요시 가장 오래된 항목 제거 (FIFO)
-   * - 성능: O(1) 평균 시간복잡도
-   */
+  }; // 캐시에 값 저장 (FIFO eviction)
 
 
   LRUCache.prototype.set = function (key, value) {
     var exists = this.cache.has(key);
 
     if (exists) {
-      // 기존 항목 업데이트: 단순 덮어쓰기 (크기 변화 없음)
       this.cache.set(key, value);
-    } else {
-      // 신규 항목 추가: 크기 체크 필요
-      if (this.cache.size >= this.maxSize) {
-        // 가장 오래된 항목 제거 (Map의 첫 번째 항목)
-        var firstKey = this.cache.keys().next().value;
-
-        if (firstKey !== undefined) {
-          this.cache.delete(firstKey);
-        }
-      }
+      return;
+    }
 
-      this.cache.set(key, value);
+    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);
+  }; // 캐시 초기화
+
 
   LRUCache.prototype.clear = function () {
     this.cache.clear();
-  };
+  }; // 캐시 크기 반환
+
 
   LRUCache.prototype.size = function () {
     return this.cache.size;
-  };
+  }; // 키 존재 여부 확인
+
 
   LRUCache.prototype.has = function (key) {
     return this.cache.has(key);
@@ -154,16 +87,10 @@ function () {
 }();
 /**
  * Spatial Hash Grid (공간 해시 그리드)
- * 공간 인덱싱을 위한 그리드 기반 자료구조 (개선 버전)
  *
- * 개선 사항:
- * 1. 중복 삽입 방지: 같은 항목을 여러 번 insert 해도 안전
- * 2. 메모리 누수 방지: 기존 항목 자동 제거
- * 3. 성능 최적화: 불필요한 배열 생성 최소화
+ * 빠른 Hit Test를 위한 그리드 기반 공간 인덱싱 자료구조
  *
- * 사용 사례:
- * - 빠른 Hit Test (마우스 클릭 시 어떤 마커/폴리곤인지 찾기)
- * - 30,000개 항목 → 클릭 위치 주변 ~10개만 체크 (3,000배 빠름)
+ * @template T 인덱싱할 항목 타입
  */
 
 var SpatialHashGrid =
@@ -177,28 +104,24 @@ function () {
     this.cellSize = cellSize;
     this.grid = new Map();
     this.itemToCells = new Map();
-  }
-  /**
-   * 셀 키 생성 (x, y 좌표 → 그리드 셀 ID)
-   */
+  } // 셀 키 생성 (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 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);
+    var endCellY = Math.floor(maxY / this.cellSize); // 바운딩 박스가 걸치는 모든 셀을 배열에 추가
 
     for (var x = startCellX; x <= endCellX; x++) {
       for (var y = startCellY; y <= endCellY; y++) {
@@ -207,31 +130,15 @@ function () {
     }
 
     return cells;
-  };
-  /**
-   * 항목 추가 (바운딩 박스 기반)
-   *
-   * 항목을 공간 인덱스에 추가합니다. 바운딩 박스가 걸치는 모든 셀에 삽입됩니다.
-   *
-   * @param item 추가할 항목
-   * @param minX 바운딩 박스 최소 X 좌표
-   * @param minY 바운딩 박스 최소 Y 좌표
-   * @param maxX 바운딩 박스 최대 X 좌표
-   * @param maxY 바운딩 박스 최대 Y 좌표
-   *
-   * @remarks
-   * - 중복 삽입 방지: 기존 항목이 있으면 먼저 제거 후 재삽입
-   * - 메모리 누수 방지: 이전 셀 참조 완전 제거
-   * - 성능: O(1) 평균 시간복잡도
-   */
+  }; // 항목 추가 (바운딩 박스 기반, 중복 삽입 방지)
 
 
   SpatialHashGrid.prototype.insert = function (item, minX, minY, maxX, maxY) {
-    // 1. 기존 항목 제거 (중복 방지)
-    this.remove(item); // 2. 새 위치에 삽입
+    // 기존 항목 제거 (중복 삽입 방지: 같은 항목을 여러 번 insert 해도 안전)
+    this.remove(item); // 바운딩 박스가 걸치는 모든 셀에 항목 등록
 
     var cells = this.getCellsForBounds(minX, minY, maxX, maxY);
-    this.itemToCells.set(item, cells);
+    this.itemToCells.set(item, cells); // 항목과 셀의 매핑 저장 (제거 시 필요)
 
     for (var _i = 0, cells_1 = cells; _i < cells_1.length; _i++) {
       var cell = cells_1[_i];
@@ -242,24 +149,12 @@ function () {
 
       this.grid.get(cell).push(item);
     }
-  };
-  /**
-   * 항목 제거
-   *
-   * 공간 인덱스에서 항목을 제거합니다.
-   *
-   * @param item 제거할 항목
-   *
-   * @remarks
-   * - 메모리 누수 방지: 모든 셀에서 참조 완전 제거
-   * - 빈 셀 정리: 항목이 없어진 셀은 자동으로 정리됨
-   * - 성능: O(셀 개수), 보통 O(1)
-   */
+  }; // 항목 제거 (모든 셀에서 참조 제거)
 
 
   SpatialHashGrid.prototype.remove = function (item) {
     var prevCells = this.itemToCells.get(item);
-    if (!prevCells) return; // 각 셀에서 항목 제거
+    if (!prevCells) return; // 항목이 등록된 모든 셀에서 참조 제거 (메모리 누수 방지)
 
     for (var _i = 0, prevCells_1 = prevCells; _i < prevCells_1.length; _i++) {
       var cell = prevCells_1[_i];
@@ -270,86 +165,39 @@ function () {
 
         if (index !== -1) {
           cellItems.splice(index, 1);
-        } // 빈 셀 정리 (메모리 효율)
+        } // 빈 셀 정리 (메모리 효율: 사용하지 않는 셀 제거)
 
 
         if (cellItems.length === 0) {
           this.grid.delete(cell);
         }
       }
-    }
+    } // 항목과 셀의 매핑 제거
+
 
     this.itemToCells.delete(item);
-  };
-  /**
-   * 항목 위치 업데이트
-   *
-   * 항목의 위치를 업데이트합니다. remove + insert의 편의 함수입니다.
-   *
-   * @param item 업데이트할 항목
-   * @param minX 새로운 바운딩 박스 최소 X 좌표
-   * @param minY 새로운 바운딩 박스 최소 Y 좌표
-   * @param maxX 새로운 바운딩 박스 최대 X 좌표
-   * @param maxY 새로운 바운딩 박스 최대 Y 좌표
-   */
+  }; // 항목 위치 업데이트 (remove + insert)
 
 
   SpatialHashGrid.prototype.update = function (item, minX, minY, maxX, maxY) {
     this.insert(item, minX, minY, maxX, maxY);
-  };
-  /**
-   * 점 주변의 항목 조회 (1개 셀만)
-   *
-   * 특정 좌표가 속한 셀의 모든 항목을 반환합니다.
-   *
-   * @param x 조회할 X 좌표
-   * @param y 조회할 Y 좌표
-   * @returns 해당 셀의 항목 배열 (없으면 빈 배열)
-   *
-   * @remarks
-   * - 성능: O(해당 셀의 항목 수) - 보통 ~10개 (30,000개 전체를 체크하지 않음)
-   * - Hit Test에 최적화된 메서드
-   * - 빈 배열 재사용으로 메모리 할당 최소화
-   *
-   * @example
-   * ```typescript
-   * const candidates = grid.queryPoint(mouseX, mouseY);
-   * for (const item of candidates) {
-   *   if (isPointInItem(item, mouseX, mouseY)) {
-   *     return item;
-   *   }
-   * }
-   * ```
-   */
+  }; // 점 주변의 항목 조회 (Hit Test용)
 
 
   SpatialHashGrid.prototype.queryPoint = function (x, y) {
+    // 클릭 위치가 속한 셀의 모든 항목 조회 (O(1) 수준의 빠른 조회)
     var cellKey = this.getCellKey(x, y);
     var items = this.grid.get(cellKey); // 빈 배열 재사용 (메모리 할당 최소화)
 
     return items || [];
-  };
-  /**
-   * 영역 내 항목 조회
-   *
-   * 특정 영역(바운딩 박스)과 교차하는 모든 항목을 반환합니다.
-   *
-   * @param minX 영역 최소 X 좌표
-   * @param minY 영역 최소 Y 좌표
-   * @param maxX 영역 최대 X 좌표
-   * @param maxY 영역 최대 Y 좌표
-   * @returns 영역과 교차하는 항목 배열 (중복 제거됨)
-   *
-   * @remarks
-   * - 성능: O(셀 개수 × 셀당 평균 항목 수)
-   * - Set으로 중복 제거 보장 (항목이 여러 셀에 걸쳐 있어도 한 번만 반환)
-   * - Viewport Culling에 유용
-   */
+  }; // 영역 내 항목 조회 (Viewport Culling용)
 
 
   SpatialHashGrid.prototype.queryBounds = function (minX, minY, maxX, maxY) {
+    // 영역이 걸치는 모든 셀 찾기
     var cells = this.getCellsForBounds(minX, minY, maxX, maxY);
-    var results = new Set();
+    var results = new Set(); // 중복 제거를 위해 Set 사용
+    // 각 셀의 모든 항목을 결과에 추가
 
     for (var _i = 0, cells_2 = cells; _i < cells_2.length; _i++) {
       var cell = cells_2[_i];
@@ -358,48 +206,24 @@ function () {
       if (items) {
         for (var _a = 0, items_1 = items; _a < items_1.length; _a++) {
           var item = items_1[_a];
-          results.add(item);
+          results.add(item); // Set이므로 중복 자동 제거
         }
       }
     }
 
     return Array.from(results);
-  };
-  /**
-   * 항목 존재 여부 확인
-   *
-   * @param item 확인할 항목
-   * @returns 항목이 인덱스에 있으면 true, 아니면 false
-   *
-   * @remarks
-   * - 성능: O(1) 해시 조회
-   */
+  }; // 항목 존재 여부 확인
 
 
   SpatialHashGrid.prototype.has = function (item) {
     return this.itemToCells.has(item);
-  };
-  /**
-   * 전체 초기화
-   */
+  }; // 전체 초기화
 
 
   SpatialHashGrid.prototype.clear = function () {
     this.grid.clear();
     this.itemToCells.clear();
-  };
-  /**
-   * 통계 정보
-   *
-   * 공간 인덱스의 현재 상태를 반환합니다. 디버깅 및 성능 분석에 유용합니다.
-   *
-   * @returns 통계 정보 객체
-   *
-   * @remarks
-   * - totalCells: 현재 사용 중인 셀 개수
-   * - totalItems: 인덱스에 등록된 고유 항목 수 (정확)
-   * - avgItemsPerCell: 셀당 평균 항목 수
-   */
+  }; // 통계 정보 반환
 
 
   SpatialHashGrid.prototype.stats = function () {

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

@@ -2,24 +2,22 @@ import Konva from "konva";
 import { Position, Offset } from "../../../types";
 /**
  * 캔버스 데이터 타입 Enum
- * 마커인지 폴리곤인지 구분하는 상수
  */
 export declare enum CanvasDataType {
     MARKER = "MARKER",
     POLYGON = "POLYGON"
 }
 /**
- * 폴리곤 경로 정의
+ * 폴리곤 경로 정의 (GeoJSON MultiPolygon 형식)
  */
 export interface Paths {
     type: string;
     coordinates: number[][][][];
 }
 /**
- * Konva 캔버스 마커/폴리곤의 기본 필수 속성
- * (렌더링에 필요한 최소 정보)
+ * 캔버스 마커/폴리곤의 기본 필수 속성
  */
-export interface KonvaCanvasOption {
+export interface CanvasOption {
     id: string;
     position: Position;
     boxWidth?: number;
@@ -30,196 +28,63 @@ export interface KonvaCanvasOption {
 }
 /**
  * 서버 데이터와 캔버스 옵션을 결합한 타입
- * @template T 서버에서 받은 원본 데이터 타입 (예: Marker, Polygon)
- * @example
- * // API에서 받은 Marker 타입을 그대로 유지하면서 캔버스 렌더링 정보 추가
- * type MarkerWithCanvas = KonvaCanvasData<Marker>
- * // { raId, lat, lng, buildingName, totalArea } + { id, position, boxWidth, ... }
+ *
+ * @template T 서버에서 받은 원본 데이터 타입
  */
-export declare type KonvaCanvasData<T = {}> = T & KonvaCanvasOption;
+export declare type CanvasData<T = {}> = T & CanvasOption;
 /**
- * 🛠️ 렌더링 유틸리티 함수들
- *
- * WoongCanvasMarker/WoongCanvasPolygon이 제공하는 헬퍼 함수 모음입니다.
- * 커스텀 렌더링 함수 내에서 좌표 변환 시 사용하세요.
- *
- * ## 주요 기능
- * - **자동 캐싱**: 좌표 변환 결과를 LRU 캐시에 저장 (성능 최적화)
- * - **지도 좌표 → 화면 좌표**: 위경도를 픽셀 좌표로 자동 변환
- * - **null 안전성**: 변환 실패 시 null 반환 (안전한 예외 처리)
+ * 렌더링 유틸리티 함수들 (좌표 변환)
  *
  * @template T 마커/폴리곤 데이터의 추가 속성 타입
- *
- * @example
- * // 마커 렌더링 예시
- * const renderBase = ({ ctx, items, utils }) => {
- *   for (const item of items) {
- *     const offset = utils.getOrComputeMarkerOffset(item);
- *     if (!offset) continue; // 변환 실패 시 스킵
- *
- *     ctx.fillRect(offset.x, offset.y, 50, 50);
- *   }
- * };
- *
- * @example
- * // 폴리곤 렌더링 예시
- * const renderBase = ({ ctx, items, utils }) => {
- *   for (const item of items) {
- *     const offsets = utils.getOrComputePolygonOffsets(item);
- *     if (!offsets) continue;
- *
- *     for (const multiPolygon of offsets) {
- *       for (const polygon of multiPolygon) {
- *         ctx.beginPath();
- *         ctx.moveTo(polygon[0][0], polygon[0][1]);
- *         for (let i = 1; i < polygon.length; i++) {
- *           ctx.lineTo(polygon[i][0], polygon[i][1]);
- *         }
- *         ctx.closePath();
- *         ctx.fill();
- *       }
- *     }
- *   }
- * };
  */
 export interface RenderUtils<T> {
-    /**
-     * 폴리곤의 위경도 좌표를 화면 픽셀 좌표로 변환합니다.
-     *
-     * - **자동 캐싱**: 동일한 폴리곤은 캐시에서 즉시 반환 (성능 최적화)
-     * - **MultiPolygon 지원**: GeoJSON MultiPolygon 형식 지원
-     * - **Donut Polygon 지원**: 구멍이 있는 폴리곤 지원
-     *
-     * @param polygonData 폴리곤 데이터 (paths 필드 필수)
-     * @returns 변환된 픽셀 좌표 배열 (4차원 배열) 또는 null (변환 실패 시)
-     *
-     * @example
-     * const offsets = utils.getOrComputePolygonOffsets(polygonItem);
-     * if (!offsets) return; // 변환 실패
-     *
-     * // offsets 구조: [MultiPolygon][Polygon][Point][x/y]
-     * for (const multiPolygon of offsets) {
-     *   for (const polygon of multiPolygon) {
-     *     ctx.beginPath();
-     *     ctx.moveTo(polygon[0][0], polygon[0][1]);
-     *     for (let i = 1; i < polygon.length; i++) {
-     *       ctx.lineTo(polygon[i][0], polygon[i][1]);
-     *     }
-     *     ctx.closePath();
-     *     ctx.fill();
-     *   }
-     * }
-     */
-    getOrComputePolygonOffsets: (polygonData: KonvaCanvasData<T>) => number[][][][] | null;
-    /**
-     * 마커의 위경도 좌표를 화면 픽셀 좌표로 변환합니다.
-     *
-     * - **자동 캐싱**: 동일한 마커는 캐시에서 즉시 반환 (성능 최적화)
-     * - **중심점 기준**: 반환된 좌표는 마커의 중심점 (x, y)
-     *
-     * @param markerData 마커 데이터 (position 필드 필수)
-     * @returns 변환된 픽셀 좌표 { x, y } 또는 null (변환 실패 시)
-     *
-     * @example
-     * const offset = utils.getOrComputeMarkerOffset(markerItem);
-     * if (!offset) return; // 변환 실패
-     *
-     * // offset.x, offset.y는 화면 픽셀 좌표
-     * const boxWidth = markerItem.boxWidth || 60;
-     * const boxHeight = markerItem.boxHeight || 75;
-     *
-     * // 중앙 정렬, 하단 기준으로 그리기
-     * ctx.fillRect(
-     *   offset.x - boxWidth / 2,
-     *   offset.y - boxHeight,
-     *   boxWidth,
-     *   boxHeight
-     * );
-     */
-    getOrComputeMarkerOffset: (markerData: KonvaCanvasData<T>) => Offset | null;
+    getOrComputePolygonOffsets: (polygonData: CanvasData<T>) => number[][][][] | null;
+    getOrComputeMarkerOffset: (markerData: CanvasData<T>) => Offset | null;
 }
 /**
  * 커스텀 렌더링 함수 파라미터 - Base Layer
  */
 export interface RenderBaseParams<T> {
-    /** Canvas 2D 렌더링 컨텍스트 (순수 Canvas API) */
     ctx: CanvasRenderingContext2D;
-    /** 렌더링할 마커/폴리곤 데이터 배열 */
-    items: KonvaCanvasData<T>[];
-    /** 현재 선택된 마커/폴리곤 ID Set */
+    items: CanvasData<T>[];
     selectedIds: Set<string>;
-    /** 현재 hover된 마커/폴리곤 데이터 (선택) */
-    hoveredItem?: KonvaCanvasData<T> | null;
-    /** 렌더링 유틸리티 함수들 */
+    hoveredItem?: CanvasData<T> | null;
     utils: RenderUtils<T>;
 }
 /**
  * 커스텀 렌더링 함수 타입 - Base Layer
  *
- * 🔥 순수 Canvas API 사용 (Konva 지식 불필요!)
- *
- * @example
- * const renderBase = ({ ctx, items, selectedIds, utils }) => {
- *   for (const item of items) {
- *     if (selectedIds.has(item.id)) continue;
- *     const pos = utils.getOrComputeMarkerOffset(item);
- *     ctx.fillRect(pos.x, pos.y, 50, 50); // 순수 Canvas API!
- *   }
- * };
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
  */
 export declare type CustomRenderBase<T> = (params: RenderBaseParams<T>) => void;
 /**
  * 커스텀 렌더링 함수 파라미터 - Animation Layer
  */
 export interface RenderAnimationParams<T> {
-    /** Konva Layer 인스턴스 */
     layer: Konva.Layer;
-    /** 현재 선택된 마커/폴리곤 ID Set */
     selectedIds: Set<string>;
-    /** 전체 마커/폴리곤 데이터 배열 */
-    items: KonvaCanvasData<T>[];
-    /** 렌더링 유틸리티 함수들 */
+    items: CanvasData<T>[];
     utils: RenderUtils<T>;
 }
 /**
  * 커스텀 렌더링 함수 타입 - Animation Layer (선택)
  *
- * @example
- * const renderAnimation = ({ layer, selectedIds, items, utils }) => {
- *   for (const id of selectedIds) {
- *     const item = items.find(i => i.id === id);
- *     // Konva 애니메이션 구현
- *   }
- * };
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
  */
 export declare type CustomRenderAnimation<T> = (params: RenderAnimationParams<T>) => void;
 /**
  * 커스텀 렌더링 함수 파라미터 - Event Layer
  */
 export interface RenderEventParams<T> {
-    /** Canvas 2D 렌더링 컨텍스트 (순수 Canvas API) */
     ctx: CanvasRenderingContext2D;
-    /** 현재 hover된 마커/폴리곤 데이터 */
-    hoveredItem: KonvaCanvasData<T> | null;
-    /** 렌더링 유틸리티 함수들 */
+    hoveredItem: CanvasData<T> | null;
     utils: RenderUtils<T>;
-    /** 현재 선택된 마커/폴리곤 데이터 배열 (선택 강조용) */
-    selectedItems?: KonvaCanvasData<T>[];
-    /** 외부에서 전달된 단일 선택 아이템 (특별한 효과용) */
-    selectedItem?: KonvaCanvasData<T> | null;
+    selectedItems?: CanvasData<T>[];
+    selectedItem?: CanvasData<T> | null;
 }
 /**
  * 커스텀 렌더링 함수 타입 - Event Layer
  *
- * 🔥 순수 Canvas API 사용 (Konva 지식 불필요!)
- *
- * @example
- * const renderEvent = ({ ctx, hoveredItem, utils, selectedItems }) => {
- *   if (hoveredItem) {
- *     const pos = utils.getOrComputeMarkerOffset(hoveredItem);
- *     ctx.fillStyle = 'red';
- *     ctx.fillRect(pos.x, pos.y, 50, 50); // 순수 Canvas API!
- *   }
- * };
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
  */
 export declare type CustomRenderEvent<T> = (params: RenderEventParams<T>) => void;

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 /**
  * 캔버스 데이터 타입 Enum
- * 마커인지 폴리곤인지 구분하는 상수
  */
 exports.CanvasDataType = void 0;