@mint-ui/map 0.1.1-beta

package/dist/components/mint-map/core/advanced/MapBuildingProjection.js

@@ -0,0 +1,173 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var MintMap = require('../../MintMap.js');
+var calculate = require('../util/calculate.js');
+var MapMarkerWrapper = require('../wrapper/MapMarkerWrapper.js');
+var MapPolygonWrapper = require('../wrapper/MapPolygonWrapper.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+function getMaxLat(items) {
+  var max;
+
+  for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+    var item = items_1[_i];
+
+    if (!max || max.lat < item.lat) {
+      max = item;
+    }
+  }
+
+  return max;
+}
+
+function getLngMinMaxPos(items, maxFlag) {
+  var data = tslib.__spreadArray([], items, true);
+
+  data.sort(function (a, b) {
+    var maxA = getLngMinMax(a.position, maxFlag);
+    var maxB = getLngMinMax(b.position, maxFlag);
+    return maxA.lat < maxB.lat ? maxFlag ? 1 : -1 : maxFlag ? -1 : 1;
+  });
+  return data[0];
+}
+
+function getLngMinMax(items, maxFlag) {
+  var val;
+
+  for (var _i = 0, items_2 = items; _i < items_2.length; _i++) {
+    var item = items_2[_i];
+
+    if (!val || maxFlag && val.lat < item.lat || !maxFlag && val.lat > item.lat) {
+      val = item;
+    }
+  }
+
+  return val;
+}
+
+function MapBuildingProjection(props) {
+  var basePolygonPath = props.basePolygonPath,
+      numberOfFloor = props.numberOfFloor,
+      _a = props.heightOfFloor,
+      heightOfFloor = _a === void 0 ? 4 : _a,
+      _b = props.lineColor,
+      lineColor = _b === void 0 ? 'blue' : _b,
+      _c = props.lineOpacity,
+      lineOpacity = _c === void 0 ? 1 : _c,
+      _d = props.fillColor,
+      fillColor = _d === void 0 ? 'lightblue' : _d,
+      _e = props.fillOpacity,
+      fillOpacity = _e === void 0 ? 1 : _e,
+      _f = props.title,
+      title = _f === void 0 ? '빌딩11' : _f,
+      titleElement = props.titleElement;
+
+  var _g = React.useState(),
+      basePolygon = _g[0],
+      setBasePolygon = _g[1];
+
+  var roofPolygon = React.useRef();
+  var wallPolygons = React.useRef();
+  var titlePosition = React.useRef();
+  React.useEffect(function () {
+    var base = {
+      position: basePolygonPath
+    };
+    var height = numberOfFloor * heightOfFloor;
+    var projectionHeight = calculate.GeoCalulator.convertMeterToLatitudeValue(height);
+    var roofPaths = [];
+
+    for (var _i = 0, basePolygonPath_1 = basePolygonPath; _i < basePolygonPath_1.length; _i++) {
+      var pos = basePolygonPath_1[_i];
+      roofPaths.push(new MintMap.Position(pos.lat + projectionHeight, pos.lng));
+    }
+
+    roofPolygon.current = {
+      position: roofPaths
+    };
+    wallPolygons.current = [];
+
+    for (var i = 0; i < basePolygonPath.length; i++) {
+      var start = basePolygonPath[i];
+      var startNext = basePolygonPath[i + 1] || basePolygonPath[0];
+      var end = roofPaths[i];
+      var endNext = roofPaths[i + 1] || roofPaths[0];
+      wallPolygons.current.push({
+        position: [start, startNext, endNext, end]
+      });
+    }
+
+    wallPolygons.current.sort(function (a, b) {
+      var maxA = getMaxLat(a.position);
+      var maxB = getMaxLat(b.position);
+      return maxA.lat < maxB.lat ? 1 : -1;
+    });
+
+    if (title || titleElement) {
+      var maxPos = getMaxLat(wallPolygons.current[0].position);
+      var maxLngPos = getLngMinMaxPos(wallPolygons.current, true);
+      var minLngPos = getLngMinMaxPos(wallPolygons.current, false);
+      var maxLng = getLngMinMax(maxLngPos.position, true);
+      var minLng = getLngMinMax(minLngPos.position, false);
+      var mid = minLng.lng + (maxLng.lng - minLng.lng) / 2;
+      titlePosition.current = {
+        position: new MintMap.Position(maxPos.lat, mid)
+      };
+    } else {
+      titlePosition.current = undefined;
+    }
+
+    setBasePolygon(base);
+  }, [props]);
+  return React__default["default"].createElement(React__default["default"].Fragment, null, basePolygon && React__default["default"].createElement(MapPolygonWrapper, tslib.__assign({}, basePolygon, {
+    lineColor: lineColor,
+    lineOpacity: lineOpacity,
+    fillColor: fillColor,
+    fillOpacity: fillOpacity
+  })), wallPolygons.current && wallPolygons.current.map(function (poly, idx) {
+    return React__default["default"].createElement(MapPolygonWrapper, tslib.__assign({
+      key: "walls-".concat(idx)
+    }, poly, {
+      lineColor: lineColor,
+      lineOpacity: lineOpacity,
+      fillColor: fillColor,
+      fillOpacity: fillOpacity
+    }));
+  }), roofPolygon.current && React__default["default"].createElement(MapPolygonWrapper, tslib.__assign({}, roofPolygon.current, {
+    lineColor: lineColor,
+    lineOpacity: lineOpacity,
+    fillColor: fillColor,
+    fillOpacity: fillOpacity
+  })), titlePosition.current && React__default["default"].createElement(MapMarkerWrapper, tslib.__assign({}, titlePosition.current), titleElement ? titleElement : React__default["default"].createElement("div", {
+    style: {
+      width: '150px',
+      height: '30px',
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center',
+      position: 'absolute',
+      left: 'calc(50% - 75px)',
+      top: '-35px'
+    }
+  }, React__default["default"].createElement("div", {
+    style: {
+      maxWidth: '150px',
+      border: '1px solid gray',
+      borderRadius: '5px',
+      padding: '2px 5px',
+      background: 'white',
+      fontSize: '12px',
+      fontWeight: 600,
+      color: '#006fd1'
+    }
+  }, "".concat(title, " (").concat(numberOfFloor, "\uCE35)")))));
+}
+
+exports.MapBuildingProjection = MapBuildingProjection;

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

