@mint-ui/map 0.1.8-beta → 0.1.9-beta

package/dist/components/mint-map/core/MintMapCore.d.ts

@@ -1,3 +1,3 @@
-import { PropsWithChildren } from "react";
-import { MintMapProps } from "../MintMap";
-export declare function MintMapCore({ onLoad, visible, base, children }: PropsWithChildren<MintMapProps>): JSX.Element;
+import { PropsWithChildren } from "react";
+import { MintMapProps } from "../MintMap";
+export declare function MintMapCore({ onLoad, visible, base, children }: PropsWithChildren<MintMapProps>): JSX.Element;

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

@@ -1,15 +1,15 @@
-/// <reference types="react" />
-import { Position } from "../../MintMap";
-interface MapBuildingProjectionProps {
-    basePolygonPath: Position[];
-    numberOfFloor: number;
-    heightOfFloor?: number;
-    lineColor?: string;
-    lineOpacity?: number;
-    fillColor?: string;
-    fillOpacity?: number;
-    title?: string;
-    titleElement?: JSX.Element;
-}
-export declare function MapBuildingProjection(props: MapBuildingProjectionProps): JSX.Element;
-export {};
+/// <reference types="react" />
+import { Position } from "../../MintMap";
+interface MapBuildingProjectionProps {
+    basePolygonPath: Position[];
+    numberOfFloor: number;
+    heightOfFloor?: number;
+    lineColor?: string;
+    lineOpacity?: number;
+    fillColor?: string;
+    fillOpacity?: number;
+    title?: string;
+    titleElement?: JSX.Element;
+}
+export declare function MapBuildingProjection(props: MapBuildingProjectionProps): JSX.Element;
+export {};

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

@@ -1 +1 @@
-export * from './MapBuildingProjection';
+export * from './MapBuildingProjection';

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

@@ -1,6 +1,6 @@
-import { Marker } from "../../MintMap";
-import { MapMarkerMoving } from "../wrapper/MapMarkerWrapper";
-export interface MapMarkerMovingHookProps extends MapMarkerMoving {
-    marker?: Marker;
-}
-export declare function useMarkerMoving({ marker, positions, positionClosed, loop, fps, startPositionIndex, velocity, onMovingStart, onMovingEnd }: MapMarkerMovingHookProps): (() => void)[];
+import { Marker } from "../../MintMap";
+import { MapMarkerMoving } from "../wrapper/MapMarkerWrapper";
+export interface MapMarkerMovingHookProps extends MapMarkerMoving {
+    marker?: Marker;
+}
+export declare function useMarkerMoving({ marker, positions, positionClosed, loop, fps, startPositionIndex, velocity, onMovingStart, onMovingEnd }: MapMarkerMovingHookProps): (() => void)[];

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

@@ -1 +1 @@
-export * from "./MarkerMovingHook";
+export * from "./MarkerMovingHook";

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

@@ -1,7 +1,7 @@
-export * from "./MintMapCore";
-export * from "./MintMapController";
-export * from "./advanced";
-export * from "./hooks";
-export * from "./provider";
-export * from './util';
-export * from './wrapper';
+export * from "./MintMapCore";
+export * from "./MintMapController";
+export * from "./advanced";
+export * from "./hooks";
+export * from "./provider";
+export * from './util';
+export * from './wrapper';

package/dist/components/mint-map/core/provider/MintMapProvider.d.ts

@@ -1,8 +1,8 @@
-import { PropsWithChildren } from "react";
-import { MintMapController } from "../MintMapController";
-interface MintMapProviderProps {
-    controller: MintMapController;
-}
-export declare function MintMapProvider({ controller, children }: PropsWithChildren<MintMapProviderProps>): JSX.Element;
-export declare function useMintMapController(): MintMapController;
-export {};
+import { PropsWithChildren } from "react";
+import { MintMapController } from "../MintMapController";
+interface MintMapProviderProps {
+    controller: MintMapController;
+}
+export declare function MintMapProvider({ controller, children }: PropsWithChildren<MintMapProviderProps>): JSX.Element;
+export declare function useMintMapController(): MintMapController;
+export {};

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

