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

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

@@ -1,163 +1,58 @@
 import { Offset } from "../../../types";
 import { MintMapController } from "../../MintMapController";
-import { KonvaCanvasData } from "./types";
+import { CanvasData } from "./types";
 /**
- * 폴리곤 offset 계산
+ * 폴리곤 좌표 변환 (위경도 → 화면 좌표)
  *
- * GeoJSON MultiPolygon 형식의 위경도 좌표를 화면 픽셀 좌표로 변환합니다.
- *
- * @param polygonData 폴리곤 데이터 (paths 필드 필수)
+ * @param polygonData 폴리곤 데이터
  * @param controller MintMapController 인스턴스
- * @returns 변환된 화면 좌표 배열 (4차원 배열) 또는 null (변환 실패 시)
- *
- * @remarks
- * - 반환 형식: [MultiPolygon][Polygon][Point][x/y]
- * - 성능: O(n), n은 폴리곤의 총 좌표 수
- * - GeoJSON MultiPolygon 형식 지원
- *
- * @example
- * ```typescript
- * const offsets = computePolygonOffsets(polygonData, controller);
- * if (!offsets) return; // 변환 실패
- *
- * // offsets 구조: [MultiPolygon][Polygon][Point][x/y]
- * for (const multiPolygon of offsets) {
- *   for (const polygon of multiPolygon) {
- *     // polygon은 [Point][x/y] 배열
- *   }
- * }
- * ```
+ * @returns 변환된 화면 좌표 배열 (4차원 배열) 또는 null
  */
-export declare const computePolygonOffsets: (polygonData: KonvaCanvasData<any>, controller: MintMapController) => number[][][][] | null;
+export declare const computePolygonOffsets: (polygonData: CanvasData<any>, controller: MintMapController) => number[][][][] | null;
 /**
- * 마커 offset 계산
- *
- * 마커의 위경도 좌표를 화면 픽셀 좌표로 변환합니다.
+ * 마커 좌표 변환 (위경도 → 화면 좌표)
  *
- * @param markerData 마커 데이터 (position 필드 필수)
+ * @param markerData 마커 데이터
  * @param controller MintMapController 인스턴스
- * @returns 변환된 화면 좌표 (Offset) 또는 null (변환 실패 시)
- *
- * @remarks
- * - 반환된 좌표는 마커의 중심점 (x, y)
- * - 성능: O(1) - 단일 좌표 변환
- *
- * @example
- * ```typescript
- * const offset = computeMarkerOffset(markerData, controller);
- * if (!offset) return; // 변환 실패
- * // offset.x, offset.y는 화면 픽셀 좌표
- * ```
+ * @returns 변환된 화면 좌표 또는 null
  */
-export declare const computeMarkerOffset: (markerData: KonvaCanvasData<any>, controller: MintMapController) => Offset | null;
+export declare const computeMarkerOffset: (markerData: CanvasData<any>, controller: MintMapController) => Offset | null;
 /**
- * Point-in-Polygon 알고리즘
- *
- * Ray Casting 알고리즘을 사용하여 점이 폴리곤 내부에 있는지 확인합니다.
+ * Point-in-Polygon 알고리즘 (Ray Casting)
  *
  * @param point 확인할 점의 좌표
- * @param polygon 폴리곤 좌표 배열 (각 요소는 [x, y] 형식)
- * @returns 점이 폴리곤 내부에 있으면 true, 아니면 false
- *
- * @remarks
- * - **알고리즘**: Ray Casting (Ray Crossing)
- * - **성능**: O(n), n은 폴리곤의 좌표 수
- * - **경계 처리**: 경계선 위의 점은 내부로 간주
- *
- * @example
- * ```typescript
- * const point = { x: 100, y: 200 };
- * const polygon = [[0, 0], [100, 0], [100, 100], [0, 100]];
- * const isInside = isPointInPolygon(point, polygon);
- * ```
+ * @param polygon 폴리곤 좌표 배열
+ * @returns 점이 폴리곤 내부에 있으면 true
  */
 export declare const isPointInPolygon: (point: Offset, polygon: number[][]) => boolean;
 /**
  * 폴리곤 히트 테스트 (도넛 폴리곤 지원)
  *
- * 점이 폴리곤 내부에 있는지 확인합니다. 도넛 폴리곤(구멍이 있는 폴리곤)을 지원합니다.
- *
  * @param clickedOffset 클릭/마우스 위치 좌표
  * @param polygonData 폴리곤 데이터
  * @param getPolygonOffsets 폴리곤 좌표 변환 함수
- * @returns 점이 폴리곤 내부에 있으면 true, 아니면 false
- *
- * @remarks
- * - **도넛 폴리곤 처리** (isDonutPolygon === true):
- *   1. 외부 폴리곤(첫 번째): 내부에 있어야 함
- *   2. 내부 구멍들(나머지): 내부에 있으면 안 됨 (evenodd 규칙)
- * - **일반 폴리곤 처리**: Point-in-Polygon 알고리즘 사용
- * - **성능**: O(n), n은 폴리곤의 총 좌표 수
- *
- * **중요**: 도넛 폴리곤과 내부 폴리곤은 별개의 polygonData로 처리됩니다.
- * - 도넛 폴리곤 A: isDonutPolygon=true
- * - 내부 폴리곤 B: isDonutPolygon=false (별도 데이터)
- *
- * @example
- * ```typescript
- * const isHit = isPointInPolygonData(
- *   clickedOffset,
- *   polygonData,
- *   getOrComputePolygonOffsets
- * );
- * ```
+ * @returns 점이 폴리곤 내부에 있으면 true
  */
