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

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

@@ -1,79 +1,31 @@
 import React from "react";
 import { Offset } from "../../../types";
-import { KonvaCanvasData } from "./types";
+import { CanvasData } from "./types";
 /**
- * 다중 WoongCanvasMarker/WoongCanvasPolygon 인스턴스를 관리하기 위한 Context
- *
- * 여러 WoongCanvas 컴포넌트가 함께 사용될 때 zIndex 기반으로 이벤트 우선순위를 관리합니다.
- *
- * @remarks
- * **주요 용도:**
- * - zIndex 기반 이벤트 우선순위 처리 (높은 zIndex가 먼저 처리)
- * - 전역 클릭/호버 이벤트 조정
- * - 여러 레이어 간 상호작용 관리
- *
- * @example
- * ```tsx
- * <WoongCanvasProvider>
- *   <WoongCanvasMarker data={markers} zIndex={10} />
- *   <WoongCanvasPolygon data={polygons} zIndex={5} />
- * </WoongCanvasProvider>
- * ```
+ * WoongCanvas 컴포넌트 인스턴스 인터페이스
  *
  * @template T 마커/폴리곤 데이터의 추가 속성 타입
  */
 export interface ComponentInstance<T> {
     zIndex: number;
     hitTest: (offset: Offset) => boolean;
-    onClick?: (payload: KonvaCanvasData<T>, selectedIds: Set<string>) => void;
-    onMouseOver?: (payload: KonvaCanvasData<T>) => void;
-    onMouseOut?: (payload: KonvaCanvasData<T>) => void;
-    findData: (offset: Offset) => KonvaCanvasData<T> | null;
-    setHovered: (data: KonvaCanvasData<T> | null) => void;
-    handleLocalClick: (data: KonvaCanvasData<T>) => void;
+    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;
 }
