@mint-ui/map 1.2.0-test.30 → 1.2.0-test.32

package/dist/index.umd.js

@@ -996,8 +996,8 @@
     return Math.max(minWidth, textWidth + padding);
   };
 
-  var KonvaMarkerContext = React.createContext(null);
-  var KonvaMarkerProvider = function (_a) {
+  var WoongCanvasContext = React.createContext(null);
+  var WoongCanvasProvider = function (_a) {
     var children = _a.children;
     var controller = useMintMapController(); // Refs
 
@@ -1142,12 +1142,12 @@
         unregisterComponent: unregisterComponent
       };
     }, [registerComponent, unregisterComponent]);
-    return React__default["default"].createElement(KonvaMarkerContext.Provider, {
+    return React__default["default"].createElement(WoongCanvasContext.Provider, {
       value: contextValue
     }, children);
   };
-  var useKonvaMarkerContext = function () {
-    var context = React.useContext(KonvaMarkerContext);
+  var useWoongCanvasContext = function () {
+    var context = React.useContext(WoongCanvasContext);
     return context;
   };
 
@@ -1229,7 +1229,7 @@
      * - 장점: 읽기 성능 대폭 향상 (10,000번 get → 이전보다 2배 빠름)
      * - 단점: 접근 빈도가 아닌 삽입 순서 기반 eviction (FIFO)
      *
-     * WoongKonvaMarker 사용 사례에 최적:
+     * WoongCanvasMarker 사용 사례에 최적:
      * - 좌표 변환 결과는 zoom/pan 시 어차피 전체 초기화
      * - 접근 빈도 추적보다 빠른 조회가 더 중요
      */
@@ -1567,7 +1567,7 @@
     }, [center]);
     return React__default["default"].createElement("div", {
       className: cn$3('mint-map-root')
-    }, mapInitialized && React__default["default"].createElement(KonvaMarkerProvider, null, children), React__default["default"].createElement("div", {
+    }, mapInitialized && React__default["default"].createElement(WoongCanvasProvider, null, children), React__default["default"].createElement("div", {
       className: cn$3('mint-map-container'),
       style: {
         visibility: visible ? 'inherit' : 'hidden'
@@ -5425,239 +5425,11 @@
     }))));
   }
 