-export declare const isPointInPolygonData: (clickedOffset: Offset, polygonData: KonvaCanvasData<any>, getPolygonOffsets: (data: KonvaCanvasData<any>) => number[][][][] | null) => boolean;
+export declare const isPointInPolygonData: (clickedOffset: Offset, polygonData: CanvasData<any>, getPolygonOffsets: (data: CanvasData<any>) => number[][][][] | null) => boolean;
 /**
- * 마커 히트 테스트 (클릭/hover 영역 체크)
- *
- * 점이 마커의 클릭/호버 영역 내부에 있는지 확인합니다.
- * 마커의 꼬리(tail)는 Hit Test 영역에서 제외됩니다.
+ * 마커 히트 테스트 (꼬리 제외, 오프셋 지원)
  *
  * @param clickedOffset 클릭/마우스 위치 좌표
  * @param markerData 마커 데이터
  * @param getMarkerOffset 마커 좌표 변환 함수
- * @returns 점이 마커 영역 내부에 있으면 true, 아니면 false
- *
- * @remarks
- * - **꼬리 제외**: 꼬리(tail)는 Hit Test 영역에서 제외됩니다
- *   - markerOffset.y는 마커 최하단(꼬리 끝) 좌표
- *   - boxHeight는 마커 본체만 포함 (꼬리 제외)
- *   - tailHeight만큼 위로 올려서 본체만 Hit Test 영역으로 사용
- * - **성능**: O(1) - 단순 사각형 영역 체크
- *
- * @example
- * ```typescript
- * const isHit = isPointInMarkerData(
- *   clickedOffset,
- *   markerData,
- *   getOrComputeMarkerOffset
- * );
- * ```
+ * @returns 점이 마커 영역 내부에 있으면 true
  */
