@stangres/react-leaflet
Version:
React components for Leaflet maps
1,428 lines (1,173 loc) • 94.7 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('leaflet'), require('react-dom')) :
typeof define === 'function' && define.amd ? define(['exports', 'react', 'leaflet', 'react-dom'], factory) :
(global = global || self, factory(global.ReactLeaflet = {}, global.React, global.L, global.ReactDOM));
}(this, function (exports, React, leaflet, reactDom) { 'use strict';
var React__default = 'default' in React ? React['default'] : React;
function unwrapExports (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var _extends_1 = createCommonjsModule(function (module) {
function _extends() {
module.exports = _extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
module.exports = _extends;
});
var reactIs_development = createCommonjsModule(function (module, exports) {
{
(function() {
Object.defineProperty(exports, '__esModule', { value: true });
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var hasSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;
var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
function isValidElementType(type) {
return typeof type === 'string' || typeof type === 'function' ||
// Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
}
/**
* Forked from fbjs/warning:
* https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
*
* Only change is we use console.warn instead of console.error,
* and do nothing when 'console' is not supported.
* This really simplifies the code.
* ---
* Similar to invariant but only logs a warning if the condition is not met.
* This can be used to log issues in development environments in critical
* paths. Removing the logging code for production environments will keep the
* same logic and follow the same code paths.
*/
var lowPriorityWarning = function () {};
{
var printWarning = function (format) {
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
var argIndex = 0;
var message = 'Warning: ' + format.replace(/%s/g, function () {
return args[argIndex++];
});
if (typeof console !== 'undefined') {
console.warn(message);
}
try {
// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
throw new Error(message);
} catch (x) {}
};
lowPriorityWarning = function (condition, format) {
if (format === undefined) {
throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
}
if (!condition) {
for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
args[_key2 - 2] = arguments[_key2];
}
printWarning.apply(undefined, [format].concat(args));
}
};
}
var lowPriorityWarning$1 = lowPriorityWarning;
function typeOf(object) {
if (typeof object === 'object' && object !== null) {
var $$typeof = object.$$typeof;
switch ($$typeof) {
case REACT_ELEMENT_TYPE:
var type = object.type;
switch (type) {
case REACT_ASYNC_MODE_TYPE:
case REACT_CONCURRENT_MODE_TYPE:
case REACT_FRAGMENT_TYPE:
case REACT_PROFILER_TYPE:
case REACT_STRICT_MODE_TYPE:
case REACT_SUSPENSE_TYPE:
return type;
default:
var $$typeofType = type && type.$$typeof;
switch ($$typeofType) {
case REACT_CONTEXT_TYPE:
case REACT_FORWARD_REF_TYPE:
case REACT_PROVIDER_TYPE:
return $$typeofType;
default:
return $$typeof;
}
}
case REACT_LAZY_TYPE:
case REACT_MEMO_TYPE:
case REACT_PORTAL_TYPE:
return $$typeof;
}
}
return undefined;
}
// AsyncMode is deprecated along with isAsyncMode
var AsyncMode = REACT_ASYNC_MODE_TYPE;
var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false;
// AsyncMode should be deprecated
function isAsyncMode(object) {
{
if (!hasWarnedAboutDeprecatedIsAsyncMode) {
hasWarnedAboutDeprecatedIsAsyncMode = true;
lowPriorityWarning$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
}
}
return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
}
function isConcurrentMode(object) {
return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
}
function isContextConsumer(object) {
return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement(object) {
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
return typeOf(object) === REACT_SUSPENSE_TYPE;
}
exports.typeOf = typeOf;
exports.AsyncMode = AsyncMode;
exports.ConcurrentMode = ConcurrentMode;
exports.ContextConsumer = ContextConsumer;
exports.ContextProvider = ContextProvider;
exports.Element = Element;
exports.ForwardRef = ForwardRef;
exports.Fragment = Fragment;
exports.Lazy = Lazy;
exports.Memo = Memo;
exports.Portal = Portal;
exports.Profiler = Profiler;
exports.StrictMode = StrictMode;
exports.Suspense = Suspense;
exports.isValidElementType = isValidElementType;
exports.isAsyncMode = isAsyncMode;
exports.isConcurrentMode = isConcurrentMode;
exports.isContextConsumer = isContextConsumer;
exports.isContextProvider = isContextProvider;
exports.isElement = isElement;
exports.isForwardRef = isForwardRef;
exports.isFragment = isFragment;
exports.isLazy = isLazy;
exports.isMemo = isMemo;
exports.isPortal = isPortal;
exports.isProfiler = isProfiler;
exports.isStrictMode = isStrictMode;
exports.isSuspense = isSuspense;
})();
}
});
unwrapExports(reactIs_development);
var reactIs_development_1 = reactIs_development.typeOf;
var reactIs_development_2 = reactIs_development.AsyncMode;
var reactIs_development_3 = reactIs_development.ConcurrentMode;
var reactIs_development_4 = reactIs_development.ContextConsumer;
var reactIs_development_5 = reactIs_development.ContextProvider;
var reactIs_development_6 = reactIs_development.Element;
var reactIs_development_7 = reactIs_development.ForwardRef;
var reactIs_development_8 = reactIs_development.Fragment;
var reactIs_development_9 = reactIs_development.Lazy;
var reactIs_development_10 = reactIs_development.Memo;
var reactIs_development_11 = reactIs_development.Portal;
var reactIs_development_12 = reactIs_development.Profiler;
var reactIs_development_13 = reactIs_development.StrictMode;
var reactIs_development_14 = reactIs_development.Suspense;
var reactIs_development_15 = reactIs_development.isValidElementType;
var reactIs_development_16 = reactIs_development.isAsyncMode;
var reactIs_development_17 = reactIs_development.isConcurrentMode;
var reactIs_development_18 = reactIs_development.isContextConsumer;
var reactIs_development_19 = reactIs_development.isContextProvider;
var reactIs_development_20 = reactIs_development.isElement;
var reactIs_development_21 = reactIs_development.isForwardRef;
var reactIs_development_22 = reactIs_development.isFragment;
var reactIs_development_23 = reactIs_development.isLazy;
var reactIs_development_24 = reactIs_development.isMemo;
var reactIs_development_25 = reactIs_development.isPortal;
var reactIs_development_26 = reactIs_development.isProfiler;
var reactIs_development_27 = reactIs_development.isStrictMode;
var reactIs_development_28 = reactIs_development.isSuspense;
var reactIs = createCommonjsModule(function (module) {
{
module.exports = reactIs_development;
}
});
/**
* Copyright 2015, Yahoo! Inc.
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var REACT_STATICS = {
childContextTypes: true,
contextType: true,
contextTypes: true,
defaultProps: true,
displayName: true,
getDefaultProps: true,
getDerivedStateFromError: true,
getDerivedStateFromProps: true,
mixins: true,
propTypes: true,
type: true
};
var KNOWN_STATICS = {
name: true,
length: true,
prototype: true,
caller: true,
callee: true,
arguments: true,
arity: true
};
var FORWARD_REF_STATICS = {
'$$typeof': true,
render: true,
defaultProps: true,
displayName: true,
propTypes: true
};
var MEMO_STATICS = {
'$$typeof': true,
compare: true,
defaultProps: true,
displayName: true,
propTypes: true,
type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
function getStatics(component) {
if (reactIs.isMemo(component)) {
return MEMO_STATICS;
}
return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
}
var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
if (typeof sourceComponent !== 'string') {
// don't hoist over string (html) components
if (objectPrototype) {
var inheritedComponent = getPrototypeOf(sourceComponent);
if (inheritedComponent && inheritedComponent !== objectPrototype) {
hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
}
}
var keys = getOwnPropertyNames(sourceComponent);
if (getOwnPropertySymbols) {
keys = keys.concat(getOwnPropertySymbols(sourceComponent));
}
var targetStatics = getStatics(targetComponent);
var sourceStatics = getStatics(sourceComponent);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
try {
// Avoid failures from read-only properties
defineProperty(targetComponent, key, descriptor);
} catch (e) {}
}
}
return targetComponent;
}
return targetComponent;
}
var hoistNonReactStatics_cjs = hoistNonReactStatics;
var leafletContext = React.createContext({});
var useLeaflet = function useLeaflet() {
return React.useContext(leafletContext);
};
var LeafletConsumer = leafletContext.Consumer;
var LeafletProvider = leafletContext.Provider;
var withLeaflet = function withLeaflet(WrappedComponent) {
var WithLeafletComponent = function WithLeafletComponent(props, ref) {
return React__default.createElement(LeafletConsumer, null, function (leaflet) {
return React__default.createElement(WrappedComponent, _extends_1({}, props, {
leaflet: leaflet,
ref: ref
}));
});
};
var name = // flowlint-next-line sketchy-null-string:off
WrappedComponent.displayName || WrappedComponent.name || 'Component';
WithLeafletComponent.displayName = "Leaflet(".concat(name, ")");
var LeafletComponent = React.forwardRef(WithLeafletComponent);
hoistNonReactStatics_cjs(LeafletComponent, WrappedComponent);
return LeafletComponent;
};
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
var classCallCheck = _classCallCheck;
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
var createClass = _createClass;
var _typeof_1 = createCommonjsModule(function (module) {
function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
function _typeof(obj) {
if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
module.exports = _typeof = function _typeof(obj) {
return _typeof2(obj);
};
} else {
module.exports = _typeof = function _typeof(obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
};
}
return _typeof(obj);
}
module.exports = _typeof;
});
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
var assertThisInitialized = _assertThisInitialized;
function _possibleConstructorReturn(self, call) {
if (call && (_typeof_1(call) === "object" || typeof call === "function")) {
return call;
}
return assertThisInitialized(self);
}
var possibleConstructorReturn = _possibleConstructorReturn;
var getPrototypeOf$1 = createCommonjsModule(function (module) {
function _getPrototypeOf(o) {
module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
module.exports = _getPrototypeOf;
});
var setPrototypeOf = createCommonjsModule(function (module) {
function _setPrototypeOf(o, p) {
module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
module.exports = _setPrototypeOf;
});
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
if (superClass) setPrototypeOf(subClass, superClass);
}
var inherits = _inherits;
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
var defineProperty$1 = _defineProperty;
var MapControl =
/*#__PURE__*/
function (_Component) {
inherits(MapControl, _Component);
function MapControl(props) {
var _this;
classCallCheck(this, MapControl);
_this = possibleConstructorReturn(this, getPrototypeOf$1(MapControl).call(this, props));
defineProperty$1(assertThisInitialized(_this), "leafletElement", void 0);
_this.leafletElement = _this.createLeafletElement(_this.props);
return _this;
}
createClass(MapControl, [{
key: "createLeafletElement",
value: function createLeafletElement(_props) {
throw new Error('createLeafletElement() must be implemented');
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(fromProps, toProps) {
if (toProps.position !== fromProps.position) {
this.leafletElement.setPosition(toProps.position);
}
}
}, {
key: "componentDidMount",
value: function componentDidMount() {
this.leafletElement.addTo(this.props.leaflet.map);
}
}, {
key: "componentDidUpdate",
value: function componentDidUpdate(prevProps) {
this.updateLeafletElement(prevProps, this.props);
}
}, {
key: "componentWillUnmount",
value: function componentWillUnmount() {
this.leafletElement.remove();
}
}, {
key: "render",
value: function render() {
return null;
}
}]);
return MapControl;
}(React.Component);
var AttributionControl =
/*#__PURE__*/
function (_MapControl) {
inherits(AttributionControl, _MapControl);
function AttributionControl() {
classCallCheck(this, AttributionControl);
return possibleConstructorReturn(this, getPrototypeOf$1(AttributionControl).apply(this, arguments));
}
createClass(AttributionControl, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
return new leaflet.Control.Attribution(props);
}
}]);
return AttributionControl;
}(MapControl);
var AttributionControl$1 = withLeaflet(AttributionControl);
function _objectWithoutPropertiesLoose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
var objectWithoutPropertiesLoose = _objectWithoutPropertiesLoose;
function _objectWithoutProperties(source, excluded) {
if (source == null) return {};
var target = objectWithoutPropertiesLoose(source, excluded);
var key, i;
if (Object.getOwnPropertySymbols) {
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
for (i = 0; i < sourceSymbolKeys.length; i++) {
key = sourceSymbolKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
}
return target;
}
var objectWithoutProperties = _objectWithoutProperties;
function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = getPrototypeOf$1(object);
if (object === null) break;
}
return object;
}
var superPropBase = _superPropBase;
var get = createCommonjsModule(function (module) {
function _get(target, property, receiver) {
if (typeof Reflect !== "undefined" && Reflect.get) {
module.exports = _get = Reflect.get;
} else {
module.exports = _get = function _get(target, property, receiver) {
var base = superPropBase(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(receiver);
}
return desc.value;
};
}
return _get(target, property, receiver || target);
}
module.exports = _get;
});
var isArray = Array.isArray;
var keyList = Object.keys;
var hasProp = Object.prototype.hasOwnProperty;
var fastDeepEqual = function equal(a, b) {
if (a === b) return true;
if (a && b && typeof a == 'object' && typeof b == 'object') {
var arrA = isArray(a)
, arrB = isArray(b)
, i
, length
, key;
if (arrA && arrB) {
length = a.length;
if (length != b.length) return false;
for (i = length; i-- !== 0;)
if (!equal(a[i], b[i])) return false;
return true;
}
if (arrA != arrB) return false;
var dateA = a instanceof Date
, dateB = b instanceof Date;
if (dateA != dateB) return false;
if (dateA && dateB) return a.getTime() == b.getTime();
var regexpA = a instanceof RegExp
, regexpB = b instanceof RegExp;
if (regexpA != regexpB) return false;
if (regexpA && regexpB) return a.toString() == b.toString();
var keys = keyList(a);
length = keys.length;
if (length !== keyList(b).length)
return false;
for (i = length; i-- !== 0;)
if (!hasProp.call(b, keys[i])) return false;
for (i = length; i-- !== 0;) {
key = keys[i];
if (!equal(a[key], b[key])) return false;
}
return true;
}
return a!==a && b!==b;
};
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var EVENTS_RE = /^on(.+)$/i;
var MapEvented =
/*#__PURE__*/
function (_Component) {
inherits(MapEvented, _Component);
function MapEvented(props) {
var _this;
classCallCheck(this, MapEvented);
_this = possibleConstructorReturn(this, getPrototypeOf$1(MapEvented).call(this, props));
defineProperty$1(assertThisInitialized(_this), "_leafletEvents", void 0);
defineProperty$1(assertThisInitialized(_this), "leafletElement", void 0);
_this._leafletEvents = _this.extractLeafletEvents(props);
return _this;
}
createClass(MapEvented, [{
key: "componentDidMount",
value: function componentDidMount() {
this.bindLeafletEvents(this._leafletEvents);
}
}, {
key: "componentDidUpdate",
value: function componentDidUpdate(_prevProps) {
this._leafletEvents = this.bindLeafletEvents(this.extractLeafletEvents(this.props), this._leafletEvents);
}
}, {
key: "componentWillUnmount",
value: function componentWillUnmount() {
var _this2 = this;
var el = this.leafletElement;
if (!el) return;
Object.keys(this._leafletEvents).forEach(function (ev) {
el.off(ev, _this2._leafletEvents[ev]);
});
}
}, {
key: "extractLeafletEvents",
value: function extractLeafletEvents(props) {
return Object.keys(props).reduce(function (res, prop) {
if (EVENTS_RE.test(prop)) {
if (props[prop] != null) {
var _key = prop.replace(EVENTS_RE, function (match, p) {
return p.toLowerCase();
});
res[_key] = props[prop];
}
}
return res;
}, {});
}
}, {
key: "bindLeafletEvents",
value: function bindLeafletEvents() {
var next = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var prev = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var el = this.leafletElement;
if (el == null || el.on == null) return {};
var diff = _objectSpread({}, prev);
Object.keys(prev).forEach(function (ev) {
if (next[ev] == null || prev[ev] !== next[ev]) {
delete diff[ev];
el.off(ev, prev[ev]);
}
});
Object.keys(next).forEach(function (ev) {
if (prev[ev] == null || next[ev] !== prev[ev]) {
diff[ev] = next[ev];
el.on(ev, next[ev]);
}
});
return diff;
}
}, {
key: "fireLeafletEvent",
value: function fireLeafletEvent(type, data) {
var el = this.leafletElement;
if (el) el.fire(type, data);
}
}]);
return MapEvented;
}(React.Component);
function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var MapComponent =
/*#__PURE__*/
function (_MapEvented) {
inherits(MapComponent, _MapEvented);
function MapComponent() {
classCallCheck(this, MapComponent);
return possibleConstructorReturn(this, getPrototypeOf$1(MapComponent).apply(this, arguments));
}
createClass(MapComponent, [{
key: "getOptions",
value: function getOptions(props) {
if (props.pane != null) {
return props;
}
if (props.leaflet != null && props.leaflet.pane != null) {
return _objectSpread$1({}, props, {
pane: props.leaflet.pane
});
}
return props;
}
}]);
return MapComponent;
}(MapEvented);
var MapLayer =
/*#__PURE__*/
function (_MapComponent) {
inherits(MapLayer, _MapComponent);
function MapLayer(props) {
var _this;
classCallCheck(this, MapLayer);
_this = possibleConstructorReturn(this, getPrototypeOf$1(MapLayer).call(this, props));
defineProperty$1(assertThisInitialized(_this), "contextValue", void 0);
defineProperty$1(assertThisInitialized(_this), "leafletElement", void 0);
_this.leafletElement = _this.createLeafletElement(props);
return _this;
}
createClass(MapLayer, [{
key: "createLeafletElement",
value: function createLeafletElement(_props) {
throw new Error('createLeafletElement() must be implemented');
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(_fromProps, _toProps) {}
}, {
key: "componentDidMount",
value: function componentDidMount() {
get(getPrototypeOf$1(MapLayer.prototype), "componentDidMount", this).call(this);
this.layerContainer.addLayer(this.leafletElement);
}
}, {
key: "componentDidUpdate",
value: function componentDidUpdate(prevProps) {
get(getPrototypeOf$1(MapLayer.prototype), "componentDidUpdate", this).call(this, prevProps);
if (this.props.attribution !== prevProps.attribution) {
var map = this.props.leaflet.map;
if (map != null && map.attributionControl != null) {
map.attributionControl.removeAttribution(prevProps.attribution);
map.attributionControl.addAttribution(this.props.attribution);
}
}
this.updateLeafletElement(prevProps, this.props);
}
}, {
key: "componentWillUnmount",
value: function componentWillUnmount() {
get(getPrototypeOf$1(MapLayer.prototype), "componentWillUnmount", this).call(this);
this.layerContainer.removeLayer(this.leafletElement);
}
}, {
key: "render",
value: function render() {
var children = this.props.children;
if (children == null) {
return null;
}
return this.contextValue == null ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(LeafletProvider, {
value: this.contextValue
}, children);
}
}, {
key: "layerContainer",
get: function get() {
return this.props.leaflet.layerContainer || this.props.leaflet.map;
}
}]);
return MapLayer;
}(MapComponent);
function pick(object, keys) {
return keys.reduce(function (obj, key) {
if (object[key]) {
obj[key] = object[key];
}
return obj;
}, {});
}
function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var OPTIONS = ['stroke', 'color', 'weight', 'opacity', 'lineCap', 'lineJoin', 'dashArray', 'dashOffset', 'fill', 'fillColor', 'fillOpacity', 'fillRule', 'bubblingMouseEvents', 'renderer', 'className', // Interactive Layer
'interactive', // Layer
'pane', 'attribution'];
var Path =
/*#__PURE__*/
function (_MapLayer) {
inherits(Path, _MapLayer);
function Path(props) {
var _this;
classCallCheck(this, Path);
_this = possibleConstructorReturn(this, getPrototypeOf$1(Path).call(this, props));
if (_this.contextValue == null) {
_this.contextValue = _objectSpread$2({}, props.leaflet, {
popupContainer: _this.leafletElement
});
}
return _this;
}
createClass(Path, [{
key: "componentDidUpdate",
value: function componentDidUpdate(prevProps) {
get(getPrototypeOf$1(Path.prototype), "componentDidUpdate", this).call(this, prevProps);
this.setStyleIfChanged(prevProps, this.props);
}
}, {
key: "getPathOptions",
value: function getPathOptions(props) {
return pick(props, OPTIONS);
}
}, {
key: "setStyle",
value: function setStyle() {
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
this.leafletElement.setStyle(options);
}
}, {
key: "setStyleIfChanged",
value: function setStyleIfChanged(fromProps, toProps) {
var nextStyle = this.getPathOptions(toProps);
if (!fastDeepEqual(nextStyle, this.getPathOptions(fromProps))) {
this.setStyle(nextStyle);
}
}
}]);
return Path;
}(MapLayer);
var Circle =
/*#__PURE__*/
function (_Path) {
inherits(Circle, _Path);
function Circle() {
classCallCheck(this, Circle);
return possibleConstructorReturn(this, getPrototypeOf$1(Circle).apply(this, arguments));
}
createClass(Circle, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var center = props.center,
radius = props.radius,
options = objectWithoutProperties(props, ["center", "radius"]);
return new leaflet.Circle(center, radius, this.getOptions(options));
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(fromProps, toProps) {
if (toProps.center !== fromProps.center) {
this.leafletElement.setLatLng(toProps.center);
}
if (toProps.radius !== fromProps.radius) {
this.leafletElement.setRadius(toProps.radius);
}
}
}]);
return Circle;
}(Path);
var Circle$1 = withLeaflet(Circle);
function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var CircleMarker =
/*#__PURE__*/
function (_Path) {
inherits(CircleMarker, _Path);
function CircleMarker() {
classCallCheck(this, CircleMarker);
return possibleConstructorReturn(this, getPrototypeOf$1(CircleMarker).apply(this, arguments));
}
createClass(CircleMarker, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var el = new leaflet.CircleMarker(props.center, this.getOptions(props));
this.contextValue = _objectSpread$3({}, props.leaflet, {
popupContainer: el
});
return el;
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(fromProps, toProps) {
if (toProps.center !== fromProps.center) {
this.leafletElement.setLatLng(toProps.center);
}
if (toProps.radius !== fromProps.radius) {
this.leafletElement.setRadius(toProps.radius);
}
}
}]);
return CircleMarker;
}(Path);
var CircleMarker$1 = withLeaflet(CircleMarker);
var splitClassName = function splitClassName() {
var className = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
return className.split(' ').filter(Boolean);
};
var addClassName = function addClassName(container, className) {
splitClassName(className).forEach(function (cls) {
leaflet.DomUtil.addClass(container, cls);
});
};
var removeClassName = function removeClassName(container, className) {
splitClassName(className).forEach(function (cls) {
leaflet.DomUtil.removeClass(container, cls);
});
};
var updateClassName = (function (container, prevClassName, nextClassName) {
if (container != null && nextClassName !== prevClassName) {
if (prevClassName != null && prevClassName.length > 0) {
removeClassName(container, prevClassName);
}
if (nextClassName != null && nextClassName.length > 0) {
addClassName(container, nextClassName);
}
}
});
var DivOverlay =
/*#__PURE__*/
function (_MapComponent) {
inherits(DivOverlay, _MapComponent);
function DivOverlay(props) {
var _this;
classCallCheck(this, DivOverlay);
_this = possibleConstructorReturn(this, getPrototypeOf$1(DivOverlay).call(this, props));
defineProperty$1(assertThisInitialized(_this), "onClose", function () {
if (_this.props.onClose) {
_this.props.onClose();
}
});
defineProperty$1(assertThisInitialized(_this), "onOpen", function () {
_this.forceUpdate(); // Re-render now that leafletElement is created
if (_this.props.onOpen) {
_this.props.onOpen();
}
});
_this.leafletElement = _this.createLeafletElement(props);
return _this;
}
createClass(DivOverlay, [{
key: "createLeafletElement",
value: function createLeafletElement(_props) {
throw new Error('createLeafletElement() must be implemented');
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(_prevProps, _props) {}
}, {
key: "componentDidUpdate",
value: function componentDidUpdate(prevProps) {
updateClassName(this.leafletElement._container, prevProps.className, this.props.className);
this.updateLeafletElement(prevProps, this.props);
if (this.leafletElement.isOpen()) {
this.leafletElement.update();
this.onRender();
}
}
}, {
key: "onRender",
value: function onRender() {}
}, {
key: "render",
value: function render() {
if (this.leafletElement._contentNode) {
return reactDom.createPortal(this.props.children, this.leafletElement._contentNode);
}
return null;
}
}]);
return DivOverlay;
}(MapComponent);
function ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$4(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$4(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var FeatureGroup =
/*#__PURE__*/
function (_Path) {
inherits(FeatureGroup, _Path);
function FeatureGroup() {
classCallCheck(this, FeatureGroup);
return possibleConstructorReturn(this, getPrototypeOf$1(FeatureGroup).apply(this, arguments));
}
createClass(FeatureGroup, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var el = new leaflet.FeatureGroup(this.getOptions(props));
this.contextValue = _objectSpread$4({}, props.leaflet, {
layerContainer: el,
popupContainer: el
});
return el;
}
}, {
key: "componentDidMount",
value: function componentDidMount() {
get(getPrototypeOf$1(FeatureGroup.prototype), "componentDidMount", this).call(this);
this.setStyle(this.props);
}
}]);
return FeatureGroup;
}(Path);
var FeatureGroup$1 = withLeaflet(FeatureGroup);
var GeoJSON =
/*#__PURE__*/
function (_Path) {
inherits(GeoJSON, _Path);
function GeoJSON() {
classCallCheck(this, GeoJSON);
return possibleConstructorReturn(this, getPrototypeOf$1(GeoJSON).apply(this, arguments));
}
createClass(GeoJSON, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
return new leaflet.GeoJSON(props.data, this.getOptions(props));
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(fromProps, toProps) {
if (typeof toProps.style === 'function') {
this.leafletElement.setStyle(toProps.style);
} else {
this.setStyleIfChanged(fromProps, toProps);
}
}
}]);
return GeoJSON;
}(Path);
var GeoJSON$1 = withLeaflet(GeoJSON);
function ownKeys$5(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$5(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$5(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$5(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var GridLayer =
/*#__PURE__*/
function (_MapLayer) {
inherits(GridLayer, _MapLayer);
function GridLayer() {
classCallCheck(this, GridLayer);
return possibleConstructorReturn(this, getPrototypeOf$1(GridLayer).apply(this, arguments));
}
createClass(GridLayer, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
return new leaflet.GridLayer(this.getOptions(props));
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(fromProps, toProps) {
var opacity = toProps.opacity,
zIndex = toProps.zIndex;
if (opacity !== fromProps.opacity) {
this.leafletElement.setOpacity(opacity);
}
if (zIndex !== fromProps.zIndex) {
this.leafletElement.setZIndex(zIndex);
}
}
}, {
key: "getOptions",
value: function getOptions(props) {
var options = get(getPrototypeOf$1(GridLayer.prototype), "getOptions", this).call(this, props);
return props.leaflet.map == null ? options : // $FlowFixMe: object spread type
_objectSpread$5({
maxZoom: props.leaflet.map.options.maxZoom,
minZoom: props.leaflet.map.options.minZoom
}, options);
}
}, {
key: "render",
value: function render() {
return null;
}
}]);
return GridLayer;
}(MapLayer);
function ownKeys$6(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$6(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$6(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$6(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var ImageOverlay =
/*#__PURE__*/
function (_MapLayer) {
inherits(ImageOverlay, _MapLayer);
function ImageOverlay() {
classCallCheck(this, ImageOverlay);
return possibleConstructorReturn(this, getPrototypeOf$1(ImageOverlay).apply(this, arguments));
}
createClass(ImageOverlay, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var el = new leaflet.ImageOverlay(props.url, props.bounds, this.getOptions(props));
this.contextValue = _objectSpread$6({}, props.leaflet, {
popupContainer: el
});
return el;
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(fromProps, toProps) {
if (toProps.url !== fromProps.url) {
this.leafletElement.setUrl(toProps.url);
}
if (toProps.bounds !== fromProps.bounds) {
this.leafletElement.setBounds(leaflet.latLngBounds(toProps.bounds));
}
if (toProps.opacity !== fromProps.opacity) {
this.leafletElement.setOpacity(toProps.opacity);
}
if (toProps.zIndex !== fromProps.zIndex) {
this.leafletElement.setZIndex(toProps.zIndex);
}
}
}]);
return ImageOverlay;
}(MapLayer);
var ImageOverlay$1 = withLeaflet(ImageOverlay);
function ownKeys$7(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$7(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$7(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$7(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var LayerGroup =
/*#__PURE__*/
function (_MapLayer) {
inherits(LayerGroup, _MapLayer);
function LayerGroup() {
classCallCheck(this, LayerGroup);
return possibleConstructorReturn(this, getPrototypeOf$1(LayerGroup).apply(this, arguments));
}
createClass(LayerGroup, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var el = new leaflet.LayerGroup([], this.getOptions(props));
this.contextValue = _objectSpread$7({}, props.leaflet, {
layerContainer: el
});
return el;
}
}]);
return LayerGroup;
}(MapLayer);
var LayerGroup$1 = withLeaflet(LayerGroup);
function ownKeys$8(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread$8(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$8(source, true).forEach(function (key) { defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$8(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
// Abtract class for layer container, extended by BaseLayer and Overlay
var ControlledLayer =
/*#__PURE__*/
function (_Component) {
inherits(ControlledLayer, _Component);
function ControlledLayer() {
var _getPrototypeOf2;
var _this;
classCallCheck(this, ControlledLayer);
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = possibleConstructorReturn(this, (_getPrototypeOf2 = getPrototy