-  /**
-   * 폴리곤 렌더링 유틸리티
-   *
-   * 이 파일은 폴리곤 렌더링을 위한 헬퍼 함수와 팩토리 함수를 제공합니다.
-   */
-
-  /**
-   * 폴리곤 그리기 헬퍼 함수 (도넛 폴리곤 지원)
-   */
-  var drawPolygon = function (_a) {
-    var ctx = _a.ctx,
-        polygonOffsets = _a.polygonOffsets,
-        isDonutPolygon = _a.isDonutPolygon,
-        fillColor = _a.fillColor,
-        strokeColor = _a.strokeColor,
-        lineWidth = _a.lineWidth;
-
-    for (var _i = 0, polygonOffsets_1 = polygonOffsets; _i < polygonOffsets_1.length; _i++) {
-      var multiPolygon = polygonOffsets_1[_i];
-
-      if (isDonutPolygon) {
-        ctx.beginPath(); // 1. 외부 폴리곤 그리기
-
-        if (multiPolygon[0] && multiPolygon[0].length > 0) {
-          ctx.moveTo(multiPolygon[0][0][0], multiPolygon[0][0][1]);
-
-          for (var i = 1; i < multiPolygon[0].length; i++) {
-            ctx.lineTo(multiPolygon[0][i][0], multiPolygon[0][i][1]);
-          }
-
-          ctx.closePath();
-        } // 2. 내부 폴리곤 (구멍들) 그리기 - 같은 path에 추가
-
-
-        for (var j = 1; j < multiPolygon.length; j++) {
-          var innerPolygon = multiPolygon[j];
-          if (innerPolygon.length === 0) continue;
-          ctx.moveTo(innerPolygon[0][0], innerPolygon[0][1]);
-
-          for (var i = 1; i < innerPolygon.length; i++) {
-            ctx.lineTo(innerPolygon[i][0], innerPolygon[i][1]);
-          }
-
-          ctx.closePath();
-        } // 3. evenodd fill rule로 구멍 뚫기
-
-
-        ctx.fillStyle = fillColor;
-        ctx.fill('evenodd'); // 4. 외곽선 그리기
-
-        ctx.strokeStyle = strokeColor;
-        ctx.lineWidth = lineWidth;
-        ctx.stroke();
-      } else {
-        // 일반 폴리곤
-        for (var _b = 0, multiPolygon_1 = multiPolygon; _b < multiPolygon_1.length; _b++) {
-          var polygonGroup = multiPolygon_1[_b];
-          if (!polygonGroup.length) continue;
-          ctx.beginPath();
-          var firstPoint = polygonGroup[0];
-          ctx.moveTo(firstPoint[0], firstPoint[1]);
-
-          for (var i = 1; i < polygonGroup.length; i++) {
-            var point = polygonGroup[i];
-            ctx.lineTo(point[0], point[1]);
-          }
-
-          ctx.closePath();
-          ctx.fillStyle = fillColor;
-          ctx.strokeStyle = strokeColor;
-          ctx.lineWidth = lineWidth;
-          ctx.fill();
-          ctx.stroke();
-        }
-      }
-    }
-  };
-  /**
-   * 폴리곤 Base 렌더링 함수
-   *
-   * @param baseFillColor 기본 폴리곤 채우기 색상
-   * @param baseStrokeColor 기본 폴리곤 테두리 색상
-   * @param baseLineWidth 기본 폴리곤 테두리 두께
-   * @returns Base Layer 렌더링 함수
-   *
-   * @example
-   * const renderBase = renderPolygonBase(
-   *   'rgba(255, 100, 100, 0.5)',
-   *   'rgba(200, 50, 50, 0.8)',
-   *   2
-   * );
-   */
-
-  var renderPolygonBase = function (baseFillColor, baseStrokeColor, baseLineWidth) {
-    return function (_a) {
-      var ctx = _a.ctx,
-          items = _a.items,
-          selectedIds = _a.selectedIds,
-          utils = _a.utils;
-
-      for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
-        var item = items_1[_i]; // 선택된 항목은 Event Layer에서 그림
-
-        if (selectedIds.has(item.id)) continue;
-        if (!item.paths) continue;
-        var polygonOffsets = utils.getOrComputePolygonOffsets(item);
-        if (!polygonOffsets) continue;
-        drawPolygon({
-          ctx: ctx,
-          polygonOffsets: polygonOffsets,
-          isDonutPolygon: item.isDonutPolygon || false,
-          fillColor: baseFillColor,
-          strokeColor: baseStrokeColor,
-          lineWidth: baseLineWidth
-        });
-      }
-    };
-  };
-  /**
-   * 폴리곤 Event 렌더링 함수
-   *
-   * @param baseFillColor 기본 폴리곤 채우기 색상 (필수, fallback용)
-   * @param baseStrokeColor 기본 폴리곤 테두리 색상 (필수, fallback용)
-   * @param baseLineWidth 기본 폴리곤 테두리 두께 (필수, fallback용)
-   * @param selectedFillColor 선택된 폴리곤 채우기 색상 (선택, 기본값: baseFillColor)
-   * @param selectedStrokeColor 선택된 폴리곤 테두리 색상 (선택, 기본값: baseStrokeColor)
-   * @param selectedLineWidth 선택된 폴리곤 테두리 두께 (선택, 기본값: baseLineWidth)
-   * @param activeFillColor 마지막 선택된 폴리곤 채우기 색상 (선택, 기본값: selectedFillColor)
-   * @param activeStrokeColor 마지막 선택된 폴리곤 테두리 색상 (선택, 기본값: selectedStrokeColor)
-   * @param activeLineWidth 마지막 선택된 폴리곤 테두리 두께 (선택, 기본값: selectedLineWidth)
-   * @param hoveredFillColor Hover 시 폴리곤 채우기 색상 (선택, 기본값: selectedFillColor)
-   * @param hoveredStrokeColor Hover 시 폴리곤 테두리 색상 (선택, 기본값: selectedStrokeColor)
-   * @param hoveredLineWidth Hover 시 폴리곤 테두리 두께 (선택, 기본값: selectedLineWidth)
-   * @returns Event Layer 렌더링 함수
-   *
-   * @example
-   * const renderEvent = renderPolygonEvent(
-   *   'rgba(255, 100, 100, 0.5)',  // baseFillColor
-   *   'rgba(200, 50, 50, 0.8)',    // baseStrokeColor
-   *   2,                            // baseLineWidth
-   *   'rgba(255, 193, 7, 0.7)',    // selectedFillColor
-   *   'rgba(255, 152, 0, 1)',      // selectedStrokeColor
-   *   4                             // selectedLineWidth
-   * );
-   */
-
-  var renderPolygonEvent = function (baseFillColor, baseStrokeColor, baseLineWidth, selectedFillColor, selectedStrokeColor, selectedLineWidth, activeFillColor, activeStrokeColor, activeLineWidth, hoveredFillColor, hoveredStrokeColor, hoveredLineWidth) {
-    // 기본값 설정 (base 기준)
-    var _selectedFillColor = selectedFillColor || baseFillColor;
-
-    var _selectedStrokeColor = selectedStrokeColor || baseStrokeColor;
-
-    var _selectedLineWidth = selectedLineWidth || baseLineWidth;
-
-    var _activeFillColor = activeFillColor || _selectedFillColor;
-
-    var _activeStrokeColor = activeStrokeColor || _selectedStrokeColor;
-
-    var _activeLineWidth = activeLineWidth || _selectedLineWidth;
-
-    var _hoveredFillColor = hoveredFillColor || _selectedFillColor;
-
-    var _hoveredStrokeColor = hoveredStrokeColor || _selectedStrokeColor;
-
-    var _hoveredLineWidth = hoveredLineWidth || _selectedLineWidth;
-
-    return function (_a) {
-      var ctx = _a.ctx,
-          hoveredItem = _a.hoveredItem,
-          utils = _a.utils,
-          selectedItems = _a.selectedItems,
-          selectedItem = _a.selectedItem; // 1. 선택된 항목들 그리기 (마지막 선택 항목과 호버된 항목 제외)
-
-      if (selectedItems === null || selectedItems === void 0 ? void 0 : selectedItems.length) {
-        for (var _i = 0, selectedItems_1 = selectedItems; _i < selectedItems_1.length; _i++) {
-          var item = selectedItems_1[_i]; // 마지막 선택 항목과 호버된 항목은 나중에 따로 그림
-
-          if (item.id === (selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id) || (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.id) === item.id) continue;
-          if (!item.paths) continue;
-          var polygonOffsets = utils.getOrComputePolygonOffsets(item);
-          if (!polygonOffsets) continue;
-          drawPolygon({
-            ctx: ctx,
-            polygonOffsets: polygonOffsets,
-            isDonutPolygon: item.isDonutPolygon || false,
-            fillColor: _selectedFillColor,
-            strokeColor: _selectedStrokeColor,
-            lineWidth: _selectedLineWidth
-          });
-        }
-      } // 2. 마지막 선택된 항목 그리기 (호버되지 않은 경우)
-
-
-      if ((selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.paths) && (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.id) !== selectedItem.id) {
-        var polygonOffsets = utils.getOrComputePolygonOffsets(selectedItem);
-
-        if (polygonOffsets) {
-          drawPolygon({
-            ctx: ctx,
-            polygonOffsets: polygonOffsets,
-            isDonutPolygon: selectedItem.isDonutPolygon || false,
-            fillColor: _activeFillColor,
-            strokeColor: _activeStrokeColor,
-            lineWidth: _activeLineWidth
-          });
-        }
-      } // 3. 호버된 항목 그리기 (가장 위에 표시)
-
-
-      if (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.paths) {
-        var polygonOffsets = utils.getOrComputePolygonOffsets(hoveredItem);
-        if (!polygonOffsets) return;
-        var isSelected = selectedItems === null || selectedItems === void 0 ? void 0 : selectedItems.some(function (item) {
-          return item.id === hoveredItem.id;
-        });
-        drawPolygon({
-          ctx: ctx,
-          polygonOffsets: polygonOffsets,
-          isDonutPolygon: hoveredItem.isDonutPolygon || false,
-          fillColor: isSelected ? _activeFillColor : _hoveredFillColor,
-          strokeColor: isSelected ? _activeStrokeColor : _hoveredStrokeColor,
-          lineWidth: isSelected ? _activeLineWidth : _hoveredLineWidth
-        });
-      }
-    };
-  };
-
   // 메인 컴포넌트
   // ============================================================================
 