-export declare const isPointInMarkerData: (clickedOffset: Offset, markerData: KonvaCanvasData<any>, getMarkerOffset: (data: KonvaCanvasData<any>) => Offset | null) => boolean;
+export declare const isPointInMarkerData: (clickedOffset: Offset, markerData: CanvasData<any>, getMarkerOffset: (data: CanvasData<any>) => Offset | null) => boolean;
 export declare const hexToRgba: (hexColor: string, alpha?: number) => string;
 /**
- * 텍스트 박스의 너비를 계산합니다.
- *
- * Canvas 2D Context의 measureText()를 사용하여 텍스트의 실제 너비를 계산하고,
- * 패딩과 최소 너비를 고려하여 최종 너비를 반환합니다.
+ * 텍스트 박스 너비 계산
  *
  * @param params 파라미터 객체
  * @param params.text 측정할 텍스트
- * @param params.fontConfig 폰트 설정 (예: 'bold 16px Arial')
- * @param params.padding 텍스트 박스에 적용할 패딩 값 (px)
+ * @param params.fontConfig 폰트 설정
+ * @param params.padding 패딩 값 (px)
  * @param params.minWidth 최소 너비 (px)
- * @returns 계산된 텍스트 박스의 너비 (px)
- *
- * @remarks
- * - 성능: O(1) - 단일 텍스트 측정
- * - 임시 Canvas를 사용하여 정확한 너비 측정
- *
- * @example
- * ```typescript
- * const width = calculateTextBoxWidth({
- *   text: "Hello World",
- *   fontConfig: 'bold 16px Arial',
- *   padding: 20,
- *   minWidth: 60
- * });
- * ```
+ * @returns 계산된 텍스트 박스 너비 (px)
  */
 export declare const calculateTextBoxWidth: ({ text, fontConfig, padding, minWidth, }: {
     text: string;

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

@@ -7,31 +7,11 @@ var MapTypes = require('../../../types/MapTypes.js');
 require('../../../types/MapEventTypes.js');
 
 /**
- * 폴리곤 offset 계산
+ * 폴리곤 좌표 변환 (위경도 → 화면 좌표)
  *
- * GeoJSON MultiPolygon 형식의 위경도 좌표를 화면 픽셀 좌표로 변환합니다.
- *
- * @param polygonData 폴리곤 데이터 (paths 필드 필수)
+ * @param polygonData 폴리곤 데이터
  * @param controller MintMapController 인스턴스
- * @returns 변환된 화면 좌표 배열 (4차원 배열) 또는 null (변환 실패 시)
- *
- * @remarks
- * - 반환 형식: [MultiPolygon][Polygon][Point][x/y]
- * - 성능: O(n), n은 폴리곤의 총 좌표 수
- * - GeoJSON MultiPolygon 형식 지원
- *
- * @example
- * ```typescript
- * const offsets = computePolygonOffsets(polygonData, controller);
- * if (!offsets) return; // 변환 실패
- *
- * // offsets 구조: [MultiPolygon][Polygon][Point][x/y]
- * for (const multiPolygon of offsets) {
- *   for (const polygon of multiPolygon) {
- *     // polygon은 [Point][x/y] 배열
- *   }
- * }
- * ```
+ * @returns 변환된 화면 좌표 배열 (4차원 배열) 또는 null
  */
 
 var computePolygonOffsets = function (polygonData, controller) {
@@ -41,7 +21,7 @@ var computePolygonOffsets = function (polygonData, controller) {
     return null;
   }
 
-  var result = [];
+  var result = []; // GeoJSON MultiPolygon 구조: [MultiPolygon][PolygonGroup][Coordinate][lng, lat]
 
   for (var _i = 0, _a = paths.coordinates; _i < _a.length; _i++) {
     var multiPolygon = _a[_i];
@@ -52,7 +32,8 @@ var computePolygonOffsets = function (polygonData, controller) {
       var polygonOffsets = [];
 
       for (var _c = 0, polygonGroup_1 = polygonGroup; _c < polygonGroup_1.length; _c++) {
-        var coord = polygonGroup_1[_c];
+        var coord = polygonGroup_1[_c]; // GeoJSON은 [lng, lat] 순서이지만 Position은 [lat, lng] 순서
+
         var pos = new MapTypes.Position(coord[1], coord[0]);
         var offset = controller.positionToOffset(pos);
         polygonOffsets.push([offset.x, offset.y]);
@@ -67,65 +48,37 @@ var computePolygonOffsets = function (polygonData, controller) {
   return result;
 };
 /**
- * 마커 offset 계산
+ * 마커 좌표 변환 (위경도 → 화면 좌표)
  *
- * 마커의 위경도 좌표를 화면 픽셀 좌표로 변환합니다.
- *
- * @param markerData 마커 데이터 (position 필드 필수)
+ * @param markerData 마커 데이터
  * @param controller MintMapController 인스턴스
- * @returns 변환된 화면 좌표 (Offset) 또는 null (변환 실패 시)
- *
- * @remarks
- * - 반환된 좌표는 마커의 중심점 (x, y)
- * - 성능: O(1) - 단일 좌표 변환
- *
- * @example
- * ```typescript
- * const offset = computeMarkerOffset(markerData, controller);
- * if (!offset) return; // 변환 실패
- * // offset.x, offset.y는 화면 픽셀 좌표
- * ```
+ * @returns 변환된 화면 좌표 또는 null
  */
 
 var computeMarkerOffset = function (markerData, controller) {
-  if (!markerData.position) {
-    return null;
-  }
-
+  if (!markerData.position) return null;
   return controller.positionToOffset(markerData.position);
 };
 /**
- * Point-in-Polygon 알고리즘
- *
- * Ray Casting 알고리즘을 사용하여 점이 폴리곤 내부에 있는지 확인합니다.
+ * Point-in-Polygon 알고리즘 (Ray Casting)
  *
  * @param point 확인할 점의 좌표
- * @param polygon 폴리곤 좌표 배열 (각 요소는 [x, y] 형식)
- * @returns 점이 폴리곤 내부에 있으면 true, 아니면 false
- *
- * @remarks
- * - **알고리즘**: Ray Casting (Ray Crossing)
- * - **성능**: O(n), n은 폴리곤의 좌표 수
- * - **경계 처리**: 경계선 위의 점은 내부로 간주
- *
- * @example
- * ```typescript
- * const point = { x: 100, y: 200 };
- * const polygon = [[0, 0], [100, 0], [100, 100], [0, 100]];
- * const isInside = isPointInPolygon(point, polygon);
- * ```
+ * @param polygon 폴리곤 좌표 배열
+ * @returns 점이 폴리곤 내부에 있으면 true
  */
 
 var isPointInPolygon = function (point, polygon) {
+  // Ray Casting 알고리즘: 점에서 오른쪽으로 무한히 뻗은 선과 폴리곤 변의 교차 횟수로 판단
   var inside = false;
 
   for (var i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
     var xi = polygon[i][0],
         yi = polygon[i][1];
     var xj = polygon[j][0],
-        yj = polygon[j][1];
+        yj = polygon[j][1]; // 점의 y 좌표가 변의 양 끝점 사이에 있고, 교차점의 x 좌표가 점의 x 좌표보다 큰지 확인
+
     var intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
-    if (intersect) inside = !inside;
+    if (intersect) inside = !inside; // 교차할 때마다 inside 상태 토글
   }
 
   return inside;
@@ -133,42 +86,20 @@ var isPointInPolygon = function (point, polygon) {
 /**
  * 폴리곤 히트 테스트 (도넛 폴리곤 지원)
  *
- * 점이 폴리곤 내부에 있는지 확인합니다. 도넛 폴리곤(구멍이 있는 폴리곤)을 지원합니다.
- *
  * @param clickedOffset 클릭/마우스 위치 좌표
  * @param polygonData 폴리곤 데이터
  * @param getPolygonOffsets 폴리곤 좌표 변환 함수
- * @returns 점이 폴리곤 내부에 있으면 true, 아니면 false
- *
- * @remarks
- * - **도넛 폴리곤 처리** (isDonutPolygon === true):
- *   1. 외부 폴리곤(첫 번째): 내부에 있어야 함
- *   2. 내부 구멍들(나머지): 내부에 있으면 안 됨 (evenodd 규칙)
- * - **일반 폴리곤 처리**: Point-in-Polygon 알고리즘 사용
- * - **성능**: O(n), n은 폴리곤의 총 좌표 수
- *
- * **중요**: 도넛 폴리곤과 내부 폴리곤은 별개의 polygonData로 처리됩니다.
- * - 도넛 폴리곤 A: isDonutPolygon=true
- * - 내부 폴리곤 B: isDonutPolygon=false (별도 데이터)
- *
- * @example
- * ```typescript
- * const isHit = isPointInPolygonData(
- *   clickedOffset,
- *   polygonData,
- *   getOrComputePolygonOffsets
- * );
- * ```
+ * @returns 점이 폴리곤 내부에 있으면 true
  */
 
 var isPointInPolygonData = function (clickedOffset, polygonData, getPolygonOffsets) {
   var polygonOffsets = getPolygonOffsets(polygonData);
-  if (!polygonOffsets) return false; // 🍩 도넛 폴리곤 처리 (isDonutPolygon === true)
+  if (!polygonOffsets) return false; // 도넛 폴리곤 처리: 외부 폴리곤 내부에 있으면서 구멍(hole) 내부에 있지 않아야 함
 
   if (polygonData.isDonutPolygon) {
     for (var _i = 0, polygonOffsets_1 = polygonOffsets; _i < polygonOffsets_1.length; _i++) {
       var multiPolygon = polygonOffsets_1[_i];
-      if (multiPolygon.length === 0) continue; // 외부 폴리곤만 있는 경우 (구멍 없음) - 일반 폴리곤처럼 처리
+      if (multiPolygon.length === 0) continue; // 구멍이 없는 경우 일반 폴리곤과 동일
 
       if (multiPolygon.length === 1) {
         if (isPointInPolygon(clickedOffset, multiPolygon[0])) {
@@ -176,33 +107,30 @@ var isPointInPolygonData = function (clickedOffset, polygonData, getPolygonOffse
         }
 
         continue;
-      } // 1. 외부 폴리곤(첫 번째)에 포함되는지 확인
+      } // 외부 폴리곤 내부에 있는지 확인
 
 
       var outerPolygon = multiPolygon[0];
 
       if (!isPointInPolygon(clickedOffset, outerPolygon)) {
-        continue; // 외부 폴리곤 밖이면 다음 multiPolygon 확인
-      } // 2. 내부 구멍들(나머지)에 포함되는지 확인
+        continue;
+      } // 구멍 내부에 있으면 false (도넛의 빈 공간)
 
 
       for (var i = 1; i < multiPolygon.length; i++) {
         var hole = multiPolygon[i];
 
         if (isPointInPolygon(clickedOffset, hole)) {
-          // ❌ 구멍 안에 있음 → 이 도넛 폴리곤은 히트 안 됨
-          // 다른 multiPolygon 체크하지 않고 바로 false 반환
-          // (도넛 폴리곤의 구멍 안은 무조건 클릭 불가)
           return false;
         }
-      } // ✅ 외부 폴리곤 안 + 구멍 밖 = 히트!
+      } // 외부 폴리곤 내부에 있으면서 모든 구멍 밖에 있으면 true
 
 
       return true;
     }
 
     return false;
-  } // 일반 폴리곤 처리 (isDonutPolygon === false 또는 undefined)
+  } // 일반 폴리곤 처리
 
 
   for (var _a = 0, polygonOffsets_2 = polygonOffsets; _a < polygonOffsets_2.length; _a++) {
@@ -221,31 +149,12 @@ var isPointInPolygonData = function (clickedOffset, polygonData, getPolygonOffse
   return false;
 };
 /**
- * 마커 히트 테스트 (클릭/hover 영역 체크)
- *
- * 점이 마커의 클릭/호버 영역 내부에 있는지 확인합니다.
- * 마커의 꼬리(tail)는 Hit Test 영역에서 제외됩니다.
+ * 마커 히트 테스트 (꼬리 제외, 오프셋 지원)
  *
  * @param clickedOffset 클릭/마우스 위치 좌표
  * @param markerData 마커 데이터
  * @param getMarkerOffset 마커 좌표 변환 함수
- * @returns 점이 마커 영역 내부에 있으면 true, 아니면 false
- *
- * @remarks
- * - **꼬리 제외**: 꼬리(tail)는 Hit Test 영역에서 제외됩니다
- *   - markerOffset.y는 마커 최하단(꼬리 끝) 좌표
- *   - boxHeight는 마커 본체만 포함 (꼬리 제외)
- *   - tailHeight만큼 위로 올려서 본체만 Hit Test 영역으로 사용
- * - **성능**: O(1) - 단순 사각형 영역 체크
- *
- * @example
- * ```typescript
- * const isHit = isPointInMarkerData(
- *   clickedOffset,
- *   markerData,
- *   getOrComputeMarkerOffset
- * );
- * ```
+ * @returns 점이 마커 영역 내부에 있으면 true
  */
 
 var isPointInMarkerData = function (clickedOffset, markerData, getMarkerOffset) {
@@ -253,58 +162,43 @@ var isPointInMarkerData = function (clickedOffset, markerData, getMarkerOffset)
   if (!markerOffset) return false;
   var boxWidth = markerData.boxWidth || 50;
   var boxHeight = markerData.boxHeight || 28;
-  var tailHeight = markerData.tailHeight || 0; // 🎯 tailHeight 사용!
+  var tailHeight = markerData.tailHeight || 0;
+  var offsetX = markerData.offsetX || 0;
+  var offsetY = markerData.offsetY || 0; // 오프셋을 적용한 마커 중심점 기준으로 박스 영역 계산 (꼬리는 제외)
 
-  var x = markerOffset.x - boxWidth / 2;
-  var y = markerOffset.y - boxHeight - tailHeight; // 🔥 꼬리만큼 위로!
+  var x = markerOffset.x + offsetX - boxWidth / 2;
+  var y = markerOffset.y + offsetY - boxHeight - tailHeight; // 클릭 위치가 박스 영역 내부에 있는지 확인
 
   return clickedOffset.x >= x && clickedOffset.x <= x + boxWidth && clickedOffset.y >= y && clickedOffset.y <= y + boxHeight;
-};
+}; // Hex 색상을 RGBA로 변환
+
 var hexToRgba = function (hexColor, alpha) {
   if (alpha === void 0) {
     alpha = 1;
-  } // NOTE: 입력된 hexColor에서 "#" 제거
-
+  }
 
-  var hex = hexColor.replace('#', ''); // NOTE: 6자리일 경우 알파 값은 사용자가 제공한 alpha 값으로 설정
+  var hex = hexColor.replace('#', '');
 
-  if (hex.length === 6) {
-    var r = parseInt(hex.substring(0, 2), 16);
-    var g = parseInt(hex.substring(2, 4), 16);
-    var b = parseInt(hex.substring(4, 6), 16);
-    return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(alpha, ")");
+  if (hex.length !== 6) {
+    throw new Error('Invalid hex color format');
   }
 
-  throw new Error('Invalid hex color format');
+  var r = parseInt(hex.substring(0, 2), 16);
+  var g = parseInt(hex.substring(2, 4), 16);
+  var b = parseInt(hex.substring(4, 6), 16);
+  return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(alpha, ")");
 };
 var tempCanvas = document.createElement('canvas');
 var tempCtx = tempCanvas.getContext('2d');
 /**
- * 텍스트 박스의 너비를 계산합니다.
- *
- * Canvas 2D Context의 measureText()를 사용하여 텍스트의 실제 너비를 계산하고,
- * 패딩과 최소 너비를 고려하여 최종 너비를 반환합니다.
+ * 텍스트 박스 너비 계산
  *
  * @param params 파라미터 객체
  * @param params.text 측정할 텍스트
- * @param params.fontConfig 폰트 설정 (예: 'bold 16px Arial')
- * @param params.padding 텍스트 박스에 적용할 패딩 값 (px)
+ * @param params.fontConfig 폰트 설정
+ * @param params.padding 패딩 값 (px)
  * @param params.minWidth 최소 너비 (px)
- * @returns 계산된 텍스트 박스의 너비 (px)
- *
- * @remarks
- * - 성능: O(1) - 단일 텍스트 측정
- * - 임시 Canvas를 사용하여 정확한 너비 측정
- *
- * @example
- * ```typescript
- * const width = calculateTextBoxWidth({
- *   text: "Hello World",
- *   fontConfig: 'bold 16px Arial',
- *   padding: 20,
- *   minWidth: 60
- * });
- * ```
+ * @returns 계산된 텍스트 박스 너비 (px)
  */
 
 var calculateTextBoxWidth = function (_a) {

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

@@ -1,5 +1,5 @@
 import { MutableRefObject } from "react";
-import { KonvaCanvasData } from "./types";
+import { CanvasData } from "./types";
 /**
  * 뷰포트 영역 (화면에 보이는 영역)
  */
@@ -21,20 +21,9 @@ export interface BoundingBox {
 /**
  * 현재 뷰포트 영역 계산
  *
- * Konva Stage의 크기와 컬링 마진을 기반으로 뷰포트 경계를 계산합니다.
- *
- * @param stage Konva Stage 인스턴스 (width, height 메서드 제공)
+ * @param stage Konva Stage 인스턴스
  * @param cullingMargin 컬링 여유 공간 (px)
  * @param viewportRef 뷰포트 경계를 저장할 ref
- *
- * @remarks
- * - 화면 밖 cullingMargin만큼의 영역까지 포함하여 계산
- * - 스크롤 시 부드러운 전환을 위해 여유 공간 포함
- *
- * @example
- * ```typescript
- * updateViewport(stageRef.current, cullingMargin, viewportRef);
- * ```
  */
 export declare const updateViewport: (stage: {
     width: () => number;
@@ -43,30 +32,11 @@ export declare const updateViewport: (stage: {
 /**
  * 아이템이 현재 뷰포트 안에 있는지 확인 (바운딩 박스 캐싱)
  *
- * 뷰포트 컬링을 위한 함수입니다. 바운딩 박스와 뷰포트 경계의 교차를 확인합니다.
- * 바운딩 박스는 캐시되어 성능을 최적화합니다.
- *
  * @template T 마커/폴리곤 데이터의 추가 속성 타입
  * @param item 확인할 아이템
- * @param enableViewportCulling 뷰포트 컬링 활성화 여부
  * @param viewportRef 뷰포트 경계 ref
  * @param boundingBoxCacheRef 바운딩 박스 캐시 ref
  * @param computeBoundingBox 바운딩 박스 계산 함수
- * @returns 뷰포트 안에 있으면 true, 아니면 false
- *
- * @remarks
- * - 성능: O(1) (캐시 히트 시) 또는 O(바운딩 박스 계산 비용) (캐시 미스 시)
- * - 바운딩 박스는 자동으로 캐시되어 재사용됨
- *
- * @example
- * ```typescript
- * const isVisible = isInViewport(
- *   item,
- *   enableViewportCulling,
- *   viewportRef,
- *   boundingBoxCacheRef,
- *   computeBoundingBox
- * );
- * ```
+ * @returns 뷰포트 안에 있으면 true
  */
-export declare const isInViewport: <T>(item: KonvaCanvasData<T>, enableViewportCulling: boolean, viewportRef: MutableRefObject<ViewportBounds | null>, boundingBoxCacheRef: MutableRefObject<Map<string, BoundingBox>>, computeBoundingBox: (item: KonvaCanvasData<T>) => BoundingBox | null) => boolean;
+export declare const isInViewport: <T>(item: CanvasData<T>, viewportRef: MutableRefObject<ViewportBounds | null>, boundingBoxCacheRef: MutableRefObject<Map<string, BoundingBox>>, computeBoundingBox: (item: CanvasData<T>) => BoundingBox | null) => boolean;

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

@@ -5,20 +5,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 /**
  * 현재 뷰포트 영역 계산
  *
- * Konva Stage의 크기와 컬링 마진을 기반으로 뷰포트 경계를 계산합니다.
- *
- * @param stage Konva Stage 인스턴스 (width, height 메서드 제공)
+ * @param stage Konva Stage 인스턴스
  * @param cullingMargin 컬링 여유 공간 (px)
  * @param viewportRef 뷰포트 경계를 저장할 ref
- *
- * @remarks
- * - 화면 밖 cullingMargin만큼의 영역까지 포함하여 계산
- * - 스크롤 시 부드러운 전환을 위해 여유 공간 포함
- *
- * @example
- * ```typescript
- * updateViewport(stageRef.current, cullingMargin, viewportRef);
- * ```
  */
 var updateViewport = function (stage, cullingMargin, viewportRef) {
   if (!stage) return;
@@ -32,35 +21,16 @@ var updateViewport = function (stage, cullingMargin, viewportRef) {
 /**
  * 아이템이 현재 뷰포트 안에 있는지 확인 (바운딩 박스 캐싱)
  *
- * 뷰포트 컬링을 위한 함수입니다. 바운딩 박스와 뷰포트 경계의 교차를 확인합니다.
- * 바운딩 박스는 캐시되어 성능을 최적화합니다.
- *
  * @template T 마커/폴리곤 데이터의 추가 속성 타입
  * @param item 확인할 아이템
- * @param enableViewportCulling 뷰포트 컬링 활성화 여부
  * @param viewportRef 뷰포트 경계 ref
  * @param boundingBoxCacheRef 바운딩 박스 캐시 ref
  * @param computeBoundingBox 바운딩 박스 계산 함수
- * @returns 뷰포트 안에 있으면 true, 아니면 false
- *
- * @remarks
- * - 성능: O(1) (캐시 히트 시) 또는 O(바운딩 박스 계산 비용) (캐시 미스 시)
- * - 바운딩 박스는 자동으로 캐시되어 재사용됨
- *
- * @example
- * ```typescript
- * const isVisible = isInViewport(
- *   item,
- *   enableViewportCulling,
- *   viewportRef,
- *   boundingBoxCacheRef,
- *   computeBoundingBox
- * );
- * ```
+ * @returns 뷰포트 안에 있으면 true
  */
 
-var isInViewport = function (item, enableViewportCulling, viewportRef, boundingBoxCacheRef, computeBoundingBox) {
-  if (!enableViewportCulling || !viewportRef.current) return true;
+var isInViewport = function (item, viewportRef, boundingBoxCacheRef, computeBoundingBox) {
+  if (!viewportRef.current) return true;
   var viewport = viewportRef.current; // 캐시된 바운딩 박스 확인
 
   var bbox = boundingBoxCacheRef.current.get(item.id);