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

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

@@ -1,131 +0,0 @@
-import Konva from "konva";
-import { Position, Offset } from "../../../../types";
-/**
- * 캔버스 데이터 타입 Enum
- * 마커인지 폴리곤인지 구분하는 상수
- */
-export declare enum CanvasDataType {
-    MARKER = "MARKER",
-    POLYGON = "POLYGON"
-}
-/**
- * 폴리곤 경로 정의
- */
-export interface Paths {
-    type: string;
-    coordinates: number[][][][];
-}
-/**
- * 캔버스 마커/폴리곤 기본 옵션
- */
-/**
- * Konva 캔버스 마커/폴리곤의 기본 필수 속성
- * (렌더링에 필요한 최소 정보)
- */
-export interface KonvaCanvasMarkerOption {
-    id: string;
-    position: Position;
-    boxWidth?: number;
-    boxHeight?: number;
-    paths?: Paths;
-    isDonutPolygon?: boolean;
-}
-/**
- * 서버 데이터와 캔버스 옵션을 결합한 타입
- * @template T 서버에서 받은 원본 데이터 타입 (예: Marker, Polygon)
- * @example
- * // API에서 받은 Marker 타입을 그대로 유지하면서 캔버스 렌더링 정보 추가
- * type MarkerWithCanvas = KonvaCanvasMarkerData<Marker>
- * // { raId, lat, lng, buildingName, totalArea } + { id, position, boxWidth, ... }
- */
-export declare type KonvaCanvasMarkerData<T = {}> = T & KonvaCanvasMarkerOption;
-/**
- * 렌더링 유틸리티 함수들
- */
-export interface RenderUtils<T> {
-    getOrComputePolygonOffsets: (polygonData: KonvaCanvasMarkerData<T>) => number[][][][] | null;
-    getOrComputeMarkerOffset: (markerData: KonvaCanvasMarkerData<T>) => Offset | null;
-}
-/**
- * 커스텀 렌더링 함수 파라미터 - Base Layer
- */
-export interface RenderBaseParams<T> {
-    /** Canvas 2D 렌더링 컨텍스트 (순수 Canvas API) */
-    ctx: CanvasRenderingContext2D;
-    /** 렌더링할 마커 데이터 배열 */
-    items: KonvaCanvasMarkerData<T>[];
-    /** 현재 선택된 마커 ID Set */
-    selectedIds: Set<string>;
-    /** 렌더링 유틸리티 함수들 */
-    utils: RenderUtils<T>;
-}
-/**
- * 커스텀 렌더링 함수 타입 - Base Layer
- *
- * 🔥 순수 Canvas API 사용 (Konva 지식 불필요!)
- *
- * @example
- * const renderBase = ({ ctx, items, selectedIds, utils }) => {
- *   for (const item of items) {
- *     if (selectedIds.has(item.id)) continue;
- *     const pos = utils.getOrComputeMarkerOffset(item);
- *     ctx.fillRect(pos.x, pos.y, 50, 50); // 순수 Canvas API!
- *   }
- * };
- */
-export declare type CustomRenderBase<T> = (params: RenderBaseParams<T>) => void;
-/**
- * 커스텀 렌더링 함수 파라미터 - Animation Layer
- */
-export interface RenderAnimationParams<T> {
-    /** Konva Layer 인스턴스 */
-    layer: Konva.Layer;
-    /** 현재 선택된 마커 ID Set */
-    selectedIds: Set<string>;
-    /** 전체 마커 데이터 배열 */
-    items: KonvaCanvasMarkerData<T>[];
-    /** 렌더링 유틸리티 함수들 */
-    utils: RenderUtils<T>;
-}
-/**
- * 커스텀 렌더링 함수 타입 - Animation Layer (선택)
- *
- * @example
- * const renderAnimation = ({ layer, selectedIds, items, utils }) => {
- *   for (const id of selectedIds) {
- *     const item = items.find(i => i.id === id);
- *     // Konva 애니메이션 구현
- *   }
- * };
- */
-export declare type CustomRenderAnimation<T> = (params: RenderAnimationParams<T>) => void;
-/**
- * 커스텀 렌더링 함수 파라미터 - Event Layer
- */
-export interface RenderEventParams<T> {
-    /** Canvas 2D 렌더링 컨텍스트 (순수 Canvas API) */
-    ctx: CanvasRenderingContext2D;
-    /** 현재 hover된 마커 데이터 */
-    hoveredItem: KonvaCanvasMarkerData<T> | null;
-    /** 렌더링 유틸리티 함수들 */
-    utils: RenderUtils<T>;
-    /** 현재 선택된 마커 데이터 배열 (선택 강조용) */
-    selectedItems?: KonvaCanvasMarkerData<T>[];
-    /** 외부에서 전달된 단일 선택 아이템 (특별한 효과용) */
-    selectedItem?: KonvaCanvasMarkerData<T> | null;
-}
-/**
- * 커스텀 렌더링 함수 타입 - Event Layer
- *
- * 🔥 순수 Canvas API 사용 (Konva 지식 불필요!)
- *
- * @example
- * const renderEvent = ({ ctx, hoveredItem, utils, selectedItems }) => {
- *   if (hoveredItem) {
- *     const pos = utils.getOrComputeMarkerOffset(hoveredItem);
- *     ctx.fillStyle = 'red';
- *     ctx.fillRect(pos.x, pos.y, 50, 50); // 순수 Canvas API!
- *   }
- * };
- */
-export declare type CustomRenderEvent<T> = (params: RenderEventParams<T>) => void;

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