-/**
- * WoongCanvas Context Value 인터페이스
- *
- * @template T 마커/폴리곤 데이터의 추가 속성 타입
- */
 interface WoongCanvasContextValue {
-    /**
-     * 컴포넌트 인스턴스 등록
-     *
-     * @param instance 등록할 컴포넌트 인스턴스
-     */
     registerComponent: <T>(instance: ComponentInstance<T>) => void;
-    /**
-     * 컴포넌트 인스턴스 등록 해제
-     *
-     * @param instance 등록 해제할 컴포넌트 인스턴스
-     */
     unregisterComponent: <T>(instance: ComponentInstance<T>) => void;
 }
 /**
  * WoongCanvasProvider 컴포넌트
  *
- * 다중 WoongCanvas 컴포넌트 인스턴스를 관리하는 Context Provider입니다.
- * 여러 WoongCanvasMarker/WoongCanvasPolygon이 함께 사용될 때 전역 이벤트 조정을 수행합니다.
- *
- * @param props 컴포넌트 props
- * @param props.children 자식 컴포넌트
- *
- * @remarks
- * - zIndex 기반으로 이벤트 우선순위 처리
- * - 전역 클릭/호버 이벤트 조정
- * - 여러 레이어 간 상호작용 관리
- *
- * @example
- * ```tsx
- * <WoongCanvasProvider>
- *   <WoongCanvasMarker data={markers} zIndex={10} />
- *   <WoongCanvasPolygon data={polygons} zIndex={5} />
- * </WoongCanvasProvider>
- * ```
+ * 다중 WoongCanvas 인스턴스를 관리하고 zIndex 기반 이벤트 우선순위를 처리합니다.
  */
 export declare const WoongCanvasProvider: React.FC<{
     children: React.ReactNode;
@@ -81,21 +33,7 @@ export declare const WoongCanvasProvider: React.FC<{
 /**
  * WoongCanvas Context Hook
  *
- * WoongCanvasProvider로 감싸진 컴포넌트에서 Context에 접근할 수 있는 hook입니다.
- *
  * @returns WoongCanvasContextValue 또는 null (Provider 없으면)
- *
- * @remarks
- * - Provider로 감싸지지 않으면 null 반환 (각 컴포넌트가 로컬 이벤트 처리)
- * - Provider로 감싸져 있으면 전역 이벤트 조정 활성화
- *
- * @example
- * ```typescript
- * const context = useWoongCanvasContext();
- * if (context) {
- *   // Context 사용 중 (전역 이벤트 조정)
- * }
- * ```
  */
 export declare const useWoongCanvasContext: () => WoongCanvasContextValue | null;
 export {};

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

@@ -13,62 +13,25 @@ var WoongCanvasContext = React.createContext(null);
 /**
  * WoongCanvasProvider 컴포넌트
  *
- * 다중 WoongCanvas 컴포넌트 인스턴스를 관리하는 Context Provider입니다.
- * 여러 WoongCanvasMarker/WoongCanvasPolygon이 함께 사용될 때 전역 이벤트 조정을 수행합니다.
- *
- * @param props 컴포넌트 props
- * @param props.children 자식 컴포넌트
- *
- * @remarks
- * - zIndex 기반으로 이벤트 우선순위 처리
- * - 전역 클릭/호버 이벤트 조정
- * - 여러 레이어 간 상호작용 관리
- *
- * @example
- * ```tsx
- * <WoongCanvasProvider>
- *   <WoongCanvasMarker data={markers} zIndex={10} />
- *   <WoongCanvasPolygon data={polygons} zIndex={5} />
- * </WoongCanvasProvider>
- * ```
+ * 다중 WoongCanvas 인스턴스를 관리하고 zIndex 기반 이벤트 우선순위를 처리합니다.
  */
 
 var WoongCanvasProvider = function (_a) {
   var children = _a.children;
-  var controller = MintMapProvider.useMintMapController(); // Refs
-
+  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 기준으로 내림차순 정렬합니다.
-   * 높은 zIndex를 가진 컴포넌트가 이벤트 처리에서 우선순위를 가집니다.
-   *
-   * @template T 마커/폴리곤 데이터의 추가 속성 타입
-   * @param instance 등록할 컴포넌트 인스턴스
-   */
+  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;
     });
-  }, []);
-  /**
-   * 컴포넌트 등록 해제
-   *
-   * 컴포넌트 인스턴스를 등록 해제합니다.
-   * hover 중이던 컴포넌트면 hover 상태도 초기화합니다.
-   *
-   * @template T 마커/폴리곤 데이터의 추가 속성 타입
-   * @param instance 등록 해제할 컴포넌트 인스턴스
-   */
+  }, []); // 컴포넌트 등록 해제
 
   var unregisterComponent = React.useCallback(function (instance) {
-    // Hover 중이던 컴포넌트면 초기화
     if (currentHoveredRef.current === instance) {
       currentHoveredRef.current = null;
       currentHoveredDataRef.current = null;
@@ -77,118 +40,77 @@ var WoongCanvasProvider = function (_a) {
     componentsRef.current = componentsRef.current.filter(function (c) {
       return c !== instance;
     });
-  }, []);
-  /**
-   * 전역 클릭 핸들러 (zIndex 우선순위)
-   *
-   * 모든 등록된 WoongCanvas 컴포넌트 중 zIndex가 높은 컴포넌트부터 클릭 이벤트를 처리합니다.
-   *
-   * @param event 클릭 이벤트 파라미터
-   *
-   * @remarks
-   * - zIndex가 높은 컴포넌트부터 순회하여 첫 번째 히트만 처리
-   * - 상호작용이 비활성화된 컴포넌트는 스킵
-   * - Context가 없으면 각 컴포넌트의 로컬 핸들러가 처리
-   */
+  }, []); // 전역 클릭 핸들러 (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 순서대로 순회 (높은 것부터)
-
-    for (var _i = 0, _b = componentsRef.current; _i < _b.length; _i++) {
-      var component = _b[_i]; // 🚫 상호작용이 비활성화된 컴포넌트는 스킵
+    var clickedOffset = controller.positionToOffset(event.param.position); // zIndex 내림차순으로 정렬된 컴포넌트 순회 (높은 zIndex가 먼저 처리)
 
+    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 우선순위)
-   *
-   * 모든 등록된 WoongCanvas 컴포넌트 중 zIndex가 높은 컴포넌트부터 hover 이벤트를 처리합니다.
-   *
-   * @param event 마우스 이동 이벤트 파라미터
-   *
-   * @remarks
-   * - zIndex가 높은 컴포넌트부터 순회하여 첫 번째 히트만 처리
-   * - 상호작용이 비활성화된 컴포넌트는 스킵
-   * - 드래그 중이면 이벤트 무시 (성능 최적화)
-   * - hover 상태 변경 감지 후 이전 hover 해제 및 새 hover 설정
-   */
+  }, [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]; // 🚫 상호작용이 비활성화된 컴포넌트는 스킵
-
+      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 이벤트 발생
+
+
+    if (newHoveredComponent && newHoveredData) {
+      newHoveredComponent.setHovered(newHoveredData);
 
-      currentHoveredRef.current = newHoveredComponent;
-      currentHoveredDataRef.current = 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);
@@ -200,8 +122,7 @@ var WoongCanvasProvider = 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,
@@ -215,26 +136,11 @@ var WoongCanvasProvider = function (_a) {
 /**
  * WoongCanvas Context Hook
  *
- * WoongCanvasProvider로 감싸진 컴포넌트에서 Context에 접근할 수 있는 hook입니다.
- *
  * @returns WoongCanvasContextValue 또는 null (Provider 없으면)
- *
- * @remarks
- * - Provider로 감싸지지 않으면 null 반환 (각 컴포넌트가 로컬 이벤트 처리)
- * - Provider로 감싸져 있으면 전역 이벤트 조정 활성화
- *
- * @example
- * ```typescript
- * const context = useWoongCanvasContext();
- * if (context) {
- *   // Context 사용 중 (전역 이벤트 조정)
- * }
- * ```
  */
 
 var useWoongCanvasContext = function () {
-  var context = React.useContext(WoongCanvasContext);
-  return context;
+  return React.useContext(WoongCanvasContext);
 };
 
 exports.WoongCanvasProvider = WoongCanvasProvider;

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

@@ -2,27 +2,19 @@ import { EventParam, MapUIEventParam } from "../../../types";
 import type { MintMapController } from "../../MintMapController";
 import type { Offset } from "../../../types";
 /**
- * 이벤트 유효성 검증 헬퍼
+ * 이벤트 유효성 검증 및 좌표 변환
  *
  * @param event 이벤트 파라미터
- * @param context Context가 있는지 여부
+ * @param context WoongCanvasContext 인스턴스
  * @param controller MintMapController 인스턴스
- * @returns 유효한 offset 또는 null
- *
- * @remarks
- * Context가 있으면 전역 이벤트 핸들러가 처리하므로 로컬 핸들러는 스킵
+ * @returns 유효한 화면 좌표 또는 null
  */
 export declare const validateEvent: (event: EventParam<MapUIEventParam> | null | undefined, context: any, controller: MintMapController) => Offset | null;
 /**
- * Map의 values를 배열로 변환 (최적화 버전)
+ * Map의 values를 배열로 변환
  *
+ * @template T Map 값의 타입
  * @param map 변환할 Map
  * @returns Map의 값 배열
- *
- * @remarks
- * Map.values()는 IterableIterator를 반환하므로 배열 변환이 필요할 때 사용합니다.
- * 성능: O(n) 시간복잡도
- *
- * 최적화: Array.from을 사용하되, 크기를 미리 할당하여 메모리 재할당 최소화
  */
 export declare const mapValuesToArray: <T>(map: Map<string, T>) => T[];

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

@@ -3,22 +3,17 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 /**
- * 이벤트 유효성 검증 헬퍼
+ * 이벤트 유효성 검증 및 좌표 변환
  *
  * @param event 이벤트 파라미터
- * @param context Context가 있는지 여부
+ * @param context WoongCanvasContext 인스턴스
  * @param controller MintMapController 인스턴스
- * @returns 유효한 offset 또는 null
- *
- * @remarks
- * Context가 있으면 전역 이벤트 핸들러가 처리하므로 로컬 핸들러는 스킵
+ * @returns 유효한 화면 좌표 또는 null
  */
 var validateEvent = function (event, context, controller) {
-  var _a; // Context가 있으면 전역 핸들러가 처리
-
-
-  if (context) return null; // 이벤트 파라미터 검증
+  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 {
@@ -29,22 +24,15 @@ var validateEvent = function (event, context, controller) {
   }
 };
 /**
- * Map의 values를 배열로 변환 (최적화 버전)
+ * Map의 values를 배열로 변환
  *
+ * @template T Map 값의 타입
  * @param map 변환할 Map
  * @returns Map의 값 배열
- *
- * @remarks
- * Map.values()는 IterableIterator를 반환하므로 배열 변환이 필요할 때 사용합니다.
- * 성능: O(n) 시간복잡도
- *
- * 최적화: Array.from을 사용하되, 크기를 미리 할당하여 메모리 재할당 최소화
  */
 
 var mapValuesToArray = function (map) {
-  // Map이 비어있으면 빈 배열 반환 (메모리 할당 최소화)
-  if (map.size === 0) return []; // Array.from 사용 (TypeScript 컴파일러 호환성)
-
+  if (map.size === 0) return [];
   return Array.from(map.values());
 };
 

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

@@ -1,7 +1,7 @@
 import { MutableRefObject } from "react";
 import type { MintMapController } from "../../MintMapController";
 import type { Marker, MarkerOptions } from "../../../types";
-import type { KonvaCanvasData } from "./types";
+import type { CanvasData } from "./types";
 import type { BoundingBox } from "./viewport";
 import type { SpatialHashGrid } from "./performance";
 /**
@@ -32,33 +32,9 @@ export interface EventHandlerDeps<T> {
 /**
  * 지도 이벤트 핸들러 생성 함수
  *
- * 지도 이동, 줌, 드래그 등의 이벤트를 처리하는 핸들러들을 생성합니다.
- *
  * @template T 마커/폴리곤 데이터의 추가 속성 타입
  * @param deps 이벤트 핸들러 생성에 필요한 의존성
  * @returns 지도 이벤트 핸들러 객체
- *
- * @example
- * ```typescript
- * const {
- *   handleIdle,
- *   handleZoomStart,
- *   handleZoomEnd,
- *   handleCenterChanged,
- *   handleDragStart,
- *   handleDragEnd,
- * } = createMapEventHandlers({
- *   controller,
- *   containerRef,
- *   markerRef,
- *   options,
- *   prevCenterOffsetRef,
- *   accumTranslateRef,
- *   offsetCacheRef,
- *   boundingBoxCacheRef,
- *   renderAllImmediate,
- * });
- * ```
  */
 export declare const createMapEventHandlers: <T>(deps: EventHandlerDeps<T>) => {
     handleIdle: () => void;
@@ -71,74 +47,28 @@ export declare const createMapEventHandlers: <T>(deps: EventHandlerDeps<T>) => {
 /**
  * 공간 인덱스 빌드 (빠른 Hit Test를 위한 자료구조)
  *
- * Spatial Hash Grid에 모든 데이터의 바운딩 박스를 삽입합니다.
- * 이를 통해 클릭/호버 시 O(1) 수준의 빠른 Hit Test가 가능합니다.
- *
  * @template T 마커/폴리곤 데이터의 추가 속성 타입
  * @param data 공간 인덱스에 삽입할 데이터 배열
  * @param spatialIndex Spatial Hash Grid 인스턴스
  * @param computeBoundingBox 바운딩 박스 계산 함수
- *
- * @remarks
- * - 성능: O(n) 시간복잡도, n은 데이터 개수
- * - 호출 시점: 데이터 변경 시 또는 지도 이동/줌 완료 시
- *
- * @example
- * ```typescript
- * buildSpatialIndex(
- *   dataRef.current,
- *   spatialIndexRef.current,
- *   computeBoundingBox
- * );
- * ```
  */
-export declare const buildSpatialIndex: <T>(data: KonvaCanvasData<T>[], spatialIndex: SpatialHashGrid<KonvaCanvasData<T>>, computeBoundingBox: (item: KonvaCanvasData<T>) => BoundingBox | null) => void;
+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
- *
- * @remarks
- * - 성능: O(n + m), n은 전체 데이터 수, m은 선택된 항목 수
- * - 화면 밖 데이터도 선택 상태 유지 (최신 데이터가 없으면 기존 데이터 유지)
- *
- * @example
- * ```typescript
- * selectedItemsMapRef.current = syncSelectedItems(
- *   data,
- *   selectedIdsRef.current,
- *   selectedItemsMapRef.current
- * );
- * ```
  */
-export declare const syncSelectedItems: <T>(data: KonvaCanvasData<T>[], selectedIds: Set<string>, selectedItemsMap: Map<string, KonvaCanvasData<T>>) => Map<string, KonvaCanvasData<T>>;
+export declare const syncSelectedItems: <T>(data: CanvasData<T>[], selectedIds: Set<string>, selectedItemsMap: Map<string, CanvasData<T>>) => Map<string, CanvasData<T>>;
 /**
  * 외부 selectedItems를 내부 상태로 동기화
  *
- * 외부에서 전달된 selectedItems prop을 내부 ref 상태로 동기화합니다.
- *
  * @template T 마커/폴리곤 데이터의 추가 속성 타입
- * @param externalSelectedItems 외부에서 전달된 선택된 항목 배열 (undefined면 동기화 안 함)
+ * @param externalSelectedItems 외부에서 전달된 선택된 항목 배열
  * @param selectedIdsRef 선택된 ID Set ref
  * @param selectedItemsMapRef 선택된 항목 Map ref
- *
- * @remarks
- * - externalSelectedItems가 undefined면 외부 제어가 아니므로 아무 작업도 하지 않음
- * - 성능: O(m), m은 externalSelectedItems의 길이
- *
- * @example
- * ```typescript
- * useEffect(() => {
- *   syncExternalSelectedItems(externalSelectedItems, selectedIdsRef, selectedItemsMapRef);
- *   // 렌더링...
- * }, [externalSelectedItems]);
- * ```
  */
-export declare const syncExternalSelectedItems: <T>(externalSelectedItems: KonvaCanvasData<T>[] | undefined, selectedIdsRef: MutableRefObject<Set<string>>, selectedItemsMapRef: MutableRefObject<Map<string, KonvaCanvasData<T>>>) => void;
+export declare const syncExternalSelectedItems: <T>(externalSelectedItems: CanvasData<T>[] | undefined, selectedIdsRef: MutableRefObject<Set<string>>, selectedItemsMapRef: MutableRefObject<Map<string, CanvasData<T>>>) => void;