@@ -0,0 +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)[];

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

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var MintMapProvider = require('../provider/MintMapProvider.js');
+var animation = require('../util/animation.js');
+var calculate = require('../util/calculate.js');
+
+function nextIndex(array, currIdx) {
+  var next = currIdx + 1;
+
+  if (next > array.length - 1) {
+    next = 0;
+  }
+
+  return next;
+}
+
+function useMarkerMoving(_a) {
+  var _b = _a.marker,
+      marker = _b === void 0 ? undefined : _b,
+      _c = _a.positions,
+      positions = _c === void 0 ? [] : _c,
+      _d = _a.positionClosed,
+      positionClosed = _d === void 0 ? false : _d,
+      _e = _a.loop,
+      loop = _e === void 0 ? false : _e,
+      _f = _a.fps,
+      fps = _f === void 0 ? 1 : _f,
+      _g = _a.startPositionIndex,
+      startPositionIndex = _g === void 0 ? 0 : _g,
+      _h = _a.velocity,
+      velocity = _h === void 0 ? 10 : _h,
+      onMovingStart = _a.onMovingStart,
+      onMovingEnd = _a.onMovingEnd;
+  var controller = MintMapProvider.useMintMapController();
+  React.useEffect(function () {
+    contextRef.current && (contextRef.current.velocityKmh = velocity);
+  }, [velocity]);
+  var contextRef = React.useRef();
+  React.useEffect(function () {
+    if (marker) {
+      var currTargetIndex_1 = nextIndex(positions, startPositionIndex);
+      var stopNext_1 = false;
+      var loopCount_1 = 0;
+      var context_1 = contextRef.current = {
+        pos1: positions[startPositionIndex],
+        pos2: positions[currTargetIndex_1],
+        velocityKmh: velocity
+      };
+      var nextOption_1 = {
+        position: context_1.nextPos,
+        anchor: marker.options.anchor
+      };
+
+      var draw = function (frameGapTime, _elapsedTime) {
+        if (!marker) {
+          console.log('myMarker is not exist!!!');
+          return true;
+        }
+
+        context_1.elapsedTimeMs = frameGapTime;
+
+        while (true) {
+          calculate.GeoCalulator.computeNextPositionAndDistances(context_1);
+
+          if (context_1.nextPos === context_1.pos2) {
+            if (currTargetIndex_1 === startPositionIndex) {
+              loopCount_1 += 1;
+            }
+
+            if (!loop && loopCount_1 > 0) {
+              stopNext_1 = true;
+              break;
+            }
+
+            context_1.pos1 = positions[currTargetIndex_1];
+            currTargetIndex_1 = nextIndex(positions, currTargetIndex_1);
+
+            if (currTargetIndex_1 === 0 && !positionClosed) {
+              context_1.pos1 = positions[currTargetIndex_1];
+              currTargetIndex_1 = nextIndex(positions, currTargetIndex_1);
+            }
+
+            context_1.pos2 = positions[currTargetIndex_1];
+          } else {
+            break;
+          }
+        }
+
+        nextOption_1.position = context_1.nextPos;
+        marker.options.position = nextOption_1.position;
+        controller.updateMarker(marker, nextOption_1);
+
+        if (stopNext_1) {
+          onMovingEnd && onMovingEnd();
+          return true;
+        }
+
+        return false;
+      };
+
+      player.current = new animation.AnimationPlayer(draw, fps);
+    }
+
+    return function () {
+      player.current && player.current.stop();
+    };
+  }, [marker]);
+  var player = React.useRef();
+
+  var _j = React.useState('stop'),
+      playbackStatus = _j[0],
+      setPlaybackStatus = _j[1];
+
+  React.useEffect(function () {
+    var _a, _b, _c;
+
+    if (playbackStatus === 'start') {
+      (_a = player === null || player === void 0 ? void 0 : player.current) === null || _a === void 0 ? void 0 : _a.start();
+      onMovingStart && onMovingStart();
+    } else if (playbackStatus === 'resume') {
+      (_b = player === null || player === void 0 ? void 0 : player.current) === null || _b === void 0 ? void 0 : _b.resume();
+    } else if (playbackStatus === 'stop') {
+      (_c = player === null || player === void 0 ? void 0 : player.current) === null || _c === void 0 ? void 0 : _c.stop();
+    }
+  }, [playbackStatus]);
+
+  var start = function () {
+    setPlaybackStatus('start');
+  };
+
+  var stop = function () {
+    setPlaybackStatus('stop');
+  };
+
+  var resume = function () {
+    setPlaybackStatus('resume');
+  };
+
+  return [start, stop, resume];
+}
+
+exports.useMarkerMoving = useMarkerMoving;

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

