@mint-ui/map 1.2.0-test.5 → 1.2.0-test.50

package/dist/components/mint-map/core/advanced/canvas/CanvasMarkerClaude.js

@@ -107,12 +107,12 @@ var CanvasMarkerClaude = React__default["default"].memo(function CanvasMarkerCla
   var hoveredPolygonRef = React.useRef(null);
   var clickedPolygonRef = React.useRef(null);
   var hoveredMarkerRef = React.useRef(null);
-  var clickedMarkerRef = React.useRef(null); // 🚀 WoongCanvasMarker 방식: 단순한 data ref (geohash 제거)
+  var clickedMarkerRef = React.useRef(null); // 🚀 CanvasMarker 방식: 단순한 data ref (geohash 제거)
 
   var polygonsRef = React.useRef([]);
   var markersRef = React.useRef([]); // 마커 경계 정보 저장 (hit-test용)
 
-  var markerBoundsRef = React.useRef(new Map()); // 🚀 드래그 추적용 (WoongCanvasMarker 방식)
+  var markerBoundsRef = React.useRef(new Map()); // 🚀 드래그 추적용 (CanvasMarker 방식)
 
   var draggingRef = React.useRef(false);
   var prevCenterOffsetRef = React.useRef(null);
@@ -172,7 +172,7 @@ var CanvasMarkerClaude = React__default["default"].memo(function CanvasMarkerCla
     if (!baseContextRef.current || !polygonsRef.current || polygonsRef.current.length === 0) return;
     canvasUtil.clearRect(baseCanvasRef.current, baseContextRef.current);
     var cacheMissCount = 0; // 캐시 미스 카운트
-    // 🚀 WoongCanvasMarker 방식: 전체 데이터 순회 (필터링 제거)
+    // 🚀 CanvasMarker 방식: 전체 데이터 순회 (필터링 제거)
 
     polygonsRef.current.forEach(function (polygon) {
       if (polygon.visible === false) return; // 🚀 캐시 확인 (ID 기반으로 변경)
@@ -243,7 +243,7 @@ var CanvasMarkerClaude = React__default["default"].memo(function CanvasMarkerCla
     if (!markersRef.current || markersRef.current.length === 0) return;
     canvasUtil.clearRect(baseMarkerCanvasRef.current, baseMarkerContextRef.current); // 마커 경계 정보 초기화
 
-    markerBoundsRef.current.clear(); // 🚀 WoongCanvasMarker 방식: 전체 데이터 순회 (필터링 제거)
+    markerBoundsRef.current.clear(); // 🚀 CanvasMarker 방식: 전체 데이터 순회 (필터링 제거)
 
     markersRef.current.forEach(function (marker) {
       var _a, _b;
@@ -566,7 +566,7 @@ var CanvasMarkerClaude = React__default["default"].memo(function CanvasMarkerCla
     }
 
     return null;
-  }; // IDLE 이벤트 핸들러 (WoongCanvasMarker 최적화 적용)
+  }; // IDLE 이벤트 핸들러 (CanvasMarker 최적화 적용)
 
 
   var handleIdle = function () {
@@ -632,7 +632,7 @@ var CanvasMarkerClaude = React__default["default"].memo(function CanvasMarkerCla
       x: event.clientX - rect.left,
       y: event.clientY - rect.top
     };
-  }; // 🚀 지도 클릭 이벤트 핸들러 (WoongCanvasMarker 방식 - controller.addEventListener)
+  }; // 🚀 지도 클릭 이벤트 핸들러 (CanvasMarker 방식 - controller.addEventListener)
 
 
   var handleMapClick = function (event) {
@@ -724,7 +724,7 @@ var CanvasMarkerClaude = React__default["default"].memo(function CanvasMarkerCla
   var rafIdRef = React.useRef(); // 마우스 이벤트 핸들러 (requestAnimationFrame으로 최적화)
 
   var handleMouseMove = function (e) {
-    // 🚀 드래그 중이면 호버 처리 스킵 (WoongCanvasMarker 방식)
+    // 🚀 드래그 중이면 호버 처리 스킵 (CanvasMarker 방식)
     if (draggingRef.current) return; // 이미 RAF가 대기 중이면 스킵
 
     if (rafIdRef.current) return;

package/dist/components/mint-map/core/advanced/canvas/index.d.ts

@@ -1,3 +1,2 @@
 export * from './CanvasMarker';
-export * from './CanvasMarkerHanquf';
 export * from './CanvasMarkerClaude';

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

@@ -2,4 +2,6 @@ export * from './shapes';
 export * from './canvas';
 export * from './MapBuildingProjection';
 export * from './MapLoadingComponents';
-export * from './woongCanvas';
+export * from './shared';
+export * from './CanvasMarkerLayer';
+export * from './CanvasPolygonLayer';

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

@@ -0,0 +1,39 @@
+import React from "react";
+import { Offset } from "../../../types";
+import { CanvasData } from "./types";
+/**
+ * Canvas 컴포넌트 인스턴스 인터페이스
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ */
+export interface ComponentInstance<T> {
+    zIndex: number;
+    hitTest: (offset: Offset) => boolean;
+    onClick?: (payload: CanvasData<T>, selectedIds: Set<string>) => void;
+    onMouseOver?: (payload: CanvasData<T>) => void;
+    onMouseOut?: (payload: CanvasData<T>) => void;
+    findData: (offset: Offset) => CanvasData<T> | null;
+    setHovered: (data: CanvasData<T> | null) => void;
+    handleLocalClick: (data: CanvasData<T>) => void;
+    getSelectedIds: () => Set<string>;
+    isInteractionDisabled: () => boolean;
+}
+interface CanvasContextValue {
+    registerComponent: <T>(instance: ComponentInstance<T>) => void;
+    unregisterComponent: <T>(instance: ComponentInstance<T>) => void;
+}
+/**
+ * CanvasProvider 컴포넌트
+ *
+ * 다중 Canvas 인스턴스를 관리하고 zIndex 기반 이벤트 우선순위를 처리합니다.
+ */
+export declare const CanvasProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+/**
+ * Canvas Context Hook
+ *
+ * @returns CanvasContextValue 또는 null (Provider 없으면)
+ */
+export declare const useCanvasContext: () => CanvasContextValue | null;
+export {};

package/dist/components/mint-map/core/advanced/{woongCanvas/shared → shared}/context.js

@@ -3,38 +3,35 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var React = require('react');
-var MintMapProvider = require('../../../provider/MintMapProvider.js');
+var MintMapProvider = require('../../provider/MintMapProvider.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
-var KonvaMarkerContext = React.createContext(null);
-var KonvaMarkerProvider = function (_a) {
-  var children = _a.children;
-  var controller = MintMapProvider.useMintMapController(); // Refs
+var CanvasContext = React.createContext(null);
+/**
+ * CanvasProvider 컴포넌트
+ *
+ * 다중 Canvas 인스턴스를 관리하고 zIndex 기반 이벤트 우선순위를 처리합니다.
+ */
 
+var CanvasProvider = function (_a) {
+  var children = _a.children;
+  var controller = MintMapProvider.useMintMapController();
   var componentsRef = React.useRef([]);
   var currentHoveredRef = React.useRef(null);
   var currentHoveredDataRef = React.useRef(null);
-  var draggingRef = React.useRef(false);
-  /**
-   * 컴포넌트 등록 (zIndex 내림차순 정렬)
-   * 높은 zIndex가 먼저 처리됨
-   */
+  var draggingRef = React.useRef(false); // 컴포넌트 등록 (zIndex 내림차순 정렬)
 
   var registerComponent = React.useCallback(function (instance) {
     componentsRef.current.push(instance);
     componentsRef.current.sort(function (a, b) {
       return b.zIndex - a.zIndex;
     });
-  }, []);
-  /**
-   * 컴포넌트 등록 해제
-   */
+  }, []); // 컴포넌트 등록 해제
 
   var unregisterComponent = React.useCallback(function (instance) {
-    // Hover 중이던 컴포넌트면 초기화
     if (currentHoveredRef.current === instance) {
       currentHoveredRef.current = null;
       currentHoveredDataRef.current = null;
@@ -43,95 +40,77 @@ var KonvaMarkerProvider = function (_a) {
     componentsRef.current = componentsRef.current.filter(function (c) {
       return c !== instance;
     });
-  }, []);
-  /**
-   * 전역 클릭 핸들러 (zIndex 우선순위)
-   */
+  }, []); // 전역 클릭 핸들러 (zIndex 우선순위)
 
   var handleGlobalClick = React.useCallback(function (event) {
-    var _a;
+    var _a, _b;
 
     if (!((_a = event === null || event === void 0 ? void 0 : event.param) === null || _a === void 0 ? void 0 : _a.position)) return;
-    var clickedOffset = controller.positionToOffset(event.param.position); // zIndex 순서대로 순회 (높은 것부터)
+    var clickedOffset = controller.positionToOffset(event.param.position); // zIndex 내림차순으로 정렬된 컴포넌트 순회 (높은 zIndex가 먼저 처리)
 
-    for (var _i = 0, _b = componentsRef.current; _i < _b.length; _i++) {
-      var component = _b[_i];
+    for (var _i = 0, _c = componentsRef.current; _i < _c.length; _i++) {
+      var component = _c[_i];
+      if (component.isInteractionDisabled()) continue;
       var data = component.findData(clickedOffset);
+      if (!data) continue; // 첫 번째로 찾은 항목만 처리하고 종료 (zIndex 우선순위)
 
-      if (data) {
-        component.handleLocalClick(data);
-
-        if (component.onClick) {
-          component.onClick(data, component.getSelectedIds());
-        }
-
-        return; // 첫 번째 히트만 처리
-      }
+      component.handleLocalClick(data);
+      (_b = component.onClick) === null || _b === void 0 ? void 0 : _b.call(component, data, component.getSelectedIds());
+      return;
     }
-  }, [controller]);
-  /**
-   * 전역 마우스 이동 핸들러 (zIndex 우선순위)
-   */
+  }, [controller]); // 전역 마우스 이동 핸들러 (zIndex 우선순위)
 
   var handleGlobalMouseMove = React.useCallback(function (event) {
     var _a;
 
     if (draggingRef.current || !((_a = event === null || event === void 0 ? void 0 : event.param) === null || _a === void 0 ? void 0 : _a.position)) return;
-    var mouseOffset = controller.positionToOffset(event.param.position); // zIndex 순서대로 순회하여 Hover 대상 찾기
-
+    var mouseOffset = controller.positionToOffset(event.param.position);
     var newHoveredComponent = null;
-    var newHoveredData = null;
+    var newHoveredData = null; // zIndex 내림차순으로 정렬된 컴포넌트 순회 (높은 zIndex가 먼저 처리)
 
     for (var _i = 0, _b = componentsRef.current; _i < _b.length; _i++) {
       var component = _b[_i];
+      if (component.isInteractionDisabled()) continue;
       var data = component.findData(mouseOffset);
+      if (!data) continue; // 첫 번째로 찾은 항목만 hover 처리 (zIndex 우선순위)
 
-      if (data) {
-        newHoveredComponent = component;
-        newHoveredData = data;
-        break; // 첫 번째 히트만 처리
-      }
-    } // Hover 상태 변경 감지 (최적화: 별도 ref로 직접 비교)
-
+      newHoveredComponent = component;
+      newHoveredData = data;
+      break;
+    } // hover 상태가 변경되지 않았으면 종료 (불필요한 렌더링 방지)
 
-    if (currentHoveredRef.current !== newHoveredComponent || currentHoveredDataRef.current !== newHoveredData) {
-      // 이전 hover 해제
-      if (currentHoveredRef.current) {
-        currentHoveredRef.current.setHovered(null);
 
-        if (currentHoveredRef.current.onMouseOut && currentHoveredDataRef.current) {
-          currentHoveredRef.current.onMouseOut(currentHoveredDataRef.current);
-        }
-      } // 새 hover 설정
+    if (currentHoveredRef.current === newHoveredComponent && currentHoveredDataRef.current === newHoveredData) {
+      return;
+    } // 기존 hover 항목에 mouseOut 이벤트 발생
 
 
-      if (newHoveredComponent && newHoveredData) {
-        newHoveredComponent.setHovered(newHoveredData);
+    if (currentHoveredRef.current) {
+      currentHoveredRef.current.setHovered(null);
 
-        if (newHoveredComponent.onMouseOver) {
-          newHoveredComponent.onMouseOver(newHoveredData);
-        }
+      if (currentHoveredRef.current.onMouseOut && currentHoveredDataRef.current) {
+        currentHoveredRef.current.onMouseOut(currentHoveredDataRef.current);
       }
+    } // 새 hover 항목에 mouseOver 이벤트 발생
+
 
-      currentHoveredRef.current = newHoveredComponent;
-      currentHoveredDataRef.current = newHoveredData;
+    if (newHoveredComponent && newHoveredData) {
+      newHoveredComponent.setHovered(newHoveredData);
+
+      if (newHoveredComponent.onMouseOver) {
+        newHoveredComponent.onMouseOver(newHoveredData);
+      }
     }
-  }, [controller]);
-  /**
-   * 줌/드래그 시작 (마우스 이동 이벤트 무시)
-   */
 
+    currentHoveredRef.current = newHoveredComponent;
+    currentHoveredDataRef.current = newHoveredData;
+  }, [controller]);
   var handleZoomStart = React.useCallback(function () {
     draggingRef.current = true;
   }, []);
-  /**
-   * 지도 idle (마우스 이동 이벤트 재개)
-   */
-
   var handleIdle = React.useCallback(function () {
     draggingRef.current = false;
-  }, []); // 이벤트 리스너 등록
-
+  }, []);
   React.useEffect(function () {
     controller.addEventListener('CLICK', handleGlobalClick);
     controller.addEventListener('MOUSEMOVE', handleGlobalMouseMove);
@@ -143,22 +122,26 @@ var KonvaMarkerProvider = function (_a) {
       controller.removeEventListener('ZOOMSTART', handleZoomStart);
       controller.removeEventListener('IDLE', handleIdle);
     };
-  }, [controller, handleGlobalClick, handleGlobalMouseMove, handleZoomStart, handleIdle]); // Context value 메모이제이션
-
+  }, [controller, handleGlobalClick, handleGlobalMouseMove, handleZoomStart, handleIdle]);
   var contextValue = React.useMemo(function () {
     return {
       registerComponent: registerComponent,
       unregisterComponent: unregisterComponent
     };
   }, [registerComponent, unregisterComponent]);
-  return React__default["default"].createElement(KonvaMarkerContext.Provider, {
+  return React__default["default"].createElement(CanvasContext.Provider, {
     value: contextValue
   }, children);
 };
-var useKonvaMarkerContext = function () {
-  var context = React.useContext(KonvaMarkerContext);
-  return context;
+/**
+ * Canvas Context Hook
+ *
+ * @returns CanvasContextValue 또는 null (Provider 없으면)
+ */
+
+var useCanvasContext = function () {
+  return React.useContext(CanvasContext);
 };
 
-exports.KonvaMarkerProvider = KonvaMarkerProvider;
-exports.useKonvaMarkerContext = useKonvaMarkerContext;
+exports.CanvasProvider = CanvasProvider;
+exports.useCanvasContext = useCanvasContext;

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

@@ -0,0 +1,20 @@
+import { EventParam, MapUIEventParam } from "../../../types";
+import type { MintMapController } from "../../MintMapController";
+import type { Offset } from "../../../types";
+/**
+ * 이벤트 유효성 검증 및 좌표 변환
+ *
+ * @param event 이벤트 파라미터
+ * @param context CanvasContext 인스턴스
+ * @param controller MintMapController 인스턴스
+ * @returns 유효한 화면 좌표 또는 null
+ */
+export declare const validateEvent: (event: EventParam<MapUIEventParam> | null | undefined, context: any, controller: MintMapController) => Offset | null;
+/**
+ * Map의 values를 배열로 변환
+ *
+ * @template T Map 값의 타입
+ * @param map 변환할 Map
+ * @returns Map의 값 배열
+ */
+export declare const mapValuesToArray: <T>(map: Map<string, T>) => T[];

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

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * 이벤트 유효성 검증 및 좌표 변환
+ *
+ * @param event 이벤트 파라미터
+ * @param context CanvasContext 인스턴스
+ * @param controller MintMapController 인스턴스
+ * @returns 유효한 화면 좌표 또는 null
+ */
+var validateEvent = function (event, 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 { MintMapController } from "../../MintMapController";
+import type { Marker, MarkerOptions } from "../../../types";
+import type { CanvasData } from "./types";
+import type { BoundingBox } from "./viewport";
+import type { SpatialHashGrid } from "./performance";
+/**
+ * 공통 이벤트 핸들러 의존성 인터페이스
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ *
+ * @remarks
+ * 지도 이벤트 핸들러 생성 시 필요한 모든 의존성을 포함합니다.
+ */
+export interface EventHandlerDeps<T> {
+    controller: MintMapController;
+    containerRef: MutableRefObject<HTMLDivElement | null>;
+    markerRef: MutableRefObject<Marker | undefined>;
+    options: Pick<MarkerOptions, 'zIndex' | 'anchor' | 'visible'>;
+    prevCenterOffsetRef: MutableRefObject<{
+        x: number;
+        y: number;
+    } | null>;
+    accumTranslateRef: MutableRefObject<{
+        x: number;
+        y: number;
+    }>;
+    offsetCacheRef: MutableRefObject<any>;
+    boundingBoxCacheRef: MutableRefObject<Map<string, BoundingBox>>;
+    renderAllImmediate: () => void;
+}
+/**
+ * 지도 이벤트 핸들러 생성 함수
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param deps 이벤트 핸들러 생성에 필요한 의존성
+ * @returns 지도 이벤트 핸들러 객체
+ */
+export declare const createMapEventHandlers: <T>(deps: EventHandlerDeps<T>) => {
+    handleIdle: () => void;
+    handleZoomStart: () => void;
+    handleZoomEnd: () => void;
+    handleCenterChanged: () => void;
+    handleDragStart: () => void;
+    handleDragEnd: () => 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,189 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+
+/**
+ * 지도 이벤트 핸들러 생성 함수
+ *
+ * @template T 마커/폴리곤 데이터의 추가 속성 타입
+ * @param deps 이벤트 핸들러 생성에 필요한 의존성
+ * @returns 지도 이벤트 핸들러 객체
+ */
+
+var createMapEventHandlers = function (deps) {
+  var controller = deps.controller,
+      containerRef = deps.containerRef,
+      markerRef = deps.markerRef,
+      options = deps.options,
+      prevCenterOffsetRef = deps.prevCenterOffsetRef,
+      accumTranslateRef = deps.accumTranslateRef,
+      offsetCacheRef = deps.offsetCacheRef,
+      boundingBoxCacheRef = deps.boundingBoxCacheRef,
+      renderAllImmediate = deps.renderAllImmediate; // 지도 이동/줌 완료 시 처리 (캐시 초기화 및 렌더링)
+
+  var handleIdle = function () {
+    prevCenterOffsetRef.current = null;
+    accumTranslateRef.current = {
+      x: 0,
+      y: 0
+    }; // 캐시 정리 (지도 이동/줌으로 좌표 변환 결과가 바뀜)
+
+    offsetCacheRef.current.clear();
+    boundingBoxCacheRef.current.clear(); // 마커 위치 업데이트
+
+    var bounds = controller.getCurrBounds();
+
+    var markerOptions = tslib.__assign({
+      position: bounds.nw
+    }, options);
+
+    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 {
+    handleIdle: handleIdle,
+    handleZoomStart: handleZoomStart,
+    handleZoomEnd: handleZoomEnd,
+    handleCenterChanged: handleCenterChanged,
+    handleDragStart: handleDragStart,
+    handleDragEnd: handleDragEnd
+  };
+};
+/**
+ * 공간 인덱스 빌드 (빠른 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);
+  });
+  selectedIdsRef.current = newSelectedIds;
+  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

@@ -2,3 +2,6 @@ export * from './types';
 export * from './utils';
 export * from './context';
 export * from './performance';
+export * from './viewport';
+export * from './hooks';
+export * from './helpers';