@@ -1 +1 @@
-export * from "./MintMapProvider";
+export * from "./MintMapProvider";

package/dist/components/mint-map/core/util/animation.d.ts

@@ -1,16 +1,16 @@
-export declare type DrawFunction = (frameGapTime: number, elapsedTime: number) => boolean | undefined;
-export declare class AnimationPlayer {
-    prevtime: number;
-    elapsedTime: number;
-    fps: number | null;
-    baseDrawGapTime: number | null;
-    private deltaTime;
-    private playing;
-    draw: DrawFunction;
-    constructor(drawFunction: DrawFunction, fps?: number);
-    init(): void;
-    start(): void;
-    stop(): void;
-    resume(): void;
-    makeFrame(timestamp: number): void;
-}
+export declare type DrawFunction = (frameGapTime: number, elapsedTime: number) => boolean | undefined;
+export declare class AnimationPlayer {
+    prevtime: number;
+    elapsedTime: number;
+    fps: number | null;
+    baseDrawGapTime: number | null;
+    private deltaTime;
+    private playing;
+    draw: DrawFunction;
+    constructor(drawFunction: DrawFunction, fps?: number);
+    init(): void;
+    start(): void;
+    stop(): void;
+    resume(): void;
+    makeFrame(timestamp: number): void;
+}

package/dist/components/mint-map/core/util/calculate.d.ts

@@ -1,29 +1,34 @@
-import { Position } from "../../MintMap";
-export declare class PolygonCalculator {
-    static getCenter(positions: Position[]): Position;
-    static intersects(positions1: Position[], positions2: Position[]): boolean;
-    private static convertPositionToPoints;
-    private static findCrossPoint;
-}
-export interface NextPositionContext {
-    pos1: Position;
-    pos2: Position;
-    velocityKmh: number;
-    elapsedTimeMs: number;
-    totalDistance: number;
-    currDistance: number;
-    distanceRemain: number;
-    prevPos2: Position;
-    prevVelocityKmh: number;
-    vPerMs: number;
-    nextPos: Position;
-}
-export declare class GeoCalulator {
-    private static readonly EARTH_RADIUS;
-    private static readonly LATITUDE_POSITION_VALUE_PER_METER;
-    static computeDistanceKiloMeter(pos1: Position, pos2: Position): number;
-    private static deg2rad;
-    static convertMeterToLatitudeValue(meter: number): number;
-    private static readonly MS_FROM_HOUR;
-    static computeNextPositionAndDistances(context: NextPositionContext): NextPositionContext;
-}
+import { Position } from "../../MintMap";
+export declare class PolygonCalculator {
+    static getCenter(positions: Position[]): Position;
+    static intersects(positions1: Position[], positions2: Position[]): boolean;
+    static getIncludedPositions(polygon: Position[], position: Position | Position[]): Position[];
+    private static convertPolygonToLinePoints;
+    private static convertPositionToPoints;
+    private static getCrossPoint;
+    private static toFixedPosition;
+    private static getCrossPointAll;
+    private static findCrossPoint;
+}
+export interface NextPositionContext {
+    pos1: Position;
+    pos2: Position;
+    velocityKmh: number;
+    elapsedTimeMs: number;
+    totalDistance: number;
+    currDistance: number;
+    distanceRemain: number;
+    prevPos2: Position;
+    prevVelocityKmh: number;
+    vPerMs: number;
+    nextPos: Position;
+}
+export declare class GeoCalulator {
+    private static readonly EARTH_RADIUS;
+    private static readonly LATITUDE_POSITION_VALUE_PER_METER;
+    static computeDistanceKiloMeter(pos1: Position, pos2: Position): number;
+    private static deg2rad;
+    static convertMeterToLatitudeValue(meter: number): number;
+    private static readonly MS_FROM_HOUR;
+    static computeNextPositionAndDistances(context: NextPositionContext): NextPositionContext;
+}

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

@@ -66,22 +66,82 @@ var PolygonCalculator = function () {
     return false;
   };
 
