|
| 1 | +function _typeof(o) { |
| 2 | + "@babel/helpers - typeof"; |
| 3 | + return ( |
| 4 | + (_typeof = |
| 5 | + "function" == typeof Symbol && "symbol" == typeof Symbol.iterator |
| 6 | + ? function (o) { |
| 7 | + return typeof o; |
| 8 | + } |
| 9 | + : function (o) { |
| 10 | + return o && |
| 11 | + "function" == typeof Symbol && |
| 12 | + o.constructor === Symbol && |
| 13 | + o !== Symbol.prototype |
| 14 | + ? "symbol" |
| 15 | + : typeof o; |
| 16 | + }), |
| 17 | + _typeof(o) |
| 18 | + ); |
| 19 | +} |
| 20 | +var _excluded = ["children"]; |
| 21 | +function ownKeys(e, r) { |
| 22 | + var t = Object.keys(e); |
| 23 | + if (Object.getOwnPropertySymbols) { |
| 24 | + var o = Object.getOwnPropertySymbols(e); |
| 25 | + r && |
| 26 | + (o = o.filter(function (r) { |
| 27 | + return Object.getOwnPropertyDescriptor(e, r).enumerable; |
| 28 | + })), |
| 29 | + t.push.apply(t, o); |
| 30 | + } |
| 31 | + return t; |
| 32 | +} |
| 33 | +function _objectSpread(e) { |
| 34 | + for (var r = 1; r < arguments.length; r++) { |
| 35 | + var t = null != arguments[r] ? arguments[r] : {}; |
| 36 | + r % 2 |
| 37 | + ? ownKeys(Object(t), !0).forEach(function (r) { |
| 38 | + _defineProperty(e, r, t[r]); |
| 39 | + }) |
| 40 | + : Object.getOwnPropertyDescriptors |
| 41 | + ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) |
| 42 | + : ownKeys(Object(t)).forEach(function (r) { |
| 43 | + Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); |
| 44 | + }); |
| 45 | + } |
| 46 | + return e; |
| 47 | +} |
| 48 | +function _defineProperty(e, r, t) { |
| 49 | + return ( |
| 50 | + (r = _toPropertyKey(r)) in e |
| 51 | + ? Object.defineProperty(e, r, { |
| 52 | + value: t, |
| 53 | + enumerable: !0, |
| 54 | + configurable: !0, |
| 55 | + writable: !0, |
| 56 | + }) |
| 57 | + : (e[r] = t), |
| 58 | + e |
| 59 | + ); |
| 60 | +} |
| 61 | +function _toPropertyKey(t) { |
| 62 | + var i = _toPrimitive(t, "string"); |
| 63 | + return "symbol" == _typeof(i) ? i : i + ""; |
| 64 | +} |
| 65 | +function _toPrimitive(t, r) { |
| 66 | + if ("object" != _typeof(t) || !t) return t; |
| 67 | + var e = t[Symbol.toPrimitive]; |
| 68 | + if (void 0 !== e) { |
| 69 | + var i = e.call(t, r || "default"); |
| 70 | + if ("object" != _typeof(i)) return i; |
| 71 | + throw new TypeError("@@toPrimitive must return a primitive value."); |
| 72 | + } |
| 73 | + return ("string" === r ? String : Number)(t); |
| 74 | +} |
| 75 | +function _slicedToArray(r, e) { |
| 76 | + return ( |
| 77 | + _arrayWithHoles(r) || |
| 78 | + _iterableToArrayLimit(r, e) || |
| 79 | + _unsupportedIterableToArray(r, e) || |
| 80 | + _nonIterableRest() |
| 81 | + ); |
| 82 | +} |
| 83 | +function _nonIterableRest() { |
| 84 | + throw new TypeError( |
| 85 | + "Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.", |
| 86 | + ); |
| 87 | +} |
| 88 | +function _unsupportedIterableToArray(r, a) { |
| 89 | + if (r) { |
| 90 | + if ("string" == typeof r) return _arrayLikeToArray(r, a); |
| 91 | + var t = {}.toString.call(r).slice(8, -1); |
| 92 | + return ( |
| 93 | + "Object" === t && r.constructor && (t = r.constructor.name), |
| 94 | + "Map" === t || "Set" === t |
| 95 | + ? Array.from(r) |
| 96 | + : "Arguments" === t || |
| 97 | + /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) |
| 98 | + ? _arrayLikeToArray(r, a) |
| 99 | + : void 0 |
| 100 | + ); |
| 101 | + } |
| 102 | +} |
| 103 | +function _arrayLikeToArray(r, a) { |
| 104 | + (null == a || a > r.length) && (a = r.length); |
| 105 | + for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; |
| 106 | + return n; |
| 107 | +} |
| 108 | +function _iterableToArrayLimit(r, l) { |
| 109 | + var t = |
| 110 | + null == r |
| 111 | + ? null |
| 112 | + : ("undefined" != typeof Symbol && r[Symbol.iterator]) || r["@@iterator"]; |
| 113 | + if (null != t) { |
| 114 | + var e, |
| 115 | + n, |
| 116 | + i, |
| 117 | + u, |
| 118 | + a = [], |
| 119 | + f = !0, |
| 120 | + o = !1; |
| 121 | + try { |
| 122 | + if (((i = (t = t.call(r)).next), 0 === l)) { |
| 123 | + if (Object(t) !== t) return; |
| 124 | + f = !1; |
| 125 | + } else |
| 126 | + for ( |
| 127 | + ; |
| 128 | + !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); |
| 129 | + f = !0 |
| 130 | + ); |
| 131 | + } catch (r) { |
| 132 | + (o = !0), (n = r); |
| 133 | + } finally { |
| 134 | + try { |
| 135 | + if (!f && null != t.return && ((u = t.return()), Object(u) !== u)) |
| 136 | + return; |
| 137 | + } finally { |
| 138 | + if (o) throw n; |
| 139 | + } |
| 140 | + } |
| 141 | + return a; |
| 142 | + } |
| 143 | +} |
| 144 | +function _arrayWithHoles(r) { |
| 145 | + if (Array.isArray(r)) return r; |
| 146 | +} |
| 147 | +function _objectWithoutProperties(e, t) { |
| 148 | + if (null == e) return {}; |
| 149 | + var o, |
| 150 | + r, |
| 151 | + i = _objectWithoutPropertiesLoose(e, t); |
| 152 | + if (Object.getOwnPropertySymbols) { |
| 153 | + var s = Object.getOwnPropertySymbols(e); |
| 154 | + for (r = 0; r < s.length; r++) |
| 155 | + (o = s[r]), |
| 156 | + t.includes(o) || ({}.propertyIsEnumerable.call(e, o) && (i[o] = e[o])); |
| 157 | + } |
| 158 | + return i; |
| 159 | +} |
| 160 | +function _objectWithoutPropertiesLoose(r, e) { |
| 161 | + if (null == r) return {}; |
| 162 | + var t = {}; |
| 163 | + for (var n in r) |
| 164 | + if ({}.hasOwnProperty.call(r, n)) { |
| 165 | + if (e.includes(n)) continue; |
| 166 | + t[n] = r[n]; |
| 167 | + } |
| 168 | + return t; |
| 169 | +} |
| 170 | +import { createPathComponent } from "@react-leaflet/core"; |
| 171 | +import L from "leaflet"; |
| 172 | +import "leaflet.markercluster"; |
| 173 | +L.MarkerClusterGroup.include({ |
| 174 | + _flushLayerBuffer: function _flushLayerBuffer() { |
| 175 | + this.addLayers(this._layerBuffer); |
| 176 | + this._layerBuffer = []; |
| 177 | + }, |
| 178 | + addLayer: function addLayer(layer) { |
| 179 | + if (this._layerBuffer.length === 0) { |
| 180 | + setTimeout(this._flushLayerBuffer.bind(this), 50); |
| 181 | + } |
| 182 | + this._layerBuffer.push(layer); |
| 183 | + }, |
| 184 | +}); |
| 185 | +L.MarkerClusterGroup.addInitHook(function () { |
| 186 | + this._layerBuffer = []; |
| 187 | +}); |
| 188 | +function createMarkerCluster(_ref, context) { |
| 189 | + var _c = _ref.children, |
| 190 | + props = _objectWithoutProperties(_ref, _excluded); |
| 191 | + var clusterProps = {}; |
| 192 | + var clusterEvents = {}; |
| 193 | + |
| 194 | + // Splitting props and events to different objects |
| 195 | + Object.entries(props).forEach(function (_ref2) { |
| 196 | + var _ref3 = _slicedToArray(_ref2, 2), |
| 197 | + propName = _ref3[0], |
| 198 | + prop = _ref3[1]; |
| 199 | + return propName.startsWith("on") |
| 200 | + ? (clusterEvents[propName] = prop) |
| 201 | + : (clusterProps[propName] = prop); |
| 202 | + }); |
| 203 | + var instance = new L.MarkerClusterGroup(clusterProps); |
| 204 | + |
| 205 | + // Initializing event listeners |
| 206 | + Object.entries(clusterEvents).forEach(function (_ref4) { |
| 207 | + var _ref5 = _slicedToArray(_ref4, 2), |
| 208 | + eventAsProp = _ref5[0], |
| 209 | + callback = _ref5[1]; |
| 210 | + var clusterEvent = "cluster".concat(eventAsProp.substring(2).toLowerCase()); |
| 211 | + instance.on(clusterEvent, callback); |
| 212 | + }); |
| 213 | + return { |
| 214 | + instance: instance, |
| 215 | + context: _objectSpread( |
| 216 | + _objectSpread({}, context), |
| 217 | + {}, |
| 218 | + { |
| 219 | + layerContainer: instance, |
| 220 | + }, |
| 221 | + ), |
| 222 | + }; |
| 223 | +} |
| 224 | +var MarkerCluster = createPathComponent(createMarkerCluster); |
| 225 | +export default MarkerCluster; |
0 commit comments