dash-core-components
Version:
Core component suite for Dash
170 lines (168 loc) • 6.29 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _react = require("react");
var _propTypes = _interopRequireDefault(require("prop-types"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
/**
* The CurrentLocation component gets geolocation of the device from the web browser. See more info here:
* https://developer.mozilla.org/en-US/docs/Web/API/Geolocation_API
*/
class Geolocation extends _react.Component {
constructor(props) {
super(props);
this.success = this.success.bind(this);
this.error = this.error.bind(this);
}
updatePosition() {
if (this.props.update_now) {
this.props.setProps({
update_now: false
});
}
if (!navigator.geolocation) {
this.error({
code: 999,
message: 'Your browser does not support Geolocation'
});
} else {
var positionOptions = {
enableHighAccuracy: this.props.high_accuracy,
maximumAge: this.props.maximum_age,
timeout: this.props.timeout
};
navigator.geolocation.getCurrentPosition(this.success, this.error, positionOptions);
}
}
componentDidMount() {
this.updatePosition();
}
componentDidUpdate(prevProps) {
if (this.props.update_now || prevProps.maximum_age !== this.props.maximum_age || prevProps.timeout !== this.props.timeout || prevProps.high_accuracy !== this.props.high_accuracy) {
this.updatePosition();
}
}
success(pos) {
var _crd$latitude, _crd$longitude, _crd$accuracy, _crd$altitude, _crd$altitudeAccuracy, _crd$speed, _crd$heading;
var crd = pos.coords;
var position_obj = {
lat: (_crd$latitude = crd.latitude) !== null && _crd$latitude !== void 0 ? _crd$latitude : null,
lon: (_crd$longitude = crd.longitude) !== null && _crd$longitude !== void 0 ? _crd$longitude : null,
accuracy: (_crd$accuracy = crd.accuracy) !== null && _crd$accuracy !== void 0 ? _crd$accuracy : null,
alt: (_crd$altitude = crd.altitude) !== null && _crd$altitude !== void 0 ? _crd$altitude : null,
alt_accuracy: (_crd$altitudeAccuracy = crd.altitudeAccuracy) !== null && _crd$altitudeAccuracy !== void 0 ? _crd$altitudeAccuracy : null,
speed: (_crd$speed = crd.speed) !== null && _crd$speed !== void 0 ? _crd$speed : null,
heading: (_crd$heading = crd.heading) !== null && _crd$heading !== void 0 ? _crd$heading : null
};
this.props.setProps({
local_date: new Date(pos.timestamp).toLocaleString(),
timestamp: pos.timestamp,
position: position_obj,
position_error: null
});
}
error(err) {
if (this.props.show_alert) {
alert("ERROR(".concat(err.code, "): ").concat(err.message));
}
this.props.setProps({
position: null,
position_error: {
code: err.code,
message: err.message
}
});
}
render() {
return null;
}
}
exports.default = Geolocation;
Geolocation.defaultProps = {
update_now: false,
high_accuracy: false,
position_error: null,
maximum_age: 0,
timeout: Infinity,
show_alert: false
};
Geolocation.propTypes = {
/**
* The ID used to identify this component in Dash callbacks.
*/
id: _propTypes.default.string,
/**
* The local date and time when the device position was updated.
* Format: MM/DD/YYYY, hh:mm:ss p where p is AM or PM
*/
local_date: _propTypes.default.string,
/**
* The Unix timestamp from when the position was updated
*/
timestamp: _propTypes.default.number,
/**
* The position of the device. `lat`, `lon`, and `accuracy` will always be returned. The other data will be included
* when available, otherwise it will be NaN.
*
* `lat` is latitude in degrees.
* `lon` is longitude in degrees.
* `accuracy` is the accuracy of the lat/lon in meters. *
*
* `alt` is altitude above mean sea level in meters.
* `alt_accuracy` is the accuracy of the altitude in meters.
* `heading` is the compass heading in degrees.
* `speed` is the speed in meters per second.
*
*/
position: _propTypes.default.shape({
lat: _propTypes.default.number,
lon: _propTypes.default.number,
accuracy: _propTypes.default.number,
alt: _propTypes.default.number,
alt_accuracy: _propTypes.default.number,
heading: _propTypes.default.number,
speed: _propTypes.default.number
}),
/**
* Position error
*/
position_error: _propTypes.default.shape({
code: _propTypes.default.number,
message: _propTypes.default.string
}),
/**
* If true, error messages will be displayed as an alert
*/
show_alert: _propTypes.default.bool,
/**
* Forces a one-time update of the position data. If set to True in a callback, the browser
* will update the position data and reset update_now back to False. This can, for example, be used to update the
* position with a button or an interval timer.
*/
update_now: _propTypes.default.bool,
/**
* If true and if the device is able to provide a more accurate position,
* it will do so. Note that this can result in slower response times or increased power consumption (with a GPS
* chip on a mobile device for example). If false (the default value), the device can save resources by
* responding more quickly and/or using less power.
*/
high_accuracy: _propTypes.default.bool,
/**
* The maximum age in milliseconds of a possible cached position that is acceptable to return. If set to 0,
* it means that the device cannot use a cached position and must attempt to retrieve the real current position.
* If set to Infinity the device must return a cached position regardless of its age. Default: 0.
*/
maximum_age: _propTypes.default.number,
/**
* The maximum length of time (in milliseconds) the device is allowed to take in order to return a position.
* The default value is Infinity, meaning that data will not be return until the position is available.
*/
timeout: _propTypes.default.number,
/**
* Dash-assigned callback that should be called to report property changes
* to Dash, to make them available for callbacks.
*/
setProps: _propTypes.default.func
};