@mint-ui/map 0.4.5-beta → 0.5.0-beta

package/dist/components/mint-map/core/hooks/MarkerMovingHook.js

@@ -6,6 +6,9 @@ var React = require('react');
 var MintMapProvider = require('../provider/MintMapProvider.js');
 var animation = require('../util/animation.js');
 var calculate = require('../util/calculate.js');
+require('../../types/MapDrawables.js');
+var MapTypes = require('../../types/MapTypes.js');
+require('../../types/MapEventTypes.js');
 
 function nextIndex(array, currIdx) {
   var next = currIdx + 1;
@@ -33,13 +36,16 @@ function useMarkerMoving(_a) {
       _h = _a.velocity,
       velocity = _h === void 0 ? 10 : _h,
       onMovingStart = _a.onMovingStart,
-      onMovingEnd = _a.onMovingEnd;
+      onMovingEnd = _a.onMovingEnd; //controller
+
   var controller = MintMapProvider.useMintMapController();
   React.useEffect(function () {
+    //console.log('velocity changed!!!!', velocity);
     contextRef.current && (contextRef.current.velocityKmh = velocity);
   }, [velocity]);
   var contextRef = React.useRef();
   React.useEffect(function () {
+    //console.log('ani marker', marker);
     if (marker) {
       var currTargetIndex_1 = nextIndex(positions, startPositionIndex);
       var stopNext_1 = false;
@@ -57,15 +63,19 @@ function useMarkerMoving(_a) {
       var draw = function (frameGapTime, _elapsedTime) {
         if (!marker) {
           console.log('myMarker is not exist!!!');
-          return true;
-        }
+          return true; //종료
+        } //지난 시간
+
 
-        context_1.elapsedTimeMs = frameGapTime;
+        context_1.elapsedTimeMs = frameGapTime; //next position 계산
 
         while (true) {
-          calculate.GeoCalulator.computeNextPositionAndDistances(context_1);
+          //계산
+          calculate.GeoCalulator.computeNextPositionAndDistances(context_1); //타겟에 도착했으면, 원래 얼마나 더 갈수 있었는지 체크해서
+          //그 만큼 더 가도록 계속 처리하기위해 다시 계산
 
           if (context_1.nextPos === context_1.pos2) {
+            //다음 목표가 시작점과 같으면 loop 카운트 +1
             if (currTargetIndex_1 === startPositionIndex) {
               loopCount_1 += 1;
             }
@@ -73,9 +83,11 @@ function useMarkerMoving(_a) {
             if (!loop && loopCount_1 > 0) {
               stopNext_1 = true;
               break;
-            }
+            } //현재 출발점
+
+
+            context_1.pos1 = positions[currTargetIndex_1]; //현재 목표점
 
-            context_1.pos1 = positions[currTargetIndex_1];
             currTargetIndex_1 = nextIndex(positions, currTargetIndex_1);
 
             if (currTargetIndex_1 === 0 && !positionClosed) {
@@ -89,13 +101,13 @@ function useMarkerMoving(_a) {
           }
         }
 
-        nextOption_1.position = context_1.nextPos;
+        nextOption_1.position = new MapTypes.Position(context_1.nextPos.lat, context_1.nextPos.lng);
         marker.options.position = nextOption_1.position;
         controller.updateMarker(marker, nextOption_1);
 
         if (stopNext_1) {
           onMovingEnd && onMovingEnd();
-          return true;
+          return true; //종료
         }
 
         return false;

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,8 +1,8 @@
-export * from "./MintMapCore";
-export * from "./MintMapController";
-export * from './MintMapCanvasRenderer';
-export * from "./advanced";
-export * from "./hooks";
-export * from "./provider";
-export * from './util';
-export * from './wrapper';
+export * from "./MintMapCore";
+export * from "./MintMapController";
+export * from './MintMapCanvasRenderer';
+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/animation.js

@@ -2,7 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var AnimationPlayer = function () {
+var AnimationPlayer =
+/** @class */
+function () {
   function AnimationPlayer(drawFunction, fps) {
     this.prevtime = 0;
     this.elapsedTime = 0;
@@ -37,21 +39,27 @@ var AnimationPlayer = function () {
   };
 
   AnimationPlayer.prototype.resume = function () {
-    this.playing = true;
+    this.playing = true; //@ts-ignore
+
     window.requestAnimationFrame(this.makeFrame.bind(this));
   };
 
   AnimationPlayer.prototype.makeFrame = function (timestamp) {
+    //frame 간 시간 변화
     if (this.prevtime === 0) {
       this.prevtime = timestamp;
     }
 
-    this.deltaTime += timestamp - this.prevtime;
+    this.deltaTime += timestamp - this.prevtime; //정해진 시간이 없거나, 정해진 시간이 지났으면 draw 호출
+
     this.prevtime = timestamp;
 
     if (!this.baseDrawGapTime || this.baseDrawGapTime <= this.deltaTime) {
-      this.elapsedTime += this.deltaTime;
-      var stopFlag = this.draw(this.deltaTime, this.elapsedTime);
+      //다음 루프 준비
+      this.elapsedTime += this.deltaTime; //draw 콜백에서 stop 신호오면 멈춤
+
+      var stopFlag = this.draw(this.deltaTime, this.elapsedTime); //delta 초기화
+
       this.deltaTime = 0;
 
       if (stopFlag) {
@@ -60,6 +68,7 @@ var AnimationPlayer = function () {
     }
 
     if (this.playing) {
+      //@ts-ignore
       window.requestAnimationFrame(this.makeFrame.bind(this));
     }
   };

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

@@ -1,34 +1,66 @@
-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;
-}
+declare class PositionMirror {
+    lat: number;
+    lng: number;
+    constructor(lat: number, lng: number);
+}
+export declare class PolygonCalculator {
+    static getRegionInfo(positions: PositionMirror[]): {
+        maxLat: number | undefined;
+        minLat: number | undefined;
+        maxLng: number | undefined;
+        minLng: number | undefined;
+        centerLat: number | undefined;
+        centerLng: number | undefined;
+    };
+    static getRegionStart(positions: PositionMirror[]): PositionMirror;
+    static getRegionEnd(positions: PositionMirror[]): PositionMirror;
+    static getCenter(positions: PositionMirror[]): PositionMirror;
+    static intersects(positions1: PositionMirror[], positions2: PositionMirror[]): boolean;
+    static getIncludedPositions(polygon: PositionMirror[], position: PositionMirror | PositionMirror[]): PositionMirror[];
+    private static convertPolygonToLinePoints;
+    private static convertPositionToPoints;
+    private static getCrossPoint;
+    private static toFixedPosition;
+    private static getCrossPointAll;
+    private static findCrossPoint;
+    static readonly TOLERANCE_NAVER_STYLE = 0.0001;
+    static readonly TOLERANCE_GOOGLE_STYLE = 0.00001;
+    static simplifyPoints(polygon: PositionMirror[], tolerance?: number, lastRepeated?: boolean): PositionMirror[];
+    private static simplify;
+    private static perpendicularDistance;
+    static calculatePolygonSize(polygon: PositionMirror[], innerPolygons?: PositionMirror[][]): number;
+    private static calculatePolygonSizeMain;
+}
+export interface NextPositionContext {
+    pos1: PositionMirror;
+    pos2: PositionMirror;
+    velocityKmh: number;
+    elapsedTimeMs: number;
+    totalDistance: number;
+    currDistance: number;
+    distanceRemain: number;
+    prevPos2: PositionMirror;
+    prevVelocityKmh: number;
+    vPerMs: number;
+    nextPos: PositionMirror;
+}
+export declare class GeoCalulator {
+    private static readonly EARTH_EQUATORIAL_RADIUS;
+    private static readonly EARTH_EQUATORIAL_RADIUS_KM;
+    private static readonly EARTH_ECCENTRICITY;
+    private static readonly METER_VALUE_PER_LATITUDE;
+    private static readonly LATITUDE_POSITION_VALUE_PER_METER;
+    static computeDistanceKiloMeter(pos1: PositionMirror, pos2: PositionMirror): number;
+    private static deg2rad;
+    static convertMeterToLatitudeValue(meter: number): number;
+    static convertLatitudeToMeterValue(lat: number): number;
+    static convertLongitudeToMeterValue(lat: number, lng: number): number;
+    private static readonly CACHE_OF_LNG_PER_METER;
+    private static getCacheUnitOfLongitudeValueWithLatitudeInMeter;
+    private static getCacheOfLongitudeValueWithLatitudeInMeter;
+    private static setCacheOfLongitudeValueWithLatitudeInMeter;
+    static calculateLongitudeValueWithLatitudeInMeter(lat: number): number;
+    private static readonly MS_FROM_HOUR;
+    static computeNextPositionAndDistances(context: NextPositionContext): NextPositionContext;
+}
+export {};