778 lines
28 KiB
JavaScript
778 lines
28 KiB
JavaScript
import { DomUtil } from 'leaflet';
|
|
|
|
function _arrayLikeToArray(r, a) {
|
|
(null == a || a > r.length) && (a = r.length);
|
|
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
|
|
return n;
|
|
}
|
|
function _arrayWithHoles(r) {
|
|
if (Array.isArray(r)) return r;
|
|
}
|
|
function _assertClassBrand(e, t, n) {
|
|
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
|
|
throw new TypeError("Private element is not present on this object");
|
|
}
|
|
function _checkPrivateRedeclaration(e, t) {
|
|
if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
|
|
}
|
|
function _classCallCheck(a, n) {
|
|
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
function _classPrivateFieldGet2(s, a) {
|
|
return s.get(_assertClassBrand(s, a));
|
|
}
|
|
function _classPrivateFieldInitSpec(e, t, a) {
|
|
_checkPrivateRedeclaration(e, t), t.set(e, a);
|
|
}
|
|
function _classPrivateFieldSet2(s, a, r) {
|
|
return s.set(_assertClassBrand(s, a), r), r;
|
|
}
|
|
function _defineProperties(e, r) {
|
|
for (var t = 0; t < r.length; t++) {
|
|
var o = r[t];
|
|
o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
|
|
}
|
|
}
|
|
function _createClass(e, r, t) {
|
|
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
|
|
writable: !1
|
|
}), e;
|
|
}
|
|
function _defineProperty(e, r, t) {
|
|
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
|
|
value: t,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
writable: !0
|
|
}) : e[r] = t, e;
|
|
}
|
|
function _iterableToArrayLimit(r, l) {
|
|
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
|
|
if (null != t) {
|
|
var e,
|
|
n,
|
|
i,
|
|
u,
|
|
a = [],
|
|
f = !0,
|
|
o = !1;
|
|
try {
|
|
if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
|
|
} catch (r) {
|
|
o = !0, n = r;
|
|
} finally {
|
|
try {
|
|
if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
|
|
} finally {
|
|
if (o) throw n;
|
|
}
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
function _nonIterableRest() {
|
|
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
function _slicedToArray(r, e) {
|
|
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
|
|
}
|
|
function _toPrimitive(t, r) {
|
|
if ("object" != typeof t || !t) return t;
|
|
var e = t[Symbol.toPrimitive];
|
|
if (void 0 !== e) {
|
|
var i = e.call(t, r);
|
|
if ("object" != typeof i) return i;
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
return (String )(t);
|
|
}
|
|
function _toPropertyKey(t) {
|
|
var i = _toPrimitive(t, "string");
|
|
return "symbol" == typeof i ? i : i + "";
|
|
}
|
|
function _unsupportedIterableToArray(r, a) {
|
|
if (r) {
|
|
if ("string" == typeof r) return _arrayLikeToArray(r, a);
|
|
var t = {}.toString.call(r).slice(8, -1);
|
|
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
|
|
}
|
|
}
|
|
|
|
var BouncingOptions = /*#__PURE__*/function () {
|
|
function BouncingOptions(options) {
|
|
_classCallCheck(this, BouncingOptions);
|
|
/**
|
|
* How high marker can bounce (px)
|
|
* @type {number}
|
|
*/
|
|
_defineProperty(this, "bounceHeight", 15);
|
|
/**
|
|
* How much marker can contract (px)
|
|
* @type {number}
|
|
*/
|
|
_defineProperty(this, "contractHeight", 12);
|
|
/**
|
|
* Bouncing speed coefficient
|
|
* @type {number}
|
|
*/
|
|
_defineProperty(this, "bounceSpeed", 52);
|
|
/**
|
|
* Contracting speed coefficient
|
|
* @type {number}
|
|
*/
|
|
_defineProperty(this, "contractSpeed", 52);
|
|
/**
|
|
* Shadow inclination angle(radians); null to cancel shadow movement
|
|
* @type {number}
|
|
*/
|
|
_defineProperty(this, "shadowAngle", -Math.PI / 4);
|
|
/**
|
|
* Activate contract animation
|
|
* @type {boolean}
|
|
*/
|
|
_defineProperty(this, "elastic", true);
|
|
/**
|
|
* Many markers can bounce in the same time
|
|
* @type {boolean}
|
|
*/
|
|
_defineProperty(this, "exclusive", false);
|
|
/**
|
|
* If true, when marker stops, it does not execute animation until its end, but instead stops
|
|
* abruptly.
|
|
* @type {boolean}
|
|
*/
|
|
_defineProperty(this, "immediateStop", false);
|
|
options && Object.assign(this, options);
|
|
}
|
|
return _createClass(BouncingOptions, [{
|
|
key: "override",
|
|
value: function override(options) {
|
|
return Object.assign(new BouncingOptions(this), options);
|
|
}
|
|
}]);
|
|
}();
|
|
|
|
var _bouncingMarkers = /*#__PURE__*/new WeakMap();
|
|
var Orchestration = /*#__PURE__*/function () {
|
|
function Orchestration() {
|
|
_classCallCheck(this, Orchestration);
|
|
_classPrivateFieldInitSpec(this, _bouncingMarkers, []);
|
|
}
|
|
return _createClass(Orchestration, [{
|
|
key: "getBouncingMarkers",
|
|
value: function getBouncingMarkers() {
|
|
return _classPrivateFieldGet2(_bouncingMarkers, this);
|
|
}
|
|
|
|
/**
|
|
* Adds the marker to the list of bouncing markers.
|
|
* If flag 'exclusive' is set to true, stops all bouncing markers before.
|
|
*
|
|
* @param marker {Marker} marker object
|
|
* @param exclusive {boolean} flag of exclusive bouncing. If set to true, stops the bouncing
|
|
* of all other markers.
|
|
*/
|
|
}, {
|
|
key: "addBouncingMarker",
|
|
value: function addBouncingMarker(marker, exclusive) {
|
|
if (exclusive || marker._bouncingMotion.bouncingOptions.exclusive) {
|
|
this.stopAllBouncingMarkers();
|
|
} else {
|
|
this.stopExclusiveMarkerBouncing();
|
|
}
|
|
_classPrivateFieldGet2(_bouncingMarkers, this).push(marker);
|
|
}
|
|
|
|
/**
|
|
* Stops the bouncing of exclusive marker.
|
|
*/
|
|
}, {
|
|
key: "stopExclusiveMarkerBouncing",
|
|
value: function stopExclusiveMarkerBouncing() {
|
|
var exclusiveMarker = _classPrivateFieldGet2(_bouncingMarkers, this).find(function (marker) {
|
|
return marker._bouncingMotion.bouncingOptions.exclusive;
|
|
});
|
|
if (exclusiveMarker) {
|
|
exclusiveMarker.stopBouncing();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the marker from the list of bouncing markers.
|
|
* @param marker {Marker} marker
|
|
*/
|
|
}, {
|
|
key: "removeBouncingMarker",
|
|
value: function removeBouncingMarker(marker) {
|
|
var i = _classPrivateFieldGet2(_bouncingMarkers, this).indexOf(marker);
|
|
if (~i) {
|
|
_classPrivateFieldGet2(_bouncingMarkers, this).splice(i, 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
|
|
*
|
|
* @param immediate {boolean} if true, markers stop to bounce immediately, without waiting
|
|
* animation to end
|
|
*/
|
|
}, {
|
|
key: "stopAllBouncingMarkers",
|
|
value: function stopAllBouncingMarkers() {
|
|
var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
var marker;
|
|
while (marker = _classPrivateFieldGet2(_bouncingMarkers, this).shift()) {
|
|
marker.stopBouncing(immediate);
|
|
}
|
|
}
|
|
}]);
|
|
}();
|
|
|
|
function MarkerPrototypeExt(Leaflet) {
|
|
var oldSetPos = Leaflet.Marker.prototype._setPos;
|
|
var oldOnAdd = Leaflet.Marker.prototype.onAdd;
|
|
var oldSetIcon = Leaflet.Marker.prototype.setIcon;
|
|
return {
|
|
/** Bouncing options shared by all markers. */
|
|
_bouncingOptions: new BouncingOptions(),
|
|
_orchestration: new Orchestration(),
|
|
_realMarker: true,
|
|
/**
|
|
* Registers options of bouncing animation for this marker. After registration of options for
|
|
* this marker, it will ignore changes of default options. Function automatically recalculates
|
|
* animation steps and delays.
|
|
*
|
|
* @param options {BouncingOptions} options object
|
|
* @return {Marker} this marker
|
|
*/
|
|
setBouncingOptions: function setBouncingOptions(options) {
|
|
this._bouncingMotion.updateBouncingOptions(options);
|
|
return this;
|
|
},
|
|
/**
|
|
* Returns true if this marker is bouncing. If this marker is not bouncing returns false.
|
|
* @return {boolean} true if marker is bouncing, false if not
|
|
*/
|
|
isBouncing: function isBouncing() {
|
|
return this._bouncingMotion.isBouncing;
|
|
},
|
|
/**
|
|
* Starts bouncing of this marker.
|
|
* @param times {number|null} number of times the marker must to bounce
|
|
* @return {Marker} this marker
|
|
*/
|
|
bounce: function bounce() {
|
|
var _this = this;
|
|
var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
|
if (times) {
|
|
this._bouncingMotion.onMotionEnd = function () {
|
|
Leaflet.Marker.prototype._orchestration.removeBouncingMarker(_this);
|
|
};
|
|
}
|
|
this._bouncingMotion.bounce(times);
|
|
var exclusive = this._bouncingMotion.bouncingOptions.exclusive;
|
|
Leaflet.Marker.prototype._orchestration.addBouncingMarker(this, exclusive);
|
|
return this;
|
|
},
|
|
/**
|
|
* Stops bouncing of this marker.
|
|
* Note: unless 'immediate' flag is set to true, by the call to this method or in marker options,
|
|
* the bouncing will not stop immediately after the call of this method. Instead, the animation
|
|
* is executed until marker returns to its original position and takes its full size.
|
|
*
|
|
* @param immediate {boolean} if true, marker stop to bounce immediately, without waiting
|
|
* animation to end
|
|
* @return {Marker} this marker
|
|
*/
|
|
stopBouncing: function stopBouncing() {
|
|
var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
this._bouncingMotion.stopBouncing(immediate);
|
|
Leaflet.Marker.prototype._orchestration.removeBouncingMarker(this);
|
|
return this;
|
|
},
|
|
/**
|
|
* Starts/stops bouncing of this marker.
|
|
* @return {Marker} marker
|
|
*/
|
|
toggleBouncing: function toggleBouncing() {
|
|
if (this._bouncingMotion.isBouncing) {
|
|
this.stopBouncing();
|
|
} else {
|
|
this.bounce();
|
|
}
|
|
return this;
|
|
},
|
|
isRealMarker: function isRealMarker() {
|
|
return Object.hasOwn(this.__proto__, '_realMarker');
|
|
},
|
|
_setPos: function _setPos(position) {
|
|
oldSetPos.call(this, position);
|
|
if (this.isRealMarker()) {
|
|
this._bouncingMotion.position = position;
|
|
this._bouncingMotion.resetStyles(this);
|
|
}
|
|
},
|
|
onAdd: function onAdd(map) {
|
|
oldOnAdd.call(this, map);
|
|
if (this.isRealMarker()) {
|
|
this._bouncingMotion.resetStyles(this);
|
|
}
|
|
},
|
|
setIcon: function setIcon(icon) {
|
|
oldSetIcon.call(this, icon);
|
|
if (this.isRealMarker() && this._icon) {
|
|
this._bouncingMotion.resetStyles(this);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Calculates the points to draw the continous line on the screen. Returns the array of ordered
|
|
* point coordinates. Uses Bresenham algorithm.
|
|
*
|
|
* @param x {number} x coordinate of origin
|
|
* @param y {number} y coordinate of origin
|
|
* @param angle {number} angle (radians)
|
|
* @param length {number} length of line (px)
|
|
*
|
|
* @return {[number, number][]} array of ordered point coordinates
|
|
*
|
|
* @see http://rosettacode.org/wiki/Bitmap/Bresenham's_line_algorithm#JavaScript
|
|
*/
|
|
function calculateLine(x, y, angle, length) {
|
|
// TODO: use something else than multiply length by 2 to calculate the line with defined
|
|
// length
|
|
var xD = Math.round(x + Math.cos(angle) * (length * 2)),
|
|
yD = Math.round(y + Math.sin(angle) * (length * 2)),
|
|
dx = Math.abs(xD - x),
|
|
sx = x < xD ? 1 : -1,
|
|
dy = Math.abs(yD - y),
|
|
sy = y < yD ? 1 : -1,
|
|
err = (dx > dy ? dx : -dy) / 2,
|
|
e2,
|
|
p = [],
|
|
i = 0;
|
|
while (true) {
|
|
p.push([x, y]);
|
|
i++;
|
|
if (i === length) break;
|
|
e2 = err;
|
|
if (e2 > -dx) {
|
|
err -= dy;
|
|
x += sx;
|
|
}
|
|
if (e2 < dy) {
|
|
err += dx;
|
|
y += sy;
|
|
}
|
|
}
|
|
return p;
|
|
}
|
|
|
|
function styleInject(css, ref) {
|
|
if ( ref === void 0 ) ref = {};
|
|
var insertAt = ref.insertAt;
|
|
|
|
if (typeof document === 'undefined') { return; }
|
|
|
|
var head = document.head || document.getElementsByTagName('head')[0];
|
|
var style = document.createElement('style');
|
|
style.type = 'text/css';
|
|
|
|
if (insertAt === 'top') {
|
|
if (head.firstChild) {
|
|
head.insertBefore(style, head.firstChild);
|
|
} else {
|
|
head.appendChild(style);
|
|
}
|
|
} else {
|
|
head.appendChild(style);
|
|
}
|
|
|
|
if (style.styleSheet) {
|
|
style.styleSheet.cssText = css;
|
|
} else {
|
|
style.appendChild(document.createTextNode(css));
|
|
}
|
|
}
|
|
|
|
var css_248z = "@keyframes l-smooth-marker-bouncing-move {\n from {\n transform: translate(var(--pos-x), var(--pos-y))\n }\n to {\n transform: translate(var(--pos-x-jump, var(--pos-x)), var(--pos-y-jump))\n }\n}\n\n@keyframes l-smooth-marker-bouncing-contract {\n from {\n transform: translate(var(--pos-x), var(--pos-y))\n }\n to {\n transform: translate(var(--pos-x), var(--pos-y-contract)) scaleY(var(--scale-contract))\n }\n}\n\n.bouncing {\n animation-name: l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-contract, l-smooth-marker-bouncing-contract;\n animation-direction: normal, reverse, normal, reverse;\n animation-duration: var(--duration-jump), var(--duration-jump), var(--duration-contract), var(--duration-contract);\n animation-delay: var(--delays)\n}\n\n.bouncing.simple {\n animation-name: l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-move;\n animation-direction: normal, reverse;\n animation-duration: var(--duration-jump), var(--duration-jump);\n animation-delay: var(--delays)\n}\n";
|
|
styleInject(css_248z);
|
|
|
|
/** Regex to parse style definitions. */
|
|
var regStyle = /([\w-]+): ([^;]+);/g;
|
|
var Styles = /*#__PURE__*/function () {
|
|
function Styles(styles) {
|
|
_classCallCheck(this, Styles);
|
|
styles && Object.assign(this, styles);
|
|
}
|
|
return _createClass(Styles, [{
|
|
key: "findOpacity",
|
|
value: function findOpacity(options) {
|
|
this.opacity = (options === null || options === void 0 ? void 0 : options.opacityWhenUnclustered // used by cluster plugin
|
|
) || (options === null || options === void 0 ? void 0 : options.opacity) || 1;
|
|
}
|
|
|
|
/**
|
|
* Creates a copy of styles merged with provided 'styles'.
|
|
* @param {Object} styles object with styles to merge
|
|
* @return {Styles} copy of styles
|
|
*/
|
|
}, {
|
|
key: "withStyles",
|
|
value: function withStyles(styles) {
|
|
var copy = new Styles(this);
|
|
copy && Object.assign(copy, styles);
|
|
return copy;
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return Object.entries(this).map(function (entry) {
|
|
return "".concat(entry[0], ": ").concat(entry[1], ";");
|
|
}).join(' ');
|
|
}
|
|
|
|
/**
|
|
* Parses cssText attribute into Styles object.
|
|
* @param cssText {string} cssText string
|
|
* @return {Styles} Styles object
|
|
*/
|
|
}], [{
|
|
key: "parse",
|
|
value: function parse(cssText) {
|
|
var styles = {};
|
|
var match = regStyle.exec(cssText);
|
|
while (match) {
|
|
styles[match[1]] = match[2];
|
|
match = regStyle.exec(cssText);
|
|
}
|
|
delete styles['z-index'];
|
|
delete styles['opacity'];
|
|
styles['outline'] = 'none';
|
|
return new Styles(styles);
|
|
}
|
|
|
|
/**
|
|
* @param marker {Marker}
|
|
*/
|
|
}, {
|
|
key: "ofMarker",
|
|
value: function ofMarker(marker) {
|
|
var styles = Styles.parse(marker._icon.style.cssText);
|
|
styles.findOpacity(marker.options);
|
|
styles['z-index'] = marker._zIndex;
|
|
return styles;
|
|
}
|
|
}]);
|
|
}();
|
|
|
|
var animationNamePrefix = 'l-smooth-marker-bouncing-';
|
|
var moveAnimationName = animationNamePrefix + 'move';
|
|
var contractAnimationName = animationNamePrefix + 'contract';
|
|
|
|
/*
|
|
* CSS3 animation runs faster than transform-based animation. We need to reduce speed in order
|
|
* to be compatible with old API.
|
|
*/
|
|
var speedCoefficient = 0.8;
|
|
|
|
/**
|
|
* Removes and then resets required classes on the HTML element.
|
|
* Used as hack to restart CSS3 animation.
|
|
*
|
|
* @param element {HTMLElement} HTML element
|
|
* @param classes {string[]} names of classes
|
|
*/
|
|
function resetClasses(element, classes) {
|
|
classes.forEach(function (className) {
|
|
return DomUtil.removeClass(element, className);
|
|
});
|
|
void element.offsetWidth;
|
|
classes.forEach(function (className) {
|
|
return DomUtil.addClass(element, className);
|
|
});
|
|
}
|
|
var _lastAnimationName = /*#__PURE__*/new WeakMap();
|
|
var _classes = /*#__PURE__*/new WeakMap();
|
|
var _eventCounter = /*#__PURE__*/new WeakMap();
|
|
var _times = /*#__PURE__*/new WeakMap();
|
|
var _listener = /*#__PURE__*/new WeakMap();
|
|
var BouncingMotionCss3 = /*#__PURE__*/function () {
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param marker {Marker} marker
|
|
* @param position {Point} marker current position on the map canvas
|
|
* @param bouncingOptions {BouncingOptions} options of bouncing animation
|
|
*/
|
|
function BouncingMotionCss3(marker, position, bouncingOptions) {
|
|
var _this = this;
|
|
_classCallCheck(this, BouncingMotionCss3);
|
|
_defineProperty(this, "marker", void 0);
|
|
_defineProperty(this, "position", void 0);
|
|
_defineProperty(this, "bouncingOptions", void 0);
|
|
_defineProperty(this, "isBouncing", false);
|
|
_defineProperty(this, "iconStyles", void 0);
|
|
_defineProperty(this, "shadowStyles", void 0);
|
|
_defineProperty(this, "bouncingAnimationPlaying", false);
|
|
_defineProperty(this, "onMotionEnd", void 0);
|
|
_classPrivateFieldInitSpec(this, _lastAnimationName, contractAnimationName);
|
|
_classPrivateFieldInitSpec(this, _classes, ['bouncing']);
|
|
_classPrivateFieldInitSpec(this, _eventCounter, void 0);
|
|
_classPrivateFieldInitSpec(this, _times, void 0);
|
|
_classPrivateFieldInitSpec(this, _listener, function (event) {
|
|
return _this.onAnimationEnd(event);
|
|
});
|
|
this.marker = marker;
|
|
this.position = position;
|
|
this.updateBouncingOptions(bouncingOptions);
|
|
}
|
|
return _createClass(BouncingMotionCss3, [{
|
|
key: "updateBouncingOptions",
|
|
value: function updateBouncingOptions(options) {
|
|
this.bouncingOptions = options instanceof BouncingOptions ? options : this.bouncingOptions.override(options);
|
|
if (this.bouncingOptions.elastic && this.bouncingOptions.contractHeight) {
|
|
_classPrivateFieldSet2(_lastAnimationName, this, contractAnimationName);
|
|
var index = _classPrivateFieldGet2(_classes, this).indexOf('simple');
|
|
if (index > -1) {
|
|
_classPrivateFieldGet2(_classes, this).splice(index, 1);
|
|
}
|
|
if (this.marker._icon) {
|
|
DomUtil.removeClass(this.marker._icon, 'simple');
|
|
}
|
|
} else {
|
|
_classPrivateFieldSet2(_lastAnimationName, this, moveAnimationName);
|
|
_classPrivateFieldGet2(_classes, this).push('simple');
|
|
}
|
|
if (this.marker._icon) {
|
|
this.resetStyles(this.marker);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onAnimationEnd",
|
|
value: function onAnimationEnd(event) {
|
|
if (event.animationName === _classPrivateFieldGet2(_lastAnimationName, this)) {
|
|
var _this$eventCounter;
|
|
_classPrivateFieldSet2(_eventCounter, this, (_this$eventCounter = _classPrivateFieldGet2(_eventCounter, this), _this$eventCounter++, _this$eventCounter));
|
|
_classPrivateFieldSet2(_eventCounter, this, _classPrivateFieldGet2(_eventCounter, this) % 2);
|
|
if (!_classPrivateFieldGet2(_eventCounter, this)) {
|
|
var _this$times;
|
|
if (this.isBouncing && (_classPrivateFieldGet2(_times, this) === null || _classPrivateFieldSet2(_times, this, (_this$times = _classPrivateFieldGet2(_times, this), --_this$times)))) {
|
|
resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
|
|
if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
|
|
resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
|
|
}
|
|
} else {
|
|
this._stopBouncingAnimation();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "resetStyles",
|
|
value: function resetStyles(marker) {
|
|
var _this$marker$getIcon,
|
|
_this$marker,
|
|
_this2 = this;
|
|
this.marker = marker;
|
|
this.iconStyles = Styles.ofMarker(marker);
|
|
if (marker._shadow) {
|
|
this.shadowStyles = Styles.parse(marker._shadow.style.cssText);
|
|
}
|
|
var iconHeight = ((_this$marker$getIcon = this.marker.getIcon()) === null || _this$marker$getIcon === void 0 || (_this$marker$getIcon = _this$marker$getIcon.options) === null || _this$marker$getIcon === void 0 ? void 0 : _this$marker$getIcon.iconSize[1]) || ((_this$marker = this.marker) === null || _this$marker === void 0 || (_this$marker = _this$marker._iconObj) === null || _this$marker === void 0 || (_this$marker = _this$marker.options) === null || _this$marker === void 0 ? void 0 : _this$marker.iconSize[1]);
|
|
var iconAnimationParams = BouncingMotionCss3.animationParams(this.position, this.bouncingOptions, iconHeight);
|
|
this.iconStyles = this.iconStyles.withStyles(iconAnimationParams);
|
|
this.marker._icon.style.cssText = this.iconStyles.toString();
|
|
if (this.bouncingAnimationPlaying) {
|
|
resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
|
|
this.marker._icon.addEventListener('animationend', _classPrivateFieldGet2(_listener, this));
|
|
}
|
|
var _this$bouncingOptions = this.bouncingOptions,
|
|
bounceHeight = _this$bouncingOptions.bounceHeight,
|
|
contractHeight = _this$bouncingOptions.contractHeight,
|
|
shadowAngle = _this$bouncingOptions.shadowAngle;
|
|
if (this.marker._shadow) {
|
|
if (shadowAngle) {
|
|
var _this$marker$getIcon2;
|
|
var _this$position = this.position,
|
|
x = _this$position.x,
|
|
y = _this$position.y;
|
|
var points = calculateLine(x, y, shadowAngle, bounceHeight + 1);
|
|
var _points$bounceHeight = _slicedToArray(points[bounceHeight], 2),
|
|
posXJump = _points$bounceHeight[0],
|
|
posYJump = _points$bounceHeight[1];
|
|
var shadowHeight = (_this$marker$getIcon2 = this.marker.getIcon()) === null || _this$marker$getIcon2 === void 0 || (_this$marker$getIcon2 = _this$marker$getIcon2.options) === null || _this$marker$getIcon2 === void 0 ? void 0 : _this$marker$getIcon2.shadowSize[1];
|
|
var shadowScaleContract = BouncingMotionCss3.contractScale(shadowHeight, contractHeight);
|
|
this.shadowStyles = this.shadowStyles.withStyles(iconAnimationParams).withStyles({
|
|
'--pos-x-jump': "".concat(posXJump, "px"),
|
|
'--pos-y-jump': "".concat(posYJump, "px"),
|
|
'--scale-contract': shadowScaleContract
|
|
});
|
|
this.marker._shadow.style.cssText = this.shadowStyles.toString();
|
|
if (this.bouncingAnimationPlaying) {
|
|
resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
|
|
}
|
|
} else {
|
|
_classPrivateFieldGet2(_classes, this).forEach(function (className) {
|
|
DomUtil.removeClass(_this2.marker._shadow, className);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "bounce",
|
|
value: function bounce() {
|
|
var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
|
_classPrivateFieldSet2(_times, this, times);
|
|
this.isBouncing = true;
|
|
if (this.bouncingAnimationPlaying) {
|
|
return;
|
|
}
|
|
_classPrivateFieldSet2(_eventCounter, this, 0);
|
|
this.bouncingAnimationPlaying = true;
|
|
resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
|
|
if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
|
|
resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
|
|
}
|
|
this.marker._icon.addEventListener('animationend', _classPrivateFieldGet2(_listener, this));
|
|
}
|
|
}, {
|
|
key: "stopBouncing",
|
|
value: function stopBouncing() {
|
|
var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
this.isBouncing = false;
|
|
immediate || (immediate = this.bouncingOptions.immediateStop);
|
|
if (immediate) {
|
|
this._stopBouncingAnimation();
|
|
}
|
|
}
|
|
}, {
|
|
key: "_stopBouncingAnimation",
|
|
value: function _stopBouncingAnimation() {
|
|
var _this3 = this;
|
|
_classPrivateFieldGet2(_classes, this).forEach(function (className) {
|
|
DomUtil.removeClass(_this3.marker._icon, className);
|
|
if (_this3.marker._shadow) {
|
|
DomUtil.removeClass(_this3.marker._shadow, className);
|
|
}
|
|
});
|
|
this.bouncingAnimationPlaying = false;
|
|
if (this.onMotionEnd) {
|
|
this.onMotionEnd();
|
|
this.onMotionEnd = null;
|
|
}
|
|
this.marker.fire('bounceend');
|
|
}
|
|
|
|
/**
|
|
* Calculates parameters of CSS3 animation of bouncing.
|
|
*
|
|
* @param position {Point} marker current position on the map canvas
|
|
* @param bouncingOptions {BouncingOptions} options of bouncing animation
|
|
* @param height {number} icons height
|
|
* @return {object} CSS3 animation parameters
|
|
*/
|
|
}], [{
|
|
key: "animationParams",
|
|
value: function animationParams(position, bouncingOptions, height) {
|
|
var x = position.x,
|
|
y = position.y;
|
|
var bounceHeight = bouncingOptions.bounceHeight,
|
|
contractHeight = bouncingOptions.contractHeight,
|
|
bounceSpeed = bouncingOptions.bounceSpeed,
|
|
contractSpeed = bouncingOptions.contractSpeed;
|
|
var scaleContract = BouncingMotionCss3.contractScale(height, contractHeight);
|
|
var durationJump = BouncingMotionCss3.calculateDuration(bounceHeight, bounceSpeed);
|
|
var durationContract = BouncingMotionCss3.calculateDuration(contractHeight, contractSpeed);
|
|
var delays = [0, durationJump, durationJump * 2, durationJump * 2 + durationContract];
|
|
return {
|
|
'--pos-x': "".concat(x, "px"),
|
|
'--pos-y': "".concat(y, "px"),
|
|
'--pos-y-jump': "".concat(y - bounceHeight, "px"),
|
|
'--pos-y-contract': "".concat(y + contractHeight, "px"),
|
|
'--scale-contract': scaleContract,
|
|
'--duration-jump': "".concat(durationJump, "ms"),
|
|
'--duration-contract': "".concat(durationContract, "ms"),
|
|
'--delays': "0ms, ".concat(delays[1], "ms, ").concat(delays[2], "ms, ").concat(delays[3], "ms")
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Calculates scale of contracting.
|
|
*
|
|
* @param {number} height original height
|
|
* @param {number} contractHeight how much it must contract
|
|
* @return {number} contracting scale between 0 and 1
|
|
*/
|
|
}, {
|
|
key: "contractScale",
|
|
value: function contractScale(height, contractHeight) {
|
|
return (height - contractHeight) / height;
|
|
}
|
|
|
|
/**
|
|
* Calculates duration of animation.
|
|
*
|
|
* @param height {number} height of movement or resizing (px)
|
|
* @param speed {number} speed coefficient
|
|
*
|
|
* @return {number} duration of animation (ms)
|
|
*/
|
|
}, {
|
|
key: "calculateDuration",
|
|
value: function calculateDuration(height, speed) {
|
|
if (height === 0) {
|
|
return 0;
|
|
}
|
|
var duration = Math.round(speed * speedCoefficient);
|
|
var i = height;
|
|
while (--i) {
|
|
duration += Math.round(speed / (height - i));
|
|
}
|
|
return duration;
|
|
}
|
|
}]);
|
|
}();
|
|
|
|
function SmoothMarkerBouncing(Leaflet) {
|
|
Leaflet.Marker.include(MarkerPrototypeExt(Leaflet));
|
|
|
|
/**
|
|
* Registers default options of bouncing animation.
|
|
* @param options {BouncingOptions|object} object with options
|
|
*/
|
|
Leaflet.Marker.setBouncingOptions = function (options) {
|
|
Leaflet.Marker.prototype._bouncingOptions = options instanceof BouncingOptions ? options : new BouncingOptions(options);
|
|
};
|
|
|
|
/**
|
|
* Returns array of currently bouncing markers.
|
|
* @return {Marker[]} array of bouncing markers
|
|
*/
|
|
Leaflet.Marker.getBouncingMarkers = function () {
|
|
return Leaflet.Marker.prototype._orchestration.getBouncingMarkers();
|
|
};
|
|
|
|
/**
|
|
* Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
|
|
*
|
|
* @param immediate {boolean} if true, markers stop to bounce immediately, without waiting
|
|
* animation to end
|
|
*/
|
|
Leaflet.Marker.stopAllBouncingMarkers = function () {
|
|
var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
Leaflet.Marker.prototype._orchestration.stopAllBouncingMarkers(immediate);
|
|
};
|
|
Leaflet.Marker.addInitHook(function () {
|
|
if (this.isRealMarker()) {
|
|
var bouncingOptions = new BouncingOptions(Leaflet.Marker.prototype._bouncingOptions);
|
|
this._bouncingMotion = new BouncingMotionCss3(this, new Leaflet.Point(0, 0), bouncingOptions);
|
|
}
|
|
});
|
|
return Leaflet;
|
|
}
|
|
|
|
export { SmoothMarkerBouncing as default };
|