-  var WoongCanvasLayer = function (props) {
+  var WoongCanvasMarker = function (props) {
     var data = props.data,
-        dataType = props.dataType,
         onClick = props.onClick,
         onMouseOver = props.onMouseOver,
         onMouseOut = props.onMouseOut,
@@ -5675,13 +5447,16 @@
         externalSelectedItem = props.selectedItem,
         _f = props.disableInteraction,
         disableInteraction = _f === void 0 ? false : _f,
-        options = tslib.__rest(props, ["data", "dataType", "onClick", "onMouseOver", "onMouseOut", "enableMultiSelect", "topOnHover", "enableViewportCulling", "cullingMargin", "maxCacheSize", "selectedItems", "selectedItem", "disableInteraction"]); // --------------------------------------------------------------------------
+        renderBase = props.renderBase,
+        renderAnimation = props.renderAnimation,
+        renderEvent = props.renderEvent,
+        options = tslib.__rest(props, ["data", "onClick", "onMouseOver", "onMouseOut", "enableMultiSelect", "topOnHover", "enableViewportCulling", "cullingMargin", "maxCacheSize", "selectedItems", "selectedItem", "disableInteraction", "renderBase", "renderAnimation", "renderEvent"]); // --------------------------------------------------------------------------
     // Hooks & Context
     // --------------------------------------------------------------------------
 
 
     var controller = useMintMapController();
-    var context = useKonvaMarkerContext();
+    var context = useWoongCanvasContext();
     var currentZIndex = options.zIndex !== undefined ? options.zIndex : 0; // --------------------------------------------------------------------------
     // DOM Refs
     // --------------------------------------------------------------------------
@@ -5810,24 +5585,6 @@
     // 유틸리티 함수: 좌표 변환 캐싱
     // --------------------------------------------------------------------------
 
-    /**
-     * 폴리곤 좌표 변환 결과를 캐시하고 반환
-     * @param polygonData 폴리곤 데이터
-     * @returns 변환된 좌표 배열 또는 null
-     */
-
-
-    var getOrComputePolygonOffsets = function (polygonData) {
-      var cached = offsetCacheRef.current.get(polygonData.id);
-      if (cached && Array.isArray(cached)) return cached;
-      var result = computePolygonOffsets(polygonData, controller);
-
-      if (result) {
-        offsetCacheRef.current.set(polygonData.id, result);
-      }
-
-      return result;
-    };
     /**
      * 마커 좌표 변환 결과를 캐시하고 반환
      *
@@ -5851,66 +5608,31 @@
     // --------------------------------------------------------------------------
 
     /**
-     * 아이템의 바운딩 박스 계산 (폴리곤/마커 공통)
+     * 마커의 바운딩 박스 계산
      *
      * 🎯 마커의 경우:
      * - boxHeight: 본체만 (Hit Test 영역)
      * - tailHeight: 꼬리 높이 (Viewport Culling용, 화면에 보이는 전체 영역)
      *
-     * @param item 마커 또는 폴리곤 데이터
+     * @param item 마커 데이터
      * @returns 바운딩 박스 또는 null
      */
 
 
     var computeBoundingBox = function (item) {
-      if (dataType === exports.CanvasDataType.POLYGON) {
-        // 폴리곤: 모든 좌표의 최소/최대값 계산
-        var offsets = getOrComputePolygonOffsets(item);
-        if (!offsets) return null;
-        var minX = Infinity,
-            minY = Infinity,
-            maxX = -Infinity,
-            maxY = -Infinity;
-
-        for (var _i = 0, offsets_1 = offsets; _i < offsets_1.length; _i++) {
-          var multiPolygon = offsets_1[_i];
-
-          for (var _a = 0, multiPolygon_1 = multiPolygon; _a < multiPolygon_1.length; _a++) {
-            var polygonGroup = multiPolygon_1[_a];
-
-            for (var _b = 0, polygonGroup_1 = polygonGroup; _b < polygonGroup_1.length; _b++) {
-              var _c = polygonGroup_1[_b],
-                  x = _c[0],
-                  y = _c[1];
-              if (x < minX) minX = x;
-              if (y < minY) minY = y;
-              if (x > maxX) maxX = x;
-              if (y > maxY) maxY = y;
-            }
-          }
-        }
+      // 마커: 중심점 기준 박스 크기 계산 (꼬리 포함)
+      var offset = getOrComputeMarkerOffset(item);
+      if (!offset) return null;
+      var boxWidth = item.boxWidth || 50;
+      var boxHeight = item.boxHeight || 28;
+      var tailHeight = item.tailHeight || 0; // 🎯 tailHeight 사용 (Viewport Culling용)
 
-        return {
-          minX: minX,
-          minY: minY,
-          maxX: maxX,
-          maxY: maxY
-        };
-      } else {
-        // 마커: 중심점 기준 박스 크기 계산 (꼬리 포함)
-        var offset = getOrComputeMarkerOffset(item);
-        if (!offset) return null;
-        var boxWidth = item.boxWidth || 50;
-        var boxHeight = item.boxHeight || 28;
-        var tailHeight = item.tailHeight || 0; // 🎯 tailHeight 사용 (Viewport Culling용)
-
-        return {
-          minX: offset.x - boxWidth / 2,
-          minY: offset.y - boxHeight - tailHeight,
-          maxX: offset.x + boxWidth / 2,
-          maxY: offset.y
-        };
-      }
+      return {
+        minX: offset.x - boxWidth / 2,
+        minY: offset.y - boxHeight - tailHeight,
+        maxX: offset.x + boxWidth / 2,
+        maxY: offset.y
+      };
     }; // --------------------------------------------------------------------------
     // 유틸리티 함수: 공간 인덱싱
     // --------------------------------------------------------------------------
@@ -5944,24 +5666,14 @@
 
 
     var renderUtils = {
-      getOrComputePolygonOffsets: getOrComputePolygonOffsets,
+      getOrComputePolygonOffsets: function () {
+        return null;
+      },
       getOrComputeMarkerOffset: getOrComputeMarkerOffset
     };
     /** Base Layer에서 사용할 빈 Set (재사용) */
 
     React.useRef(new Set());
-    /**
-     * 실제 사용할 렌더링 함수 결정
-     * - MARKER: 외부에서 전달받은 renderBase 사용 (필수)
-     * - POLYGON: renderer.ts의 팩토리 함수로 생성 (props 기반)
-     */
-
-    var renderBase = dataType === exports.CanvasDataType.MARKER ? props.renderBase : renderPolygonBase(props.baseFillColor, props.baseStrokeColor, props.baseLineWidth);
-    var renderAnimation = dataType === exports.CanvasDataType.MARKER ? props.renderAnimation : undefined;
-    var renderEvent = dataType === exports.CanvasDataType.MARKER ? props.renderEvent : function () {
-      var polygonProps = props;
-      return renderPolygonEvent(polygonProps.baseFillColor, polygonProps.baseStrokeColor, polygonProps.baseLineWidth, polygonProps.selectedFillColor, polygonProps.selectedStrokeColor, polygonProps.selectedLineWidth, polygonProps.activeFillColor, polygonProps.activeStrokeColor, polygonProps.activeLineWidth, polygonProps.hoveredFillColor, polygonProps.hoveredStrokeColor, polygonProps.hoveredLineWidth);
-    }();
     /**
      * Base 레이어 렌더링 (뷰포트 컬링 적용, 선택된 마커 제외)
      *
@@ -6006,6 +5718,7 @@
               ctx: ctx,
               items: visibleItems,
               selectedIds: selectedIdsRef.current,
+              hoveredItem: hovered,
               utils: renderUtils
             }); // hover된 항목을 최상단에 렌더링 (renderEvent가 없을 때만)
 
@@ -6017,6 +5730,7 @@
                   ctx: ctx,
                   items: [hovered],
                   selectedIds: selectedIdsRef.current,
+                  hoveredItem: hovered,
                   utils: renderUtils
                 });
               }
@@ -6233,54 +5947,35 @@
     // --------------------------------------------------------------------------
 
     /**
-     * 특정 좌표의 마커/폴리곤 데이터 찾기 (Spatial Index 사용)
+     * 특정 좌표의 마커 데이터 찾기 (Spatial Index 사용)
      *
      * topOnHover가 true일 때:
      * - 현재 hover된 항목을 최우선으로 체크
      * - 시각적으로 최상단에 있는 항목이 hit test에서도 우선됨
      *
      * @param offset 검사할 좌표
-     * @returns 찾은 마커/폴리곤 데이터 또는 null
+     * @returns 찾은 마커 데이터 또는 null
      */
 
 
     var findData = function (offset) {
       // topOnHover가 true이고 현재 hover된 항목이 있으면, 그것을 먼저 체크
       if (topOnHover && hoveredItemRef.current) {
-        var hovered = hoveredItemRef.current; // 폴리곤인 경우
+        var hovered = hoveredItemRef.current;
 
-        if (dataType === exports.CanvasDataType.POLYGON) {
-          if (isPointInPolygonData(offset, hovered, getOrComputePolygonOffsets)) {
-            return hovered; // 여전히 hover된 항목 위에 있음
-          }
-        } // 마커인 경우
-        else {
-          if (isPointInMarkerData(offset, hovered, getOrComputeMarkerOffset)) {
-            return hovered; // 여전히 hover된 항목 위에 있음
-          }
+        if (isPointInMarkerData(offset, hovered, getOrComputeMarkerOffset)) {
+          return hovered; // 여전히 hover된 항목 위에 있음
         }
       } // Spatial Index로 후보 항목만 빠르게 추출 (30,000개 → ~10개)
 
 
-      var candidates = spatialIndexRef.current.queryPoint(offset.x, offset.y); // 데이터 타입에 따라 적절한 히트 테스트 수행
-
-      if (dataType === exports.CanvasDataType.MARKER) {
-        // 마커 체크
-        for (var i = candidates.length - 1; i >= 0; i--) {
-          var item = candidates[i];
+      var candidates = spatialIndexRef.current.queryPoint(offset.x, offset.y); // 마커 체크
 
-          if (isPointInMarkerData(offset, item, getOrComputeMarkerOffset)) {
-            return item;
-          }
-        }
-      } else {
-        // 폴리곤 체크
-        for (var i = candidates.length - 1; i >= 0; i--) {
-          var item = candidates[i];
+      for (var i = candidates.length - 1; i >= 0; i--) {
+        var item = candidates[i];
 
-          if (isPointInPolygonData(offset, item, getOrComputePolygonOffsets)) {
-            return item;
-          }
+        if (isPointInMarkerData(offset, item, getOrComputeMarkerOffset)) {
+          return item;
         }
       }
 
@@ -6395,7 +6090,7 @@
           }
         }
       } catch (error) {
-        console.error('[WoongKonvaMarker] handleClick error:', error);
+        console.error('[WoongCanvasMarker] handleClick error:', error);
       }
     };
     /**
@@ -6421,7 +6116,7 @@
           if (hoveredItem && onMouseOver) onMouseOver(hoveredItem);
         }
       } catch (error) {
-        console.error('[WoongKonvaMarker] handleMouseMove error:', error);
+        console.error('[WoongCanvasMarker] handleMouseMove error:', error);
       }
     };
     /**
@@ -9577,7 +9272,6 @@
   exports.Drawable = Drawable;
   exports.GeoCalulator = GeoCalulator;
   exports.GoogleMintMapController = GoogleMintMapController;
-  exports.KonvaMarkerProvider = KonvaMarkerProvider;
   exports.LRUCache = LRUCache;
   exports.MapBuildingProjection = MapBuildingProjection;
   exports.MapCanvasMarkerWrapper = MapCanvasMarkerWrapper;
@@ -9610,7 +9304,9 @@
   exports.Spacing = Spacing;
   exports.SpatialHashGrid = SpatialHashGrid;
   exports.Status = Status;
-  exports.WoongCanvasLayer = WoongCanvasLayer;
+  exports.WoongCanvasLayer = WoongCanvasMarker;
+  exports.WoongCanvasMarker = WoongCanvasMarker;
+  exports.WoongCanvasProvider = WoongCanvasProvider;
   exports.calculateTextBoxWidth = calculateTextBoxWidth;
   exports.computeMarkerOffset = computeMarkerOffset;
   exports.computePolygonOffsets = computePolygonOffsets;
@@ -9621,9 +9317,9 @@
   exports.isPointInPolygon = isPointInPolygon;
   exports.isPointInPolygonData = isPointInPolygonData;
   exports.log = log;
-  exports.useKonvaMarkerContext = useKonvaMarkerContext;
   exports.useMarkerMoving = useMarkerMoving;
   exports.useMintMapController = useMintMapController;
+  exports.useWoongCanvasContext = useWoongCanvasContext;
   exports.waiting = waiting;
 
   Object.defineProperty(exports, '__esModule', { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mint-ui/map",
-  "version": "1.2.0-test.30",
+  "version": "1.2.0-test.32",
   "main": "./dist/index.js",
   "module": "./dist/index.es.js",
   "browser": "./dist/index.umd.js",