+  PolygonCalculator.getIncludedPositions = function (polygon, position) {
+    var targets = Array.isArray(position) ? position : [position];
+    var result = [];
+    var maxX = Math.max.apply(Math, polygon.map(function (pos) {
+      return pos.lng;
+    })) + 1;
+    var lines = this.convertPolygonToLinePoints(polygon);
+
+    for (var _i = 0, targets_1 = targets; _i < targets_1.length; _i++) {
+      var target = targets_1[_i];
+      var tempLine = this.convertPositionToPoints(target, new MintMap.Position(target.lat, maxX));
+      var crossPoints = this.getCrossPointAll(lines, tempLine);
+
+      if (crossPoints.length > 0 && crossPoints.length % 2 != 0) {
+        result.push(target);
+      }
+    }
+
+    return result;
+  };
+
+  PolygonCalculator.convertPolygonToLinePoints = function (polygon) {
+    var lines = [];
+
+    for (var i = 0; i < polygon.length; i++) {
+      lines.push(this.convertPositionToPoints(polygon[i], polygon[i + 1 === polygon.length ? 0 : i + 1]));
+    }
+
+    return lines;
+  };
+
   PolygonCalculator.convertPositionToPoints = function (pos1, pos2) {
     return new LinePoints(pos1.lng, pos1.lat, pos2.lng, pos2.lat);
   };
 
