@mint-ui/map 1.2.0-test.8 → 1.2.0

package/dist/components/mint-map/core/advanced/CanvasPolygonLayer/renderer.js

@@ -0,0 +1,1091 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable no-restricted-syntax */
+
+/* eslint-disable no-continue */
+
+/* eslint-disable no-underscore-dangle */
+
+/**
+ * 폴리곤 렌더링 유틸리티
+ *
+ * 이 파일은 폴리곤 렌더링을 위한 헬퍼 함수와 팩토리 함수를 제공합니다.
+ * GeoJSON MultiPolygon 형식을 지원하며, 도넛 폴리곤(구멍이 있는 폴리곤)도 처리할 수 있습니다.
+ *
+ * 세 가지 스타일 지정 방식을 지원하는 렌더링 함수를 제공합니다:
+ * 1. 개별 props 방식: renderPolygonBase, renderPolygonEvent
+ * 2. 객체 방식: renderPolygonBaseWithObject, renderPolygonEventWithObject
+ * 3. 함수 방식: renderPolygonBaseWithCustomStyle, renderPolygonEventWithCustomStyle
+ */
+
+/**
+ * 폴리곤 그리기 헬퍼 함수 (도넛 폴리곤 지원)
+ *
+ * Canvas 2D Context를 사용하여 폴리곤을 그립니다.
+ * 도넛 폴리곤의 경우 evenodd fill rule을 사용하여 구멍을 처리합니다.
+ *
+ * @param params 폴리곤 그리기 파라미터
+ *
+ * @remarks
+ * - **도넛 폴리곤 처리**:
+ *   - 외부 폴리곤과 내부 구멍들을 같은 path에 추가
+ *   - `fill('evenodd')`를 사용하여 구멍 뚫기
+ * - **일반 폴리곤 처리**: 각 폴리곤 그룹을 개별적으로 그리기
+ * - **성능**: O(n), n은 폴리곤의 총 좌표 수
+ *
+ * @example
+ * ```typescript
+ * drawPolygon({
+ *   ctx,
+ *   polygonOffsets: [[[[100, 200], [200, 200], [200, 100], [100, 100]]]],
+ *   isDonutPolygon: false,
+ *   fillColor: 'rgba(255, 0, 0, 0.5)',
+ *   strokeColor: 'rgba(255, 0, 0, 1)',
+ *   lineWidth: 2
+ * });
+ * ```
+ */
+var drawPolygon = function (_a) {
+  var ctx = _a.ctx,
+      fillColor = _a.fillColor,
+      isDonutPolygon = _a.isDonutPolygon,
+      lineWidth = _a.lineWidth,
+      polygonOffsets = _a.polygonOffsets,
+      strokeColor = _a.strokeColor;
+
+  for (var _i = 0, polygonOffsets_1 = polygonOffsets; _i < polygonOffsets_1.length; _i++) {
+    var multiPolygon = polygonOffsets_1[_i];
+
+    if (isDonutPolygon) {
+      // 도넛 폴리곤 처리: 외부 폴리곤 + 내부 구멍들을 같은 path에 추가
+      ctx.beginPath(); // 1. 외부 폴리곤 그리기 (첫 번째 폴리곤)
+
+      var outerPolygon = multiPolygon[0];
+
+      if (outerPolygon && outerPolygon.length > 0) {
+        ctx.moveTo(outerPolygon[0][0], outerPolygon[0][1]);
+
+        for (var i = 1; i < outerPolygon.length; i++) {
+          ctx.lineTo(outerPolygon[i][0], outerPolygon[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 렌더링 함수 팩토리
+ *
+ * Base Layer에서 사용할 렌더링 함수를 생성합니다.
+ * 선택되지 않은 폴리곤만 렌더링하며, 선택된 항목은 Event Layer에서 처리됩니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param baseFillColor 기본 폴리곤 채우기 색상
+ * @param baseStrokeColor 기본 폴리곤 테두리 색상
+ * @param baseLineWidth 기본 폴리곤 테두리 두께
+ * @returns Base Layer 렌더링 함수
+ *
+ * @remarks
+ * - 선택된 항목은 Event Layer에서 그려지므로 Base Layer에서는 스킵
+ * - 성능: O(n), n은 렌더링할 폴리곤 개수
+ * - 좌표 변환은 자동으로 캐싱되어 성능 최적화됨
+ *
+ * @example
+ * ```typescript
+ * 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; // paths가 없으면 스킵
+
+      if (!item.paths) continue; // 좌표 변환 (자동 캐싱)
+
+      var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+      if (!polygonOffsets) continue; // 폴리곤 그리기
+
+      drawPolygon({
+        ctx: ctx,
+        fillColor: baseFillColor,
+        isDonutPolygon: item.isDonutPolygon || false,
+        lineWidth: baseLineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: baseStrokeColor
+      });
+    }
+  };
+};
+/**
+ * 폴리곤 Event 렌더링 함수 팩토리
+ *
+ * Event Layer에서 사용할 렌더링 함수를 생성합니다.
+ * 선택된 항목, hover된 항목, 마지막 선택된 항목을 각각 다른 스타일로 렌더링합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @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 렌더링 함수
+ *
+ * @remarks
+ * - **렌더링 순서**: 선택된 항목 → 마지막 선택된 항목 → hover된 항목 (최상단)
+ * - **성능**: O(m), m은 선택된 항목 수 + hover된 항목 수
+ * - 좌표 변환은 자동으로 캐싱되어 성능 최적화됨
+ * - hover된 항목이 선택되어 있으면 active 스타일 적용
+ *
+ * @example
+ * ```typescript
+ * 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,
+        selectedItem = _a.selectedItem,
+        selectedItems = _a.selectedItems,
+        utils = _a.utils; // 성능 최적화: selectedItems를 Set으로 변환하여 O(1) 조회 (매번 some() 체크 방지)
+
+    var selectedIdsSet = selectedItems ? new Set(selectedItems.map(function (item) {
+      return item.id;
+    })) : new Set();
+    var hoveredItemId = hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.id;
+    var selectedItemId = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id; // 1. 호버된 항목 그리기 (가장 위에 표시)
+
+    if (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.paths) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(hoveredItem); // 좌표 변환 실패 시 스킵 (return은 렌더링 함수 종료)
+
+      if (!polygonOffsets) return; // 성능 최적화: Set을 사용하여 O(1) 조회 (이전: O(m) some() 체크)
+
+      var isSelected = selectedIdsSet.has(hoveredItem.id);
+      drawPolygon({
+        ctx: ctx,
+        fillColor: isSelected ? _activeFillColor : _hoveredFillColor,
+        isDonutPolygon: hoveredItem.isDonutPolygon || false,
+        lineWidth: isSelected ? _activeLineWidth : _hoveredLineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: isSelected ? _activeStrokeColor : _hoveredStrokeColor
+      });
+    } // 2. 선택된 항목들 그리기 (마지막 선택 항목과 호버된 항목 제외)
+
+
+    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 === selectedItemId || item.id === hoveredItemId) continue;
+        if (!item.paths) continue;
+        var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+        if (!polygonOffsets) continue;
+        drawPolygon({
+          ctx: ctx,
+          fillColor: _selectedFillColor,
+          isDonutPolygon: item.isDonutPolygon || false,
+          lineWidth: _selectedLineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: _selectedStrokeColor
+        });
+      }
+    } // 3. 마지막 선택된 항목 그리기 (호버되지 않은 경우)
+
+
+    if ((selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.paths) && hoveredItemId !== selectedItemId) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(selectedItem);
+
+      if (polygonOffsets) {
+        drawPolygon({
+          ctx: ctx,
+          fillColor: _activeFillColor,
+          isDonutPolygon: selectedItem.isDonutPolygon || false,
+          lineWidth: _activeLineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: _activeStrokeColor
+        });
+      }
+    }
+  };
+};
+/**
+ * 폴리곤 Base 렌더링 함수 팩토리 (객체 방식)
+ *
+ * Base Layer에서 사용할 렌더링 함수를 생성합니다.
+ * renderStyle 객체를 사용하여 기본 스타일을 적용합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param renderStyle 폴리곤 스타일 객체
+ * @returns Base Layer 렌더링 함수
+ *
+ * @remarks
+ * - 선택된 항목은 Event Layer에서 그려지므로 Base Layer에서는 스킵
+ * - 성능: O(n), n은 렌더링할 폴리곤 개수
+ * - 좌표 변환은 자동으로 캐싱되어 성능 최적화됨
+ *
+ * @example
+ * ```typescript
+ * const renderBase = renderPolygonBaseWithObject<MyDataType>({
+ *   base: { fillColor: 'rgba(255, 100, 100, 0.5)', strokeColor: 'rgba(200, 50, 50, 0.8)', lineWidth: 2 }
+ * });
+ * ```
+ */
+
+var renderPolygonBaseWithObject = function (renderStyle) {
+  return function (_a) {
+    var ctx = _a.ctx,
+        items = _a.items,
+        selectedIds = _a.selectedIds,
+        utils = _a.utils;
+
+    for (var _i = 0, items_2 = items; _i < items_2.length; _i++) {
+      var item = items_2[_i]; // 선택된 항목은 Event Layer에서 그림 (중복 렌더링 방지)
+
+      if (selectedIds.has(item.id)) continue; // paths가 없으면 스킵
+
+      if (!item.paths) continue; // 좌표 변환 (자동 캐싱)
+
+      var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+      if (!polygonOffsets) continue; // Base Layer는 선택되지 않은 항목만 그리므로 base 스타일 사용
+
+      var style = renderStyle.base; // 폴리곤 그리기
+
+      drawPolygon({
+        ctx: ctx,
+        fillColor: style.fillColor,
+        isDonutPolygon: item.isDonutPolygon || false,
+        lineWidth: style.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: style.strokeColor
+      });
+    }
+  };
+};
+/**
+ * 폴리곤 Event 렌더링 함수 팩토리 (객체 방식)
+ *
+ * Event Layer에서 사용할 렌더링 함수를 생성합니다.
+ * renderStyle 객체를 사용하여 개별 props 방식과 동일한 알고리즘으로 스타일을 적용합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param renderStyle 폴리곤 스타일 객체
+ * @returns Event Layer 렌더링 함수
+ *
+ * @remarks
+ * - **렌더링 순서**: 선택된 항목 → 마지막 선택된 항목 → hover된 항목 (최상단)
+ * - **성능**: O(m), m은 선택된 항목 수 + hover된 항목 수
+ * - 좌표 변환은 자동으로 캐싱되어 성능 최적화됨
+ * - **알고리즘**: 개별 props 방식과 동일
+ *   - 기본값 설정: selected/active/hovered가 없으면 base 또는 상위 값 사용
+ *   - 선택된 항목: selected 스타일
+ *   - 마지막 선택된 항목 (호버 안 됨): active 스타일
+ *   - 호버된 항목: 선택되어 있으면 active, 아니면 hovered 스타일
+ *
+ * @example
+ * ```typescript
+ * const renderEvent = renderPolygonEventWithObject<MyDataType>({
+ *   base: { fillColor: 'rgba(255, 100, 100, 0.5)', strokeColor: 'rgba(200, 50, 50, 0.8)', lineWidth: 2 },
+ *   selected: { fillColor: 'rgba(255, 193, 7, 0.7)', strokeColor: 'rgba(255, 152, 0, 1)', lineWidth: 4 },
+ *   active: { fillColor: 'rgba(255, 152, 0, 0.8)', strokeColor: 'rgba(255, 87, 34, 1)', lineWidth: 5 },
+ *   hovered: { fillColor: 'rgba(100, 150, 255, 0.8)', strokeColor: 'rgba(0, 100, 200, 1)', lineWidth: 3 }
+ * });
+ * ```
+ */
+
+var renderPolygonEventWithObject = function (renderStyle) {
+  // 기본값 설정 (개별 props 방식과 동일한 로직)
+  var _selectedStyle = renderStyle.selected || renderStyle.base;
+
+  var _activeStyle = renderStyle.active || _selectedStyle;
+
+  var _hoveredStyle = renderStyle.hovered || _selectedStyle;
+
+  return function (_a) {
+    var ctx = _a.ctx,
+        hoveredItem = _a.hoveredItem,
+        selectedItem = _a.selectedItem,
+        selectedItems = _a.selectedItems,
+        utils = _a.utils; // 성능 최적화: selectedItems를 Set으로 변환하여 O(1) 조회 (매번 some() 체크 방지)
+
+    var selectedIdsSet = selectedItems ? new Set(selectedItems.map(function (item) {
+      return item.id;
+    })) : new Set();
+    var hoveredItemId = hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.id;
+    var selectedItemId = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id; // 1. 호버된 항목 그리기 (가장 위에 표시)
+
+    if (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.paths) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(hoveredItem); // 좌표 변환 실패 시 스킵 (return은 렌더링 함수 종료)
+
+      if (!polygonOffsets) return; // 성능 최적화: Set을 사용하여 O(1) 조회 (이전: O(m) some() 체크)
+
+      var isSelected = selectedIdsSet.has(hoveredItem.id);
+      drawPolygon({
+        ctx: ctx,
+        fillColor: isSelected ? _activeStyle.fillColor : _hoveredStyle.fillColor,
+        isDonutPolygon: hoveredItem.isDonutPolygon || false,
+        lineWidth: isSelected ? _activeStyle.lineWidth : _hoveredStyle.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: isSelected ? _activeStyle.strokeColor : _hoveredStyle.strokeColor
+      });
+    } // 2. 선택된 항목들 그리기 (마지막 선택 항목과 호버된 항목 제외)
+
+
+    if (selectedItems === null || selectedItems === void 0 ? void 0 : selectedItems.length) {
+      for (var _i = 0, selectedItems_2 = selectedItems; _i < selectedItems_2.length; _i++) {
+        var item = selectedItems_2[_i]; // 마지막 선택 항목과 호버된 항목은 나중에 따로 그림
+
+        if (item.id === selectedItemId || item.id === hoveredItemId) continue;
+        if (!item.paths) continue;
+        var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+        if (!polygonOffsets) continue;
+        drawPolygon({
+          ctx: ctx,
+          fillColor: _selectedStyle.fillColor,
+          isDonutPolygon: item.isDonutPolygon || false,
+          lineWidth: _selectedStyle.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: _selectedStyle.strokeColor
+        });
+      }
+    } // 3. 마지막 선택된 항목 그리기 (호버되지 않은 경우)
+
+
+    if ((selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.paths) && hoveredItemId !== selectedItemId) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(selectedItem);
+
+      if (polygonOffsets) {
+        drawPolygon({
+          ctx: ctx,
+          fillColor: _activeStyle.fillColor,
+          isDonutPolygon: selectedItem.isDonutPolygon || false,
+          lineWidth: _activeStyle.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: _activeStyle.strokeColor
+        });
+      }
+    }
+  };
+};
+/**
+ * 폴리곤 Base 렌더링 함수 팩토리 (커스터마이징 방식)
+ *
+ * Base Layer에서 사용할 렌더링 함수를 생성합니다.
+ * customStyle 함수를 사용하여 각 폴리곤의 스타일을 자유롭게 커스터마이징합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param customStyle 폴리곤 스타일 커스터마이징 함수
+ * @returns Base Layer 렌더링 함수
+ *
+ * @remarks
+ * - 선택된 항목은 Event Layer에서 그려지므로 Base Layer에서는 스킵
+ * - 성능: O(n), n은 렌더링할 폴리곤 개수
+ * - 좌표 변환은 자동으로 캐싱되어 성능 최적화됨
+ *
+ * @example
+ * ```typescript
+ * const renderBase = renderPolygonBaseWithCustomStyle<MyDataType>(
+ *   (item, context) => {
+ *     if (item.someProperty > 100) {
+ *       return { fillColor: 'red', strokeColor: 'darkred', lineWidth: 3 };
+ *     }
+ *     // 아무것도 반환하지 않으면 그리지 않음
+ *   }
+ * );
+ * ```
+ */
+
+var renderPolygonBaseWithCustomStyle = function (customStyle) {
+  return function (_a) {
+    var ctx = _a.ctx,
+        items = _a.items,
+        selectedIds = _a.selectedIds,
+        utils = _a.utils;
+
+    for (var _i = 0, items_3 = items; _i < items_3.length; _i++) {
+      var item = items_3[_i]; // 선택된 항목은 Event Layer에서 그림 (중복 렌더링 방지)
+
+      if (selectedIds.has(item.id)) continue; // paths가 없으면 스킵
+
+      if (!item.paths) continue; // 좌표 변환 (자동 캐싱)
+
+      var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+      if (!polygonOffsets) continue; // Base Layer는 선택되지 않은 항목만 그리므로
+
+      var context = {
+        isActive: false,
+        isHovered: false,
+        isSelected: false
+      };
+      var style = customStyle(item, context); // null 또는 undefined를 반환하면 그리지 않음
+
+      if (!style) continue; // 폴리곤 그리기
+
+      drawPolygon({
+        ctx: ctx,
+        fillColor: style.fillColor,
+        isDonutPolygon: item.isDonutPolygon || false,
+        lineWidth: style.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: style.strokeColor
+      });
+    }
+  };
+};
+/**
+ * 폴리곤 Event 렌더링 함수 팩토리 (커스터마이징 방식)
+ *
+ * Event Layer에서 사용할 렌더링 함수를 생성합니다.
+ * customStyle 함수를 사용하여 각 폴리곤의 스타일을 자유롭게 커스터마이징합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param customStyle 폴리곤 스타일 커스터마이징 함수
+ * @returns Event Layer 렌더링 함수
+ *
+ * @remarks
+ * - **렌더링 순서**: 선택된 항목 → 마지막 선택된 항목 → hover된 항목 (최상단)
+ * - **성능**: O(m), m은 선택된 항목 수 + hover된 항목 수
+ * - 좌표 변환은 자동으로 캐싱되어 성능 최적화됨
+ *
+ * @example
+ * ```typescript
+ * const renderEvent = renderPolygonEventWithCustomStyle<MyDataType>(
+ *   (item, context) => {
+ *     if (context.isActive) {
+ *       return { fillColor: 'yellow', strokeColor: 'orange', lineWidth: 5 };
+ *     }
+ *     if (context.isHovered) {
+ *       return { fillColor: 'blue', strokeColor: 'darkblue', lineWidth: 3 };
+ *     }
+ *     if (context.isSelected) {
+ *       return { fillColor: 'green', strokeColor: 'darkgreen', lineWidth: 4 };
+ *     }
+ *     // 아무것도 반환하지 않으면 그리지 않음
+ *   }
+ * );
+ * ```
+ */
+
+var renderPolygonEventWithCustomStyle = function (customStyle) {
+  return function (_a) {
+    var ctx = _a.ctx,
+        hoveredItem = _a.hoveredItem,
+        selectedItem = _a.selectedItem,
+        selectedItems = _a.selectedItems,
+        utils = _a.utils; // 성능 최적화: selectedItems를 Set으로 변환하여 O(1) 조회 (매번 some() 체크 방지)
+
+    var selectedIdsSet = selectedItems ? new Set(selectedItems.map(function (item) {
+      return item.id;
+    })) : new Set();
+    var hoveredItemId = hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.id;
+    var selectedItemId = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id; // 1. 호버된 항목 그리기 (가장 위에 표시)
+
+    if (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.paths) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(hoveredItem); // 좌표 변환 실패 시 스킵 (return은 렌더링 함수 종료)
+
+      if (!polygonOffsets) return; // 성능 최적화: Set을 사용하여 O(1) 조회 (이전: O(m) some() 체크)
+
+      var isSelected = selectedIdsSet.has(hoveredItem.id);
+      var context = {
+        isActive: isSelected && hoveredItem.id === selectedItemId,
+        isHovered: !isSelected,
+        isSelected: isSelected
+      };
+      var style = customStyle(hoveredItem, context); // null 또는 undefined를 반환하면 그리지 않음
+
+      if (!style) return;
+      drawPolygon({
+        ctx: ctx,
+        fillColor: style.fillColor,
+        isDonutPolygon: hoveredItem.isDonutPolygon || false,
+        lineWidth: style.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: style.strokeColor
+      });
+    } // 2. 선택된 항목들 그리기 (마지막 선택 항목과 호버된 항목 제외)
+
+
+    if (selectedItems === null || selectedItems === void 0 ? void 0 : selectedItems.length) {
+      for (var _i = 0, selectedItems_3 = selectedItems; _i < selectedItems_3.length; _i++) {
+        var item = selectedItems_3[_i]; // 마지막 선택 항목과 호버된 항목은 나중에 따로 그림
+
+        if (item.id === selectedItemId || item.id === hoveredItemId) continue;
+        if (!item.paths) continue;
+        var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+        if (!polygonOffsets) continue;
+        var context = {
+          isActive: false,
+          isHovered: false,
+          isSelected: true
+        };
+        var style = customStyle(item, context); // null 또는 undefined를 반환하면 그리지 않음
+
+        if (!style) continue;
+        drawPolygon({
+          ctx: ctx,
+          fillColor: style.fillColor,
+          isDonutPolygon: item.isDonutPolygon || false,
+          lineWidth: style.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: style.strokeColor
+        });
+      }
+    } // 3. 마지막 선택된 항목 그리기 (호버되지 않은 경우)
+
+
+    if ((selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.paths) && hoveredItemId !== selectedItemId) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(selectedItem);
+
+      if (polygonOffsets) {
+        var context = {
+          isActive: true,
+          isHovered: false,
+          isSelected: true
+        };
+        var style = customStyle(selectedItem, context); // null 또는 undefined를 반환하면 그리지 않음
+
+        if (!style) return;
+        drawPolygon({
+          ctx: ctx,
+          fillColor: style.fillColor,
+          isDonutPolygon: selectedItem.isDonutPolygon || false,
+          lineWidth: style.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: style.strokeColor
+        });
+      }
+    }
+  };
+};
+/**
+ * 폴리곤 Base 렌더링 함수 팩토리 (하이브리드 방식: customStyle + 개별 props)
+ *
+ * Base Layer에서 사용할 렌더링 함수를 생성합니다.
+ * customStyle이 제공되면 우선적으로 사용하며, null/undefined를 반환하면 개별 props로 정의된 기본 스타일을 사용합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param customStyle 폴리곤 스타일 커스터마이징 함수 (선택)
+ * @param baseFillColor 기본 폴리곤 채우기 색상 (fallback용)
+ * @param baseStrokeColor 기본 폴리곤 테두리 색상 (fallback용)
+ * @param baseLineWidth 기본 폴리곤 테두리 두께 (fallback용)
+ * @returns Base Layer 렌더링 함수
+ */
+
+var renderPolygonBaseWithHybrid = function (customStyle, baseFillColor, baseStrokeColor, baseLineWidth) {
+  return function (_a) {
+    var ctx = _a.ctx,
+        items = _a.items,
+        selectedIds = _a.selectedIds,
+        utils = _a.utils;
+
+    for (var _i = 0, items_4 = items; _i < items_4.length; _i++) {
+      var item = items_4[_i]; // 선택된 항목은 Event Layer에서 그림 (중복 렌더링 방지)
+
+      if (selectedIds.has(item.id)) continue; // paths가 없으면 스킵
+
+      if (!item.paths) continue; // 좌표 변환 (자동 캐싱)
+
+      var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+      if (!polygonOffsets) continue; // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+
+      var style = void 0;
+
+      if (customStyle) {
+        var context = {
+          isActive: false,
+          isHovered: false,
+          isSelected: false
+        };
+        style = customStyle(item, context);
+      } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+      if (!style) {
+        style = {
+          fillColor: baseFillColor,
+          lineWidth: baseLineWidth,
+          strokeColor: baseStrokeColor
+        };
+      } // 폴리곤 그리기
+
+
+      drawPolygon({
+        ctx: ctx,
+        fillColor: style.fillColor,
+        isDonutPolygon: item.isDonutPolygon || false,
+        lineWidth: style.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: style.strokeColor
+      });
+    }
+  };
+};
+/**
+ * 폴리곤 Event 렌더링 함수 팩토리 (하이브리드 방식: customStyle + 개별 props)
+ *
+ * Event Layer에서 사용할 렌더링 함수를 생성합니다.
+ * customStyle이 제공되면 우선적으로 사용하며, null/undefined를 반환하면 개별 props로 정의된 기본 스타일을 사용합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param customStyle 폴리곤 스타일 커스터마이징 함수 (선택)
+ * @param baseFillColor 기본 폴리곤 채우기 색상 (fallback용)
+ * @param baseStrokeColor 기본 폴리곤 테두리 색상 (fallback용)
+ * @param baseLineWidth 기본 폴리곤 테두리 두께 (fallback용)
+ * @param selectedFillColor 선택된 폴리곤 채우기 색상 (fallback용)
+ * @param selectedStrokeColor 선택된 폴리곤 테두리 색상 (fallback용)
+ * @param selectedLineWidth 선택된 폴리곤 테두리 두께 (fallback용)
+ * @param activeFillColor 마지막 선택된 폴리곤 채우기 색상 (fallback용)
+ * @param activeStrokeColor 마지막 선택된 폴리곤 테두리 색상 (fallback용)
+ * @param activeLineWidth 마지막 선택된 폴리곤 테두리 두께 (fallback용)
+ * @param hoveredFillColor Hover 시 폴리곤 채우기 색상 (fallback용)
+ * @param hoveredStrokeColor Hover 시 폴리곤 테두리 색상 (fallback용)
+ * @param hoveredLineWidth Hover 시 폴리곤 테두리 두께 (fallback용)
+ * @returns Event Layer 렌더링 함수
+ */
+
+var renderPolygonEventWithHybrid = function (customStyle, 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,
+        selectedItem = _a.selectedItem,
+        selectedItems = _a.selectedItems,
+        utils = _a.utils; // 성능 최적화: selectedItems를 Set으로 변환하여 O(1) 조회 (매번 some() 체크 방지)
+
+    var selectedIdsSet = selectedItems ? new Set(selectedItems.map(function (item) {
+      return item.id;
+    })) : new Set();
+    var hoveredItemId = hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.id;
+    var selectedItemId = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id; // 1. 호버된 항목 그리기 (가장 위에 표시)
+
+    if (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.paths) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(hoveredItem); // 좌표 변환 실패 시 스킵 (return은 렌더링 함수 종료)
+
+      if (!polygonOffsets) return; // 성능 최적화: Set을 사용하여 O(1) 조회 (이전: O(m) some() 체크)
+
+      var isSelected = selectedIdsSet.has(hoveredItem.id); // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+
+      var style = void 0;
+
+      if (customStyle) {
+        var context = {
+          isActive: isSelected && hoveredItem.id === selectedItemId,
+          isHovered: !isSelected,
+          isSelected: isSelected
+        };
+        style = customStyle(hoveredItem, context);
+      } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+      if (!style) {
+        style = {
+          fillColor: isSelected ? _activeFillColor : _hoveredFillColor,
+          lineWidth: isSelected ? _activeLineWidth : _hoveredLineWidth,
+          strokeColor: isSelected ? _activeStrokeColor : _hoveredStrokeColor
+        };
+      }
+
+      drawPolygon({
+        ctx: ctx,
+        fillColor: style.fillColor,
+        isDonutPolygon: hoveredItem.isDonutPolygon || false,
+        lineWidth: style.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: style.strokeColor
+      });
+    } // 2. 선택된 항목들 그리기 (마지막 선택 항목과 호버된 항목 제외)
+
+
+    if (selectedItems === null || selectedItems === void 0 ? void 0 : selectedItems.length) {
+      for (var _i = 0, selectedItems_4 = selectedItems; _i < selectedItems_4.length; _i++) {
+        var item = selectedItems_4[_i]; // 마지막 선택 항목과 호버된 항목은 나중에 따로 그림
+
+        if (item.id === selectedItemId || item.id === hoveredItemId) continue;
+        if (!item.paths) continue;
+        var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+        if (!polygonOffsets) continue; // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+
+        var style = void 0;
+
+        if (customStyle) {
+          var context = {
+            isActive: false,
+            isHovered: false,
+            isSelected: true
+          };
+          style = customStyle(item, context);
+        } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+        if (!style) {
+          style = {
+            fillColor: _selectedFillColor,
+            lineWidth: _selectedLineWidth,
+            strokeColor: _selectedStrokeColor
+          };
+        }
+
+        drawPolygon({
+          ctx: ctx,
+          fillColor: style.fillColor,
+          isDonutPolygon: item.isDonutPolygon || false,
+          lineWidth: style.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: style.strokeColor
+        });
+      }
+    } // 3. 마지막 선택된 항목 그리기 (호버되지 않은 경우)
+
+
+    if ((selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.paths) && hoveredItemId !== selectedItemId) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(selectedItem);
+
+      if (polygonOffsets) {
+        // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+        var style = void 0;
+
+        if (customStyle) {
+          var context = {
+            isActive: true,
+            isHovered: false,
+            isSelected: true
+          };
+          style = customStyle(selectedItem, context);
+        } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+        if (!style) {
+          style = {
+            fillColor: _activeFillColor,
+            lineWidth: _activeLineWidth,
+            strokeColor: _activeStrokeColor
+          };
+        }
+
+        drawPolygon({
+          ctx: ctx,
+          fillColor: style.fillColor,
+          isDonutPolygon: selectedItem.isDonutPolygon || false,
+          lineWidth: style.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: style.strokeColor
+        });
+      }
+    }
+  };
+};
+/**
+ * 폴리곤 Base 렌더링 함수 팩토리 (하이브리드 방식: customStyle + renderStyle)
+ *
+ * Base Layer에서 사용할 렌더링 함수를 생성합니다.
+ * customStyle이 제공되면 우선적으로 사용하며, null/undefined를 반환하면 renderStyle로 정의된 기본 스타일을 사용합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param customStyle 폴리곤 스타일 커스터마이징 함수 (선택)
+ * @param renderStyle 폴리곤 스타일 객체 (fallback용)
+ * @returns Base Layer 렌더링 함수
+ */
+
+var renderPolygonBaseWithHybridObject = function (customStyle, renderStyle) {
+  return function (_a) {
+    var ctx = _a.ctx,
+        items = _a.items,
+        selectedIds = _a.selectedIds,
+        utils = _a.utils;
+
+    for (var _i = 0, items_5 = items; _i < items_5.length; _i++) {
+      var item = items_5[_i]; // 선택된 항목은 Event Layer에서 그림 (중복 렌더링 방지)
+
+      if (selectedIds.has(item.id)) continue; // paths가 없으면 스킵
+
+      if (!item.paths) continue; // 좌표 변환 (자동 캐싱)
+
+      var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+      if (!polygonOffsets) continue; // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+
+      var style = void 0;
+
+      if (customStyle) {
+        var context = {
+          isActive: false,
+          isHovered: false,
+          isSelected: false
+        };
+        style = customStyle(item, context);
+      } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+      if (!style) {
+        style = renderStyle.base;
+      } // 폴리곤 그리기
+
+
+      drawPolygon({
+        ctx: ctx,
+        fillColor: style.fillColor,
+        isDonutPolygon: item.isDonutPolygon || false,
+        lineWidth: style.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: style.strokeColor
+      });
+    }
+  };
+};
+/**
+ * 폴리곤 Event 렌더링 함수 팩토리 (하이브리드 방식: customStyle + renderStyle)
+ *
+ * Event Layer에서 사용할 렌더링 함수를 생성합니다.
+ * customStyle이 제공되면 우선적으로 사용하며, null/undefined를 반환하면 renderStyle로 정의된 기본 스타일을 사용합니다.
+ *
+ * @template T 폴리곤 데이터의 추가 속성 타입
+ * @param customStyle 폴리곤 스타일 커스터마이징 함수 (선택)
+ * @param renderStyle 폴리곤 스타일 객체 (fallback용)
+ * @returns Event Layer 렌더링 함수
+ */
+
+var renderPolygonEventWithHybridObject = function (customStyle, renderStyle) {
+  // 기본값 설정 (개별 props 방식과 동일한 로직)
+  var _selectedStyle = renderStyle.selected || renderStyle.base;
+
+  var _activeStyle = renderStyle.active || _selectedStyle;
+
+  var _hoveredStyle = renderStyle.hovered || _selectedStyle;
+
+  return function (_a) {
+    var ctx = _a.ctx,
+        hoveredItem = _a.hoveredItem,
+        selectedItem = _a.selectedItem,
+        selectedItems = _a.selectedItems,
+        utils = _a.utils; // 성능 최적화: selectedItems를 Set으로 변환하여 O(1) 조회 (매번 some() 체크 방지)
+
+    var selectedIdsSet = selectedItems ? new Set(selectedItems.map(function (item) {
+      return item.id;
+    })) : new Set();
+    var hoveredItemId = hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.id;
+    var selectedItemId = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id; // 1. 호버된 항목 그리기 (가장 위에 표시)
+
+    if (hoveredItem === null || hoveredItem === void 0 ? void 0 : hoveredItem.paths) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(hoveredItem); // 좌표 변환 실패 시 스킵 (return은 렌더링 함수 종료)
+
+      if (!polygonOffsets) return; // 성능 최적화: Set을 사용하여 O(1) 조회 (이전: O(m) some() 체크)
+
+      var isSelected = selectedIdsSet.has(hoveredItem.id); // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+
+      var style = void 0;
+
+      if (customStyle) {
+        var context = {
+          isActive: isSelected && hoveredItem.id === selectedItemId,
+          isHovered: !isSelected,
+          isSelected: isSelected
+        };
+        style = customStyle(hoveredItem, context);
+      } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+      if (!style) {
+        style = isSelected ? _activeStyle : _hoveredStyle;
+      }
+
+      drawPolygon({
+        ctx: ctx,
+        fillColor: style.fillColor,
+        isDonutPolygon: hoveredItem.isDonutPolygon || false,
+        lineWidth: style.lineWidth,
+        polygonOffsets: polygonOffsets,
+        strokeColor: style.strokeColor
+      });
+    } // 2. 선택된 항목들 그리기 (마지막 선택 항목과 호버된 항목 제외)
+
+
+    if (selectedItems === null || selectedItems === void 0 ? void 0 : selectedItems.length) {
+      for (var _i = 0, selectedItems_5 = selectedItems; _i < selectedItems_5.length; _i++) {
+        var item = selectedItems_5[_i]; // 마지막 선택 항목과 호버된 항목은 나중에 따로 그림
+
+        if (item.id === selectedItemId || item.id === hoveredItemId) continue;
+        if (!item.paths) continue;
+        var polygonOffsets = utils.getOrComputePolygonOffsets(item);
+        if (!polygonOffsets) continue; // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+
+        var style = void 0;
+
+        if (customStyle) {
+          var context = {
+            isActive: false,
+            isHovered: false,
+            isSelected: true
+          };
+          style = customStyle(item, context);
+        } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+        if (!style) {
+          style = _selectedStyle;
+        }
+
+        drawPolygon({
+          ctx: ctx,
+          fillColor: style.fillColor,
+          isDonutPolygon: item.isDonutPolygon || false,
+          lineWidth: style.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: style.strokeColor
+        });
+      }
+    } // 3. 마지막 선택된 항목 그리기 (호버되지 않은 경우)
+
+
+    if ((selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.paths) && hoveredItemId !== selectedItemId) {
+      var polygonOffsets = utils.getOrComputePolygonOffsets(selectedItem);
+
+      if (polygonOffsets) {
+        // customStyle이 있으면 우선 사용, 없거나 null/undefined 반환 시 기본 스타일 사용
+        var style = void 0;
+
+        if (customStyle) {
+          var context = {
+            isActive: true,
+            isHovered: false,
+            isSelected: true
+          };
+          style = customStyle(selectedItem, context);
+        } // customStyle이 없거나 null/undefined를 반환하면 기본 스타일 사용
+
+
+        if (!style) {
+          style = _activeStyle;
+        }
+
+        drawPolygon({
+          ctx: ctx,
+          fillColor: style.fillColor,
+          isDonutPolygon: selectedItem.isDonutPolygon || false,
+          lineWidth: style.lineWidth,
+          polygonOffsets: polygonOffsets,
+          strokeColor: style.strokeColor
+        });
+      }
+    }
+  };
+};
+
+exports.drawPolygon = drawPolygon;
+exports.renderPolygonBase = renderPolygonBase;
+exports.renderPolygonBaseWithCustomStyle = renderPolygonBaseWithCustomStyle;
+exports.renderPolygonBaseWithHybrid = renderPolygonBaseWithHybrid;
+exports.renderPolygonBaseWithHybridObject = renderPolygonBaseWithHybridObject;
+exports.renderPolygonBaseWithObject = renderPolygonBaseWithObject;
+exports.renderPolygonEvent = renderPolygonEvent;
+exports.renderPolygonEventWithCustomStyle = renderPolygonEventWithCustomStyle;
+exports.renderPolygonEventWithHybrid = renderPolygonEventWithHybrid;
+exports.renderPolygonEventWithHybridObject = renderPolygonEventWithHybridObject;
+exports.renderPolygonEventWithObject = renderPolygonEventWithObject;