@@ -1,14 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/**
- * 캔버스 데이터 타입 Enum
- * 마커인지 폴리곤인지 구분하는 상수
- */
-exports.CanvasDataType = void 0;
-
-(function (CanvasDataType) {
-  CanvasDataType["MARKER"] = "MARKER";
-  CanvasDataType["POLYGON"] = "POLYGON";
-})(exports.CanvasDataType || (exports.CanvasDataType = {}));

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

@@ -1,31 +0,0 @@
-import { Offset } from "../../../../types";
-import { MintMapController } from "../../../MintMapController";
-import { KonvaCanvasMarkerData } from "./types";
-/**
- * 폴리곤 offset 계산
- */
-export declare const computePolygonOffsets: (polygonData: KonvaCanvasMarkerData<any>, controller: MintMapController) => number[][][][] | null;
-/**
- * 마커 offset 계산
- */
-export declare const computeMarkerOffset: (markerData: KonvaCanvasMarkerData<any>, controller: MintMapController) => Offset | null;
-/**
- * Point-in-Polygon 알고리즘
- */
-export declare const isPointInPolygon: (point: Offset, polygon: number[][]) => boolean;
-/**
- * 폴리곤 히트 테스트 (도넛 폴리곤 지원)
- *
- * 로직:
- * 1. 외부 폴리곤(첫 번째): 내부에 있어야 함
- * 2. 내부 구멍들(나머지): 내부에 있으면 안 됨 (evenodd 규칙)
- *
- * 중요: 도넛 폴리곤과 내부 폴리곤은 별개의 polygonData로 처리됨
- * - 도넛 폴리곤 A: isDonutPolygon=true
- * - 내부 폴리곤 B: isDonutPolygon=false (별도 데이터)
- */
-export declare const isPointInPolygonData: (clickedOffset: Offset, polygonData: KonvaCanvasMarkerData<any>, getPolygonOffsets: (data: KonvaCanvasMarkerData<any>) => number[][][][] | null) => boolean;
-/**
- * 마커 히트 테스트
- */
-export declare const isPointInMarkerData: (clickedOffset: Offset, markerData: KonvaCanvasMarkerData<any>, getMarkerOffset: (data: KonvaCanvasMarkerData<any>) => Offset | null) => boolean;

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