@@ -0,0 +1,7 @@
+export { default as MintMapController } from "./MintMapController";
+export { default as MapControlWrapper } from './wrapper/MapControlWrapper';
+export { default as MapMarkerWrapper } from './wrapper/MapMarkerWrapper';
+export { default as MapPolygonWrapper } from './wrapper/MapPolygonWrapper';
+export { default as MapPolylineWrapper } from './wrapper/MapPolylineWrapper';
+export { default as MintMapProvider } from "./provider/MintMapProvider";
+export { MapBuildingProjection } from "./advanced/MapBuildingProjection";

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

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

package/dist/components/mint-map/core/provider/MintMapProvider.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+var MintMapControllerContext = React.createContext(null);
+function MintMapProvider(_a) {
+  var controller = _a.controller,
+      children = _a.children;
+  return React__default["default"].createElement(MintMapControllerContext.Provider, {
+    value: controller
+  }, children);
+}
+function useMintMapController() {
+  var controller = React.useContext(MintMapControllerContext);
+
+  if (controller === null) {
+    throw new Error('controller is not initialized');
+  }
+
+  return controller;
+}
+
+exports["default"] = MintMapProvider;
+exports.useMintMapController = useMintMapController;

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AnimationPlayer = function () {
+  function AnimationPlayer(drawFunction, fps) {
+    this.prevtime = 0;
+    this.elapsedTime = 0;
+    this.fps = null;
+    this.baseDrawGapTime = null;
+    this.deltaTime = 0;
+    this.playing = false;
+    this.draw = drawFunction;
+    this.fps = fps || null;
+
+    if (fps !== undefined) {
+      this.baseDrawGapTime = 1000 / fps;
+    }
+
+    this.init();
+  }
+
+  AnimationPlayer.prototype.init = function () {
+    this.deltaTime = 0;
+    this.prevtime = 0;
+    this.elapsedTime = 0;
+    this.playing = false;
+  };
+
+  AnimationPlayer.prototype.start = function () {
+    this.init();
+    this.resume();
+  };
+
+  AnimationPlayer.prototype.stop = function () {
+    this.playing = false;
+  };
+
+  AnimationPlayer.prototype.resume = function () {
+    this.playing = true;
+    window.requestAnimationFrame(this.makeFrame.bind(this));
+  };
+
+  AnimationPlayer.prototype.makeFrame = function (timestamp) {
+    if (this.prevtime === 0) {
+      this.prevtime = timestamp;
+    }
+
+    this.deltaTime += timestamp - this.prevtime;
+    this.prevtime = timestamp;
+
+    if (!this.baseDrawGapTime || this.baseDrawGapTime <= this.deltaTime) {
+      this.elapsedTime += this.deltaTime;
+      var stopFlag = this.draw(this.deltaTime, this.elapsedTime);
+      this.deltaTime = 0;
+
+      if (stopFlag) {
+        this.stop();
+      }
+    }
+
+    if (this.playing) {
+      window.requestAnimationFrame(this.makeFrame.bind(this));
+    }
+  };
+
+  return AnimationPlayer;
+}();
+
+exports.AnimationPlayer = AnimationPlayer;

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

