@stangres/react-leaflet
Version:
React components for Leaflet maps
1,652 lines (1,336 loc) • 88.1 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 = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactLeaflet = {}, global.React, global.L, global.ReactDOM));
}(this, (function (exports, React, leaflet, reactDom) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
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() {
// 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; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
// (unstable) APIs that have been removed. Can we remove the symbols?
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_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
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 || type === REACT_SUSPENSE_LIST_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 || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
}
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_LAZY_TYPE:
case REACT_MEMO_TYPE:
case REACT_PROVIDER_TYPE:
return $$typeofType;
default:
return $$typeof;
}
}
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; // Using console['warn'] to evade Babel and ESLint
console['warn']('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.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.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;
exports.isValidElementType = isValidElementType;
exports.typeOf = typeOf;
})();
}
});
var reactIs_development_1 = reactIs_development.AsyncMode;
var reactIs_development_2 = reactIs_development.ConcurrentMode;
var reactIs_development_3 = reactIs_development.ContextConsumer;
var reactIs_development_4 = reactIs_development.ContextProvider;
var reactIs_development_5 = reactIs_development.Element;
var reactIs_development_6 = reactIs_development.ForwardRef;
var reactIs_development_7 = reactIs_development.Fragment;
var reactIs_development_8 = reactIs_development.Lazy;
var reactIs_development_9 = reactIs_development.Memo;
var reactIs_development_10 = reactIs_development.Portal;
var reactIs_development_11 = reactIs_development.Profiler;
var reactIs_development_12 = reactIs_development.StrictMode;
var reactIs_development_13 = reactIs_development.Suspense;
var reactIs_development_14 = reactIs_development.isAsyncMode;
var reactIs_development_15 = reactIs_development.isConcurrentMode;
var reactIs_development_16 = reactIs_development.isContextConsumer;
var reactIs_development_17 = reactIs_development.isContextProvider;
var reactIs_development_18 = reactIs_development.isElement;
var reactIs_development_19 = reactIs_development.isForwardRef;
var reactIs_development_20 = reactIs_development.isFragment;
var reactIs_development_21 = reactIs_development.isLazy;
var reactIs_development_22 = reactIs_development.isMemo;
var reactIs_development_23 = reactIs_development.isPortal;
var reactIs_development_24 = reactIs_development.isProfiler;
var reactIs_development_25 = reactIs_development.isStrictMode;
var reactIs_development_26 = reactIs_development.isSuspense;
var reactIs_development_27 = reactIs_development.isValidElementType;
var reactIs_development_28 = reactIs_development.typeOf;
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;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
function getStatics(component) {
// React v16.11 and below
if (reactIs.isMemo(component)) {
return MEMO_STATICS;
} // React v16.12 and above
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;
}
var hoistNonReactStatics_cjs = hoistNonReactStatics;
var leafletContext = /*#__PURE__*/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 /*#__PURE__*/React__default['default'].createElement(LeafletConsumer, null, function (leaflet) {
return /*#__PURE__*/React__default['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 = /*#__PURE__*/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 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;
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;
});
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
return true;
} catch (e) {
return false;
}
}
var isNativeReflectConstruct = _isNativeReflectConstruct;
var _typeof_1 = createCommonjsModule(function (module) {
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
module.exports = _typeof = function _typeof(obj) {
return typeof obj;
};
} else {
module.exports = _typeof = function _typeof(obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof 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;
function _createSuper(Derived) {
var hasNativeReflectConstruct = isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = getPrototypeOf$1(Derived),
result;
if (hasNativeReflectConstruct) {
var NewTarget = getPrototypeOf$1(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return possibleConstructorReturn(this, result);
};
}
var createSuper = _createSuper;
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);
var _super = createSuper(MapControl);
function MapControl(props) {
var _this;
classCallCheck(this, MapControl);
_this = _super.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);
var _super = createSuper(AttributionControl);
function AttributionControl() {
classCallCheck(this, AttributionControl);
return _super.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 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 _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
if (i % 2) {
ownKeys(Object(source), true).forEach(function (key) {
defineProperty$1(target, key, source[key]);
});
} else if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
}
return target;
}
var objectSpread2 = _objectSpread2;
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;
});
// do not edit .js files directly - edit src/index.jst
var fastDeepEqual = function equal(a, b) {
if (a === b) return true;
if (a && b && typeof a == 'object' && typeof b == 'object') {
if (a.constructor !== b.constructor) return false;
var length, i, keys;
if (Array.isArray(a)) {
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 (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length) return false;
for (i = length; i-- !== 0;)
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
for (i = length; i-- !== 0;) {
var key = keys[i];
if (!equal(a[key], b[key])) return false;
}
return true;
}
// true if both NaN, false otherwise
return a!==a && b!==b;
};
var EVENTS_RE = /^on(.+)$/i;
var MapEvented = /*#__PURE__*/function (_Component) {
inherits(MapEvented, _Component);
var _super = createSuper(MapEvented);
function MapEvented(props) {
var _this;
classCallCheck(this, MapEvented);
_this = _super.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 = objectSpread2({}, 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);
var MapComponent = /*#__PURE__*/function (_MapEvented) {
inherits(MapComponent, _MapEvented);
var _super = createSuper(MapComponent);
function MapComponent() {
classCallCheck(this, MapComponent);
return _super.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 objectSpread2(objectSpread2({}, props), {}, {
pane: props.leaflet.pane
});
}
return props;
}
}]);
return MapComponent;
}(MapEvented);
var MapLayer = /*#__PURE__*/function (_MapComponent) {
inherits(MapLayer, _MapComponent);
var _super = createSuper(MapLayer);
function MapLayer(props) {
var _this;
classCallCheck(this, MapLayer);
_this = _super.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 ? /*#__PURE__*/React__default['default'].createElement(React.Fragment, null, children) : /*#__PURE__*/React__default['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 (typeof object[key] !== 'undefined') {
obj[key] = object[key];
}
return obj;
}, {});
}
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);
var _super = createSuper(Path);
function Path(props) {
var _this;
classCallCheck(this, Path);
_this = _super.call(this, props);
if (_this.contextValue == null) {
_this.contextValue = objectSpread2(objectSpread2({}, 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);
var _super = createSuper(Circle);
function Circle() {
classCallCheck(this, Circle);
return _super.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);
var CircleMarker = /*#__PURE__*/function (_Path) {
inherits(CircleMarker, _Path);
var _super = createSuper(CircleMarker);
function CircleMarker() {
classCallCheck(this, CircleMarker);
return _super.apply(this, arguments);
}
createClass(CircleMarker, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var el = new leaflet.CircleMarker(props.center, this.getOptions(props));
this.contextValue = objectSpread2(objectSpread2({}, 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);
var _super = createSuper(DivOverlay);
function DivOverlay(props) {
var _this;
classCallCheck(this, DivOverlay);
_this = _super.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 /*#__PURE__*/reactDom.createPortal(this.props.children, this.leafletElement._contentNode);
}
return null;
}
}]);
return DivOverlay;
}(MapComponent);
var FeatureGroup = /*#__PURE__*/function (_Path) {
inherits(FeatureGroup, _Path);
var _super = createSuper(FeatureGroup);
function FeatureGroup() {
classCallCheck(this, FeatureGroup);
return _super.apply(this, arguments);
}
createClass(FeatureGroup, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var el = new leaflet.FeatureGroup(this.getOptions(props));
this.contextValue = objectSpread2(objectSpread2({}, 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);
var _super = createSuper(GeoJSON);
function GeoJSON() {
classCallCheck(this, GeoJSON);
return _super.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);
var GridLayer = /*#__PURE__*/function (_MapLayer) {
inherits(GridLayer, _MapLayer);
var _super = createSuper(GridLayer);
function GridLayer() {
classCallCheck(this, GridLayer);
return _super.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 = objectSpread2({}, get(getPrototypeOf$1(GridLayer.prototype), "getOptions", this).call(this, props));
var map = props.leaflet.map;
if (map != null) {
// $FlowFixMe: Object spread
if (options.maxZoom == null && map.options.maxZoom != null) {
// $FlowFixMe: Object spread
options.maxZoom = map.options.maxZoom;
} // $FlowFixMe: Object spread
if (options.minZoom == null && map.options.minZoom != null) {
// $FlowFixMe: Object spread
options.minZoom = map.options.minZoom;
}
}
return options;
}
}, {
key: "render",
value: function render() {
return null;
}
}]);
return GridLayer;
}(MapLayer);
var ImageOverlay = /*#__PURE__*/function (_MapLayer) {
inherits(ImageOverlay, _MapLayer);
var _super = createSuper(ImageOverlay);
function ImageOverlay() {
classCallCheck(this, ImageOverlay);
return _super.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 = objectSpread2(objectSpread2({}, 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);
var LayerGroup = /*#__PURE__*/function (_MapLayer) {
inherits(LayerGroup, _MapLayer);
var _super = createSuper(LayerGroup);
function LayerGroup() {
classCallCheck(this, LayerGroup);
return _super.apply(this, arguments);
}
createClass(LayerGroup, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var el = new leaflet.LayerGroup([], this.getOptions(props));
this.contextValue = objectSpread2(objectSpread2({}, props.leaflet), {}, {
layerContainer: el
});
return el;
}
}]);
return LayerGroup;
}(MapLayer);
var LayerGroup$1 = withLeaflet(LayerGroup);
// Abtract class for layer container, extended by BaseLayer and Overlay
var ControlledLayer = /*#__PURE__*/function (_Component) {
inherits(ControlledLayer, _Component);
var _super = createSuper(ControlledLayer);
function ControlledLayer() {
var _this;
classCallCheck(this, ControlledLayer);
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _super.call.apply(_super, [this].concat(args));
defineProperty$1(assertThisInitialized(_this), "contextValue", void 0);
defineProperty$1(assertThisInitialized(_this), "layer", void 0);
return _this;
}
createClass(ControlledLayer, [{
key: "componentDidUpdate",
value: function componentDidUpdate(_ref) {
var checked = _ref.checked;
if (this.props.leaflet.map == null) {
return;
} // Handle dynamically (un)checking the layer => adding/removing from the map
if (this.props.checked === true && (checked == null || checked === false)) {
this.props.leaflet.map.addLayer(this.layer);
} else if (checked === true && (this.props.checked == null || this.props.checked === false)) {
this.props.leaflet.map.removeLayer(this.layer);
}
}
}, {
key: "componentWillUnmount",
value: function componentWillUnmount() {
this.props.removeLayerControl(this.layer);
}
}, {
key: "addLayer",
value: function addLayer() {
throw new Error('Must be implemented in extending class');
}
}, {
key: "removeLayer",
value: function removeLayer(layer) {
this.props.removeLayer(layer);
}
}, {
key: "render",
value: function render() {
var children = this.props.children;
return children ? /*#__PURE__*/React__default['default'].createElement(LeafletProvider, {
value: this.contextValue
}, children) : null;
}
}]);
return ControlledLayer;
}(React.Component);
var BaseLayer = /*#__PURE__*/function (_ControlledLayer) {
inherits(BaseLayer, _ControlledLayer);
var _super2 = createSuper(BaseLayer);
function BaseLayer(props) {
var _this2;
classCallCheck(this, BaseLayer);
_this2 = _super2.call(this, props);
defineProperty$1(assertThisInitialized(_this2), "addLayer", function (layer) {
_this2.layer = layer; // Keep layer reference to handle dynamic changes of props
var _this2$props = _this2.props,
addBaseLayer = _this2$props.addBaseLayer,
checked = _this2$props.checked,
name = _this2$props.name;
addBaseLayer(layer, name, checked);
});
_this2.contextValue = objectSpread2(objectSpread2({}, props.leaflet), {}, {
layerContainer: {
addLayer: _this2.addLayer.bind(assertThisInitialized(_this2)),
removeLayer: _this2.removeLayer.bind(assertThisInitialized(_this2))
}
});
return _this2;
}
return BaseLayer;
}(ControlledLayer);
var Overlay = /*#__PURE__*/function (_ControlledLayer2) {
inherits(Overlay, _ControlledLayer2);
var _super3 = createSuper(Overlay);
function Overlay(props) {
var _this3;
classCallCheck(this, Overlay);
_this3 = _super3.call(this, props);
defineProperty$1(assertThisInitialized(_this3), "addLayer", function (layer) {
_this3.layer = layer; // Keep layer reference to handle dynamic changes of props
var _this3$props = _this3.props,
addOverlay = _this3$props.addOverlay,
checked = _this3$props.checked,
name = _this3$props.name;
addOverlay(layer, name, checked);
});
_this3.contextValue = objectSpread2(objectSpread2({}, props.leaflet), {}, {
layerContainer: {
addLayer: _this3.addLayer.bind(assertThisInitialized(_this3)),
removeLayer: _this3.removeLayer.bind(assertThisInitialized(_this3))
}
});
return _this3;
}
return Overlay;
}(ControlledLayer);
var LayersControl = /*#__PURE__*/function (_MapControl) {
inherits(LayersControl, _MapControl);
var _super4 = createSuper(LayersControl);
function LayersControl(props) {
var _this4;
classCallCheck(this, LayersControl);
_this4 = _super4.call(this, props);
defineProperty$1(assertThisInitialized(_this4), "controlProps", void 0);
_this4.controlProps = {
addBaseLayer: _this4.addBaseLayer.bind(assertThisInitialized(_this4)),
addOverlay: _this4.addOverlay.bind(assertThisInitialized(_this4)),
leaflet: props.leaflet,
removeLayer: _this4.removeLayer.bind(assertThisInitialized(_this4)),
removeLayerControl: _this4.removeLayerControl.bind(assertThisInitialized(_this4))
};
return _this4;
}
createClass(LayersControl, [{
key: "createLeafletElement",
value: function createLeafletElement(props) {
var _children = props.children,
options = objectWithoutProperties(props, ["children"]);
return new leaflet.Control.Layers(undefined, undefined, options);
}
}, {
key: "updateLeafletElement",
value: function updateLeafletElement(fromProps, toProps) {
get(getPrototypeOf$1(LayersControl.prototype), "updateLeafletElement", this).call(this, fromProps, toProps);
if (toProps.collapsed !== fromProps.collapsed) {
if (toProps.collapsed === true) {
this.leafletElement.collapse();
} else {
this.leafletElement.expand();
}
}
}
}, {
key: "componentWillUnmount",
value: function componentWillUnmount() {
var _this5 = this;
setTimeout(function () {
get(getPrototypeOf$1(LayersControl.prototype), "componentWillUnmount", _this5).call(_this5);
}, 0);
}
}, {
key: "addBaseLayer",
value: function addBaseLayer(layer, name) {
var checked = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
if (checked && this.props.leaflet.map != null) {
this.props.leaflet.map.addLayer(layer);
}
this.leafletElement.addBaseLayer(layer, name);
}
}, {
key: "addOverlay",
value: function addOverlay(layer, name) {
var checked = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
if (checked && this.props.leaflet.map != null) {
this.props.leaflet.map.addLayer(layer);
}
this.leafletElement.addOverlay(layer, name);
}
}, {
key: "removeLayer",
value: function removeLayer(layer) {
if (this.props.leaflet.map != null) {
this.props.leaflet.map.removeLayer(layer);
}
}
}, {
key: "removeLayerControl",
value: function removeLayerControl(layer) {
this.leafletElement.removeLayer(layer);
}
}, {
key: "render",
value: function render() {
var _this6 = this;
var children = React.Children.map(this.props.children, function (child) {
return child ? /*#__PURE__*/React.cloneElement(child, _this6.controlProps) : null;
});
return /*#__PURE__*/React__default['default'].createElement(React.Fragment, null, children);
}
}]);
return LayersControl;
}(MapControl);
var LayersControlExport = withLeaflet(LayersControl);
LayersControlExport.BaseLayer = BaseLayer;
LayersControlExport.Overlay = Overlay;
function omit(obj) {
for (var _len = arguments.length, keysToOmit = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
keysToOmit[_key - 1] = arguments[_key];
}
return Object.keys(obj).reduce(function (acc, key) {
if (keysToOmit.indexOf(key) === -1) {
acc[key] = obj[key];
}