@@ -1,164 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-require('../../../../types/MapDrawables.js');
-var MapTypes = require('../../../../types/MapTypes.js');
-require('../../../../types/MapEventTypes.js');
-
-/**
- * 폴리곤 offset 계산
- */
-
-var computePolygonOffsets = function (polygonData, controller) {
-  var paths = polygonData.paths;
-
-  if (!paths || paths.type !== 'MultiPolygon' || !paths.coordinates) {
-    return null;
-  }
-
-  var result = [];
-
-  for (var _i = 0, _a = paths.coordinates; _i < _a.length; _i++) {
-    var multiPolygon = _a[_i];
-    var multiPolygonOffsets = [];
-
-    for (var _b = 0, multiPolygon_1 = multiPolygon; _b < multiPolygon_1.length; _b++) {
-      var polygonGroup = multiPolygon_1[_b];
-      var polygonOffsets = [];
-
-      for (var _c = 0, polygonGroup_1 = polygonGroup; _c < polygonGroup_1.length; _c++) {
-        var coord = polygonGroup_1[_c];
-        var pos = new MapTypes.Position(coord[1], coord[0]);
-        var offset = controller.positionToOffset(pos);
-        polygonOffsets.push([offset.x, offset.y]);
-      }
-
-      multiPolygonOffsets.push(polygonOffsets);
-    }
-
-    result.push(multiPolygonOffsets);
-  }
-
-  return result;
-};
-/**
- * 마커 offset 계산
- */
-
-var computeMarkerOffset = function (markerData, controller) {
-  if (!markerData.position) {
-    return null;
-  }
-
-  return controller.positionToOffset(markerData.position);
-};
-/**
- * Point-in-Polygon 알고리즘
- */
-
-var isPointInPolygon = function (point, polygon) {
-  var inside = false;
-
-  for (var i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-    var xi = polygon[i][0],
-        yi = polygon[i][1];
-    var xj = polygon[j][0],
-        yj = polygon[j][1];
-    var intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
-    if (intersect) inside = !inside;
-  }
-
-  return inside;
-};
-/**
- * 폴리곤 히트 테스트 (도넛 폴리곤 지원)
- *
- * 로직:
- * 1. 외부 폴리곤(첫 번째): 내부에 있어야 함
- * 2. 내부 구멍들(나머지): 내부에 있으면 안 됨 (evenodd 규칙)
- *
- * 중요: 도넛 폴리곤과 내부 폴리곤은 별개의 polygonData로 처리됨
- * - 도넛 폴리곤 A: isDonutPolygon=true
- * - 내부 폴리곤 B: isDonutPolygon=false (별도 데이터)
- */
-
-var isPointInPolygonData = function (clickedOffset, polygonData, getPolygonOffsets) {
-  var polygonOffsets = getPolygonOffsets(polygonData);
-  if (!polygonOffsets) return false; // 🍩 도넛 폴리곤 처리 (isDonutPolygon === true)
-
-  if (polygonData.isDonutPolygon) {
-    for (var _i = 0, polygonOffsets_1 = polygonOffsets; _i < polygonOffsets_1.length; _i++) {
-      var multiPolygon = polygonOffsets_1[_i];
-      if (multiPolygon.length === 0) continue; // 외부 폴리곤만 있는 경우 (구멍 없음) - 일반 폴리곤처럼 처리
-
-      if (multiPolygon.length === 1) {
-        if (isPointInPolygon(clickedOffset, multiPolygon[0])) {
-          return true;
-        }
-
-        continue;
-      } // 1. 외부 폴리곤(첫 번째)에 포함되는지 확인
-
-
-      var outerPolygon = multiPolygon[0];
-
-      if (!isPointInPolygon(clickedOffset, outerPolygon)) {
-        continue; // 외부 폴리곤 밖이면 다음 multiPolygon 확인
-      } // 2. 내부 구멍들(나머지)에 포함되는지 확인
-
-
-      for (var i = 1; i < multiPolygon.length; i++) {
-        var hole = multiPolygon[i];
-
-        if (isPointInPolygon(clickedOffset, hole)) {
-          // ❌ 구멍 안에 있음 → 이 도넛 폴리곤은 히트 안 됨
-          // 다른 multiPolygon 체크하지 않고 바로 false 반환
-          // (도넛 폴리곤의 구멍 안은 무조건 클릭 불가)
-          return false;
-        }
-      } // ✅ 외부 폴리곤 안 + 구멍 밖 = 히트!
-
-
-      return true;
-    }
-
-    return false;
-  } // 일반 폴리곤 처리 (isDonutPolygon === false 또는 undefined)
-
-
-  for (var _a = 0, polygonOffsets_2 = polygonOffsets; _a < polygonOffsets_2.length; _a++) {
-    var multiPolygon = polygonOffsets_2[_a];
-
-    for (var _b = 0, multiPolygon_2 = multiPolygon; _b < multiPolygon_2.length; _b++) {
-      var polygonGroup = multiPolygon_2[_b];
-      if (polygonGroup.length === 0) continue;
-
-      if (isPointInPolygon(clickedOffset, polygonGroup)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-};
-/**
- * 마커 히트 테스트
- */
-
-var isPointInMarkerData = function (clickedOffset, markerData, getMarkerOffset) {
-  var markerOffset = getMarkerOffset(markerData);
-  if (!markerOffset) return false;
-  var boxWidth = markerData.boxWidth || 50;
-  var boxHeight = markerData.boxHeight || 28;
-  var tailHeight = 6;
-  var x = markerOffset.x - boxWidth / 2;
-  var y = markerOffset.y - boxHeight - tailHeight;
-  return clickedOffset.x >= x && clickedOffset.x <= x + boxWidth && clickedOffset.y >= y && clickedOffset.y <= y + boxHeight;
-};
-
-exports.computeMarkerOffset = computeMarkerOffset;
-exports.computePolygonOffsets = computePolygonOffsets;
-exports.isPointInMarkerData = isPointInMarkerData;
-exports.isPointInPolygon = isPointInPolygon;
-exports.isPointInPolygonData = isPointInPolygonData;

package/dist/components/mint-map/core/util/geohash.js

@@ -1,125 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-// Lightweight Geohash encoder and neighbor utilities
-var BASE32 = '0123456789bcdefghjkmnpqrstuvwxyz';
-var NEIGHBORS = {
-  n: {
-    even: {
-      border: 'prxz',
-      neighbor: 'bc01fg45238967deuvhjyznpkmstqrwx'
-    },
-    odd: {
-      border: 'bcfguvyz',
-      neighbor: 'p0r21436x8zb9dcf5h7kjnmqesgutwvy'
-    }
-  },
-  s: {
-    even: {
-      border: '028b',
-      neighbor: '238967debc01fg45kmstqrwxuvhjyznp'
-    },
-    odd: {
-      border: '0145hjnp',
-      neighbor: '14365h7k9dcfesgujnmqp0r2twvyx8zb'
-    }
-  },
-  e: {
-    even: {
-      border: 'bcfguvyz',
-      neighbor: '14365h7k9dcfesgujnmqp0r2twvyx8zb'
-    },
-    odd: {
-      border: 'prxz',
-      neighbor: 'bc01fg45238967deuvhjyznpkmstqrwx'
-    }
-  },
-  w: {
-    even: {
-      border: '0145hjnp',
-      neighbor: '238967debc01fg45kmstqrwxuvhjyznp'
-    },
-    odd: {
-      border: '028b',
-      neighbor: 'p0r21436x8zb9dcf5h7kjnmqesgutwvy'
-    }
-  }
-};
-function geohashEncode(lat, lon, precision) {
-  if (precision === void 0) {
-    precision = 6;
-  }
-
-  var idx = 0;
-  var bit = 0;
-  var evenBit = true;
-  var geohash = '';
-  var latMin = -90,
-      latMax = 90;
-  var lonMin = -180,
-      lonMax = 180;
-
-  while (geohash.length < precision) {
-    if (evenBit) {
-      var lonMid = (lonMin + lonMax) / 2;
-
-      if (lon >= lonMid) {
-        idx = idx * 2 + 1;
-        lonMin = lonMid;
-      } else {
-        idx = idx * 2;
-        lonMax = lonMid;
-      }
-    } else {
-      var latMid = (latMin + latMax) / 2;
-
-      if (lat >= latMid) {
-        idx = idx * 2 + 1;
-        latMin = latMid;
-      } else {
-        idx = idx * 2;
-        latMax = latMid;
-      }
-    }
-
-    evenBit = !evenBit;
-
-    if (++bit == 5) {
-      geohash += BASE32.charAt(idx);
-      bit = 0;
-      idx = 0;
-    }
-  }
-
-  return geohash;
-}
-
-function adjacent(hash, dir) {
-  var lastChr = hash[hash.length - 1];
-  var type = hash.length % 2 ? 'odd' : 'even'; // @ts-ignore
-
-  var border = NEIGHBORS[dir][type].border; // @ts-ignore
-
-  var neighbor = NEIGHBORS[dir][type].neighbor;
-  var base = hash.substring(0, hash.length - 1);
-
-  if (border.indexOf(lastChr) !== -1) {
-    base = adjacent(base, dir);
-  }
-
-  var pos = neighbor.indexOf(lastChr);
-  var nextChr = BASE32.charAt(pos);
-  return base + nextChr;
-}
-
-function geohashNeighbors(hash) {
-  var n = adjacent(hash, 'n');
-  var s = adjacent(hash, 's');
-  var e = adjacent(hash, 'e');
-  var w = adjacent(hash, 'w');
-  return [hash, n, s, e, w, adjacent(n, 'e'), adjacent(n, 'w'), adjacent(s, 'e'), adjacent(s, 'w')];
-}
-
-exports.geohashEncode = geohashEncode;
-exports.geohashNeighbors = geohashNeighbors;