-  PolygonCalculator.findCrossPoint = function (sr, tr) {
+  PolygonCalculator.getCrossPoint = function (sr, tr) {
+    var p1 = (sr.x1 - sr.x2) * (tr.y1 - tr.y2) - (sr.y1 - sr.y2) * (tr.x1 - tr.x2);
+
+    if (p1 != 0) {
+      var x = ((sr.x1 * sr.y2 - sr.y1 * sr.x2) * (tr.x1 - tr.x2) - (sr.x1 - sr.x2) * (tr.x1 * tr.y2 - tr.y1 * tr.x2)) / p1;
+      var y = ((sr.x1 * sr.y2 - sr.y1 * sr.x2) * (tr.y1 - tr.y2) - (sr.y1 - sr.y2) * (tr.x1 * tr.y2 - tr.y1 * tr.x2)) / p1;
+
+      if (this.toFixedPosition((x - sr.x1) * (x - sr.x2)) <= 0 && this.toFixedPosition((y - sr.y1) * (y - sr.y2)) <= 0 && this.toFixedPosition((x - tr.x1) * (x - tr.x2)) <= 0 && this.toFixedPosition((y - tr.y1) * (y - tr.y2)) <= 0) {
+        return {
+          x: x,
+          y: y
+        };
+      }
+    }
+  };
+
+  PolygonCalculator.toFixedPosition = function (n) {
+    return Number(n.toFixed(15));
+  };
+
+  PolygonCalculator.getCrossPointAll = function (sr, tr) {
+    var result = [];
+
     for (var _i = 0, sr_1 = sr; _i < sr_1.length; _i++) {
       var tmp = sr_1[_i];
-      var p1 = (tmp.x1 - tmp.x2) * (tr.y1 - tr.y2) - (tmp.y1 - tmp.y2) * (tr.x1 - tr.x2);
+      var p = this.getCrossPoint(tmp, tr);
 
-      if (p1 != 0) {
-        var x = ((tmp.x1 * tmp.y2 - tmp.y1 * tmp.x2) * (tr.x1 - tr.x2) - (tmp.x1 - tmp.x2) * (tr.x1 * tr.y2 - tr.y1 * tr.x2)) / p1;
-        var y = ((tmp.x1 * tmp.y2 - tmp.y1 * tmp.x2) * (tr.y1 - tr.y2) - (tmp.y1 - tmp.y2) * (tr.x1 * tr.y2 - tr.y1 * tr.x2)) / p1;
+      if (p) {
+        result.push(p);
+      }
+    }
+
+    return result;
+  };
 
-        if ((x - tmp.x1) * (x - tmp.x2) <= 0 && (y - tmp.y1) * (y - tmp.y2) <= 0 && (x - tr.x1) * (x - tr.x2) <= 0 && (y - tr.y1) * (y - tr.y2) <= 0) {
-          return true;
-        }
+  PolygonCalculator.findCrossPoint = function (sr, tr) {
+    for (var _i = 0, sr_2 = sr; _i < sr_2.length; _i++) {
+      var tmp = sr_2[_i];
+
+      if (this.getCrossPoint(tmp, tr)) {
+        return true;
       }
     }
 

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

@@ -1,3 +1,3 @@
-export * from './animation';
-export * from './calculate';
-export * from './waiting';
+export * from './animation';
+export * from './calculate';
+export * from './waiting';

package/dist/components/mint-map/core/util/waiting.d.ts

@@ -1 +1 @@
-export declare function waiting(evaluation: () => boolean, timeoutSeconds?: number): Promise<boolean>;
+export declare function waiting(evaluation: () => boolean, timeoutSeconds?: number): Promise<boolean>;

package/dist/components/mint-map/core/wrapper/MapControlWrapper.d.ts

@@ -1,11 +1,11 @@
-import { PropsWithChildren } from "react";
-declare type AlignHorizontal = 'left' | 'right' | 'center';
-declare type AlignVertical = 'top' | 'bottom' | 'center';
-export interface MapControlWrapperProps {
-    width?: number | string;
-    height?: number | string;
-    positionHorizontal?: AlignHorizontal;
-    positionVertical?: AlignVertical;
-}
-export declare function MapControlWrapper({ width, height, positionHorizontal, positionVertical, children }: PropsWithChildren<MapControlWrapperProps>): JSX.Element;
-export {};
+import { PropsWithChildren } from "react";
+declare type AlignHorizontal = 'left' | 'right' | 'center';
+declare type AlignVertical = 'top' | 'bottom' | 'center';
+export interface MapControlWrapperProps {
+    width?: number | string;
+    height?: number | string;
+    positionHorizontal?: AlignHorizontal;
+    positionVertical?: AlignVertical;
+}
+export declare function MapControlWrapper({ width, height, positionHorizontal, positionVertical, children }: PropsWithChildren<MapControlWrapperProps>): JSX.Element;
+export {};

package/dist/components/mint-map/core/wrapper/MapMarkerWrapper.d.ts

@@ -1,23 +1,23 @@
-import { PropsWithChildren } from "react";
-import { MarkerOptions, Position } from "../../MintMap";
-export declare type MovingEventFunciton = () => void;
-export interface MapMarkerMoving {
-    positions?: Position[];
-    positionClosed?: boolean;
-    startPositionIndex?: number;
-    velocity?: number;
-    loop?: boolean;
-    delay?: number;
-    autoStart?: boolean;
-    fps?: number;
-    onMovingStart?: MovingEventFunciton;
-    onMovingEnd?: MovingEventFunciton;
-}
-export interface MapMarkerWrapperProps extends MarkerOptions {
-    topOnClick?: boolean;
-    topOnHover?: boolean;
-    startAnimationClassName?: string;
-    endAnimationClassName?: string;
-    movingAnimation?: MapMarkerMoving;
-}
-export declare function MapMarkerWrapper({ startAnimationClassName, endAnimationClassName, topOnClick, topOnHover, movingAnimation, children, ...options }: PropsWithChildren<MapMarkerWrapperProps>): JSX.Element;
+import { PropsWithChildren } from "react";
+import { MarkerOptions, Position } from "../../MintMap";
+export declare type MovingEventFunciton = () => void;
+export interface MapMarkerMoving {
+    positions?: Position[];
+    positionClosed?: boolean;
+    startPositionIndex?: number;
+    velocity?: number;
+    loop?: boolean;
+    delay?: number;
+    autoStart?: boolean;
+    fps?: number;
+    onMovingStart?: MovingEventFunciton;
+    onMovingEnd?: MovingEventFunciton;
+}
+export interface MapMarkerWrapperProps extends MarkerOptions {
+    topOnClick?: boolean;
+    topOnHover?: boolean;
+    startAnimationClassName?: string;
+    endAnimationClassName?: string;
+    movingAnimation?: MapMarkerMoving;
+}
+export declare function MapMarkerWrapper({ startAnimationClassName, endAnimationClassName, topOnClick, topOnHover, movingAnimation, children, ...options }: PropsWithChildren<MapMarkerWrapperProps>): JSX.Element;

package/dist/components/mint-map/core/wrapper/MapMarkerWrapper.js

@@ -100,7 +100,7 @@ function MapMarkerWrapper(_a) {
           divCloneRef.current && divCloneRef.current.removeEventListener('animationend', aniListener_1);
 
           if (markerRef.current) {
-            console.log('drawable cleared', controller.clearDrawable(markerRef.current));
+            controller.clearDrawable(markerRef.current);
           }
 
           divCloneRef.current = undefined;
@@ -113,7 +113,7 @@ function MapMarkerWrapper(_a) {
         divElement.removeEventListener('mouseover', onMouseOverHandler);
 
         if (markerRef.current) {
-          console.log('drawable cleared', controller.clearDrawable(markerRef.current));
+          controller.clearDrawable(markerRef.current);
         }
       }
     };

package/dist/components/mint-map/core/wrapper/MapPolygonWrapper.d.ts

@@ -1,5 +1,5 @@
-import { PropsWithChildren } from "react";
-import { PolygonOptions } from "../../MintMap";
-export interface MapPolygonWrapperProps extends PolygonOptions {
-}
-export declare function MapPolygonWrapper({ children, ...options }: PropsWithChildren<MapPolygonWrapperProps>): JSX.Element;
+import { PropsWithChildren } from "react";
+import { PolygonOptions } from "../../MintMap";
+export interface MapPolygonWrapperProps extends PolygonOptions {
+}
+export declare function MapPolygonWrapper({ children, ...options }: PropsWithChildren<MapPolygonWrapperProps>): JSX.Element;

package/dist/components/mint-map/core/wrapper/MapPolylineWrapper.d.ts

@@ -1,5 +1,5 @@
-import { PropsWithChildren } from "react";
-import { PolylineOptions } from "../../MintMap";
-export interface MapPolylineWrapperProps extends PolylineOptions {
-}
-export declare function MapPolylineWrapper({ children, ...options }: PropsWithChildren<MapPolylineWrapperProps>): JSX.Element;
+import { PropsWithChildren } from "react";
+import { PolylineOptions } from "../../MintMap";
+export interface MapPolylineWrapperProps extends PolylineOptions {
+}
+export declare function MapPolylineWrapper({ children, ...options }: PropsWithChildren<MapPolylineWrapperProps>): JSX.Element;

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

@@ -1,4 +1,4 @@
-export * from './MapControlWrapper';
-export * from './MapMarkerWrapper';
-export * from './MapPolygonWrapper';
-export * from './MapPolylineWrapper';
+export * from './MapControlWrapper';
+export * from './MapMarkerWrapper';
+export * from './MapPolygonWrapper';
+export * from './MapPolylineWrapper';

package/dist/components/mint-map/google/GoogleMintMapController.d.ts

@@ -1,35 +1,35 @@
-/// <reference types="google.maps" />
-import { MintMapController } from "../core/MintMapController";
-import { Bounds, Drawable, MapType, MapVendorType, Marker, MarkerOptions, MintMapProps, Polygon, PolygonOptions, Polyline, PolylineOptions, Position } from "../MintMap";
-export declare class GoogleMintMapController extends MintMapController {
-    type: MapType;
-    map: google.maps.Map | null;
-    scriptUrl: string;
-    scriptModules: string[];
-    constructor(props: MintMapProps);
-    polylineEvents: string[];
-    createPolyline(polyline: Polyline): void;
-    updatePolyline(polyline: Polyline, options: PolylineOptions): void;
-    polygonEvents: string[];
-    createPolygon(polygon: Polygon): void;
-    updatePolygon(polygon: Polygon, options: PolygonOptions): void;
-    private getValidOptions;
-    markerEvents: string[];
-    createMarker(marker: Marker): void;
-    updateMarker(marker: Marker, options: MarkerOptions): void;
-    private markerMaxZIndex;
-    private getMaxZIndex;
-    markerToTheTop(marker: Marker): void;
-    clearDrawable(drawable: Drawable): boolean;
-    private dragged;
-    isMapDragged(): boolean;
-    setMapDragged(value: boolean): void;
-    loadMapApi(): Promise<boolean>;
-    initializingMap(divElement: HTMLDivElement): Promise<MapVendorType>;
-    destroyMap: () => void;
-    private fromGoogleBounds;
-    getCurrBounds(): Bounds;
-    panningTo(targetCenter: Position): void;
-    getZoomLevel(): number;
-    setZoomLevel(zoom: number): void;
-}
+/// <reference types="google.maps" />
+import { MintMapController } from "../core/MintMapController";
+import { Bounds, Drawable, MapType, MapVendorType, Marker, MarkerOptions, MintMapProps, Polygon, PolygonOptions, Polyline, PolylineOptions, Position } from "../MintMap";
+export declare class GoogleMintMapController extends MintMapController {
+    type: MapType;
+    map: google.maps.Map | null;
+    scriptUrl: string;
+    scriptModules: string[];
+    constructor(props: MintMapProps);
+    polylineEvents: string[];
+    createPolyline(polyline: Polyline): void;
+    updatePolyline(polyline: Polyline, options: PolylineOptions): void;
+    polygonEvents: string[];
+    createPolygon(polygon: Polygon): void;
+    updatePolygon(polygon: Polygon, options: PolygonOptions): void;
+    private getValidOptions;
+    markerEvents: string[];
+    createMarker(marker: Marker): void;
+    updateMarker(marker: Marker, options: MarkerOptions): void;
+    private markerMaxZIndex;
+    private getMaxZIndex;
+    markerToTheTop(marker: Marker): void;
+    clearDrawable(drawable: Drawable): boolean;
+    private dragged;
+    isMapDragged(): boolean;
+    setMapDragged(value: boolean): void;
+    loadMapApi(): Promise<boolean>;
+    initializingMap(divElement: HTMLDivElement): Promise<MapVendorType>;
+    destroyMap: () => void;
+    private fromGoogleBounds;
+    getCurrBounds(): Bounds;
+    panningTo(targetCenter: Position): void;
+    getZoomLevel(): number;
+    setZoomLevel(zoom: number): void;
+}

package/dist/components/mint-map/google/GoogleMintMapController.js

@@ -373,6 +373,9 @@ var GoogleMintMapController = function (_super) {
                     console.log('map dragend');
                     _this.mapProps.onBoundsChanged && _this.mapProps.onBoundsChanged(_this.getCurrBounds());
                   });
+                  map.addListener('idle', function () {
+                    _this.mapProps.onBoundsChanged && _this.mapProps.onBoundsChanged(_this.getCurrBounds());
+                  });
                   map.addListener('zoom_changed', function () {
                     console.log('zoom_changed');
                     _this.map && _this.mapProps.onZoomChanged && _this.mapProps.onZoomChanged(_this.map.getZoom());

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

@@ -1,4 +1,4 @@
-export * from './MintMap';
-export * from './core';
-export * from './naver/NaverMintMapController';
-export * from './google/GoogleMintMapController';
+export * from './MintMap';
+export * from './core';
+export * from './naver/NaverMintMapController';
+export * from './google/GoogleMintMapController';

package/dist/components/mint-map/naver/NaverMintMapController.d.ts

@@ -1,38 +1,38 @@
-/// <reference types="navermaps" />
-import { MintMapController } from "../core/MintMapController";
-import { Bounds, Drawable, MapType, MapVendorType, Marker, MarkerOptions, MintMapProps, Polygon, PolygonOptions, Polyline, PolylineOptions, Position } from "../MintMap";
-import { ObjectPool } from '@mint-ui/tools';
-export declare class NaverMintMapController extends MintMapController {
-    type: MapType;
-    map: naver.maps.Map | null;
-    scriptUrl: string;
-    scriptModules: string[];
-    markerPool?: ObjectPool<naver.maps.Marker>;
-    constructor(props: MintMapProps);
-    private initMarkerPool;
-    polylineEvents: string[];
-    createPolyline(polyline: Polyline): void;
-    updatePolyline(polyline: Polyline, options: PolylineOptions): void;
-    polygonEvents: string[];
-    createPolygon(polygon: Polygon): void;
-    updatePolygon(polygon: Polygon, options: PolygonOptions): void;
-    markerEvents: string[];
-    createMarker(marker: Marker): void;
-    updateMarker(marker: Marker, options: MarkerOptions): void;
-    private markerMaxZIndex;
-    private getMaxZIndex;
-    markerToTheTop(marker: Marker): void;
-    clearDrawable(drawable: Drawable): boolean;
-    private dragStartPoint;
-    private dragged;
-    isMapDragged(): boolean;
-    setMapDragged(value: boolean): void;
-    loadMapApi(): Promise<boolean>;
-    initializingMap(divElement: HTMLDivElement): Promise<MapVendorType>;
-    private getSafeZoomValue;
-    destroyMap(): void;
-    getCurrBounds(): Bounds;
-    panningTo(targetCenter: Position): void;
-    getZoomLevel(): number;
-    setZoomLevel(zoom: number): void;
-}
+/// <reference types="navermaps" />
+import { MintMapController } from "../core/MintMapController";
+import { Bounds, Drawable, MapType, MapVendorType, Marker, MarkerOptions, MintMapProps, Polygon, PolygonOptions, Polyline, PolylineOptions, Position } from "../MintMap";
+import { ObjectPool } from '@mint-ui/tools';
+export declare class NaverMintMapController extends MintMapController {
+    type: MapType;
+    map: naver.maps.Map | null;
+    scriptUrl: string;
+    scriptModules: string[];
+    markerPool?: ObjectPool<naver.maps.Marker>;
+    constructor(props: MintMapProps);
+    private initMarkerPool;
+    polylineEvents: string[];
+    createPolyline(polyline: Polyline): void;
+    updatePolyline(polyline: Polyline, options: PolylineOptions): void;
+    polygonEvents: string[];
+    createPolygon(polygon: Polygon): void;
+    updatePolygon(polygon: Polygon, options: PolygonOptions): void;
+    markerEvents: string[];
+    createMarker(marker: Marker): void;
+    updateMarker(marker: Marker, options: MarkerOptions): void;
+    private markerMaxZIndex;
+    private getMaxZIndex;
+    markerToTheTop(marker: Marker): void;
+    clearDrawable(drawable: Drawable): boolean;
+    private dragStartPoint;
+    private dragged;
+    isMapDragged(): boolean;
+    setMapDragged(value: boolean): void;
+    loadMapApi(): Promise<boolean>;
+    initializingMap(divElement: HTMLDivElement): Promise<MapVendorType>;
+    private getSafeZoomValue;
+    destroyMap(): void;
+    getCurrBounds(): Bounds;
+    panningTo(targetCenter: Position): void;
+    getZoomLevel(): number;
+    setZoomLevel(zoom: number): void;
+}

package/dist/components/mint-map/naver/NaverMintMapController.js

@@ -38,7 +38,7 @@ var NaverMintMapController = function (_super) {
       });
     }).setClear(function (item) {
       item.setMap(null);
-    }).createPool(1000).setCheckLiveTimeInterval(1000);
+    }).createPool(this.mapProps.markerCachePoolSize && this.mapProps.markerCachePoolSize > 0 ? this.mapProps.markerCachePoolSize : 1000).setCheckLiveTimeInterval(1000);
   };
 
   NaverMintMapController.prototype.createPolyline = function (polyline) {
@@ -414,12 +414,12 @@ var NaverMintMapController = function (_super) {
                     } else {
                       _this.dragged = true;
                     }
-
+                  });
+                  map.addListener('idle', function () {
                     _this.mapProps.onBoundsChanged && _this.mapProps.onBoundsChanged(_this.getCurrBounds());
                   });
                   map.addListener('zoom_changed', function () {
                     _this.map && _this.mapProps.onZoomChanged && _this.mapProps.onZoomChanged(_this.map.getZoom());
-                    _this.mapProps.onBoundsChanged && _this.mapProps.onBoundsChanged(_this.getCurrBounds());
                   });
                   map.addListener('click', function (e) {
                     console.log('map click', e);

package/dist/index.d.ts

@@ -1 +1 @@
-export * from './components/mint-map';
+export * from './components/mint-map';