@@ -0,0 +1,29 @@
+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;
+}

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

@@ -0,0 +1,167 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var MintMap = require('../../MintMap.js');
+
+var LinePoints = function () {
+  function LinePoints(x1, y1, x2, y2) {
+    this.x1 = x1;
+    this.y1 = y1;
+    this.x2 = x2;
+    this.y2 = y2;
+  }
+
+  return LinePoints;
+}();
+
+var PolygonCalculator = function () {
+  function PolygonCalculator() {}
+
+  PolygonCalculator.getCenter = function (positions) {
+    var maxX, minX, maxY, minY;
+
+    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {
+      var pos = positions_1[_i];
+
+      if (maxX === undefined || pos.lat > maxX) {
+        maxX = pos.lat;
+      }
+
+      if (minX === undefined || pos.lat < minX) {
+        minX = pos.lat;
+      }
+
+      if (maxY === undefined || pos.lng > maxY) {
+        maxY = pos.lng;
+      }
+
+      if (minY === undefined || pos.lng < minY) {
+        minY = pos.lng;
+      }
+    }
+
+    if (maxX && minX && maxY && minY) {
+      return new MintMap.Position(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2);
+    }
+
+    throw new Error('Calculate Center Error!!!');
+  };
+
+  PolygonCalculator.intersects = function (positions1, positions2) {
+    var lines = [];
+
+    for (var i = 0; i < positions2.length - 1; i++) {
+      lines.push(this.convertPositionToPoints(positions2[i], positions2[i + 1]));
+    }
+
+    for (var i = 0; i < positions1.length - 1; i++) {
+      var targetLinePoints = this.convertPositionToPoints(positions1[i], positions1[i + 1]);
+
+      if (this.findCrossPoint(lines, targetLinePoints)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  PolygonCalculator.convertPositionToPoints = function (pos1, pos2) {
+    return new LinePoints(pos1.lng, pos1.lat, pos2.lng, pos2.lat);
+  };
+
+  PolygonCalculator.findCrossPoint = function (sr, tr) {
+    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);
+
+      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 ((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;
+        }
+      }
+    }
+
+    return false;
+  };
+
+  return PolygonCalculator;
+}();
+
+var GeoCalulator = function () {
+  function GeoCalulator() {}
+
+  GeoCalulator.computeDistanceKiloMeter = function (pos1, pos2) {
+    var dLat = this.deg2rad(pos2.lat - pos1.lat);
+    var dLon = this.deg2rad(pos2.lng - pos1.lng);
+    var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(this.deg2rad(pos1.lat)) * Math.cos(this.deg2rad(pos2.lat)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    var d = this.EARTH_RADIUS * c;
+    return d;
+  };
+
+  GeoCalulator.deg2rad = function (deg) {
+    return deg * (Math.PI / 180);
+  };
+
+  GeoCalulator.convertMeterToLatitudeValue = function (meter) {
+    return meter * this.LATITUDE_POSITION_VALUE_PER_METER;
+  };
+
+  GeoCalulator.computeNextPositionAndDistances = function (context) {
+    var pos1 = context.pos1,
+        pos2 = context.pos2,
+        prevPos2 = context.prevPos2,
+        velocityKmh = context.velocityKmh,
+        prevVelocityKmh = context.prevVelocityKmh,
+        elapsedTimeMs = context.elapsedTimeMs;
+
+    if (pos2 !== prevPos2) {
+      context.totalDistance = this.computeDistanceKiloMeter(pos1, pos2);
+      context.currDistance = 0;
+      context.prevPos2 = pos2;
+    }
+
+    var totalDistance = context.totalDistance;
+
+    if (velocityKmh !== prevVelocityKmh) {
+      context.vPerMs = velocityKmh / this.MS_FROM_HOUR;
+      context.prevVelocityKmh = velocityKmh;
+    }
+
+    var vPerMs = context.vPerMs;
+    var nextDistance = context.distanceRemain ? context.distanceRemain : context.currDistance + elapsedTimeMs * vPerMs;
+    context.currDistance = nextDistance;
+
+    if (totalDistance < context.currDistance) {
+      context.distanceRemain = context.currDistance - totalDistance;
+      context.nextPos = pos2;
+      return context;
+    } else {
+      context.distanceRemain = 0;
+    }
+
+    var ratio = nextDistance / totalDistance;
+    var latCalib = pos2.lat > pos1.lat ? 1 : -1;
+    var lngCalib = pos2.lng > pos1.lng ? 1 : -1;
+    var newPos = new MintMap.Position(pos1.lat + (pos2.lat - pos1.lat) * ratio, pos1.lng + (pos2.lng - pos1.lng) * ratio);
+
+    if ((latCalib === 1 && pos2.lat <= newPos.lat || latCalib === -1 && pos2.lat >= newPos.lat) && (lngCalib === 1 && pos2.lng <= newPos.lng || lngCalib === -1 && pos2.lng >= newPos.lng)) {
+      newPos = pos2;
+    }
+
+    context.nextPos = newPos;
+    return context;
+  };
+
+  GeoCalulator.EARTH_RADIUS = 6371;
+  GeoCalulator.LATITUDE_POSITION_VALUE_PER_METER = 1 / (110 * 1000);
+  GeoCalulator.MS_FROM_HOUR = 60 * 60 * 1000;
+  return GeoCalulator;
+}();
+
+exports.GeoCalulator = GeoCalulator;
+exports.PolygonCalculator = PolygonCalculator;

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

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

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

@@ -0,0 +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 default function MapControlWrapper({ width, height, positionHorizontal, positionVertical, children }: PropsWithChildren<MapControlWrapperProps>): JSX.Element;
+export {};