ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make code prettier

Browse Source 
This updates ESLint and our shared eslint-config-openlayers to use Prettier.  Most formatting changes were automatically applied with this:

    npm run lint -- --fix

A few manual changes were required:

 * In `examples/offscreen-canvas.js`, the `//eslint-disable-line` comment needed to be moved to the appropriate line to disable the error about the `'worker-loader!./offscreen-canvas.worker.js'` import.
 * In `examples/webpack/exapmle-builder.js`, spaces could not be added after a couple `function`s for some reason.  While editing this, I reworked `ExampleBuilder` to be a class.
 * In `src/ol/format/WMSGetFeatureInfo.js`, the `// @ts-ignore` comment needed to be moved down one line so it applied to the `parsersNS` argument.
This commit is contained in:
Tim Schaub
2020-04-06 12:25:12 -06:00
parent 53b48baf62
commit 054af09032
790 changed files with 46833 additions and 33765 deletions
Download Patch File Download Diff File Expand all files Collapse all files

331
test/spec/ol/renderer/webgl/pointslayer.test.js
View File

@@ -2,11 +2,14 @@ import Feature from '../../../../../src/ol/Feature.js';
import Point from '../../../../../src/ol/geom/Point.js';
import VectorLayer from '../../../../../src/ol/layer/Vector.js';
import VectorSource from '../../../../../src/ol/source/Vector.js';
import WebGLPointsLayerRenderer from '../../../../../src/ol/renderer/webgl/PointsLayer.js';
import {get as getProjection} from '../../../../../src/ol/proj.js';
import ViewHint from '../../../../../src/ol/ViewHint.js';
import WebGLPointsLayerRenderer from '../../../../../src/ol/renderer/webgl/PointsLayer.js';
import {WebGLWorkerMessageType} from '../../../../../src/ol/renderer/webgl/Layer.js';
import {compose as composeTransform, create as createTransform} from '../../../../../src/ol/transform.js';
import {
compose as composeTransform,
create as createTransform,
} from '../../../../../src/ol/transform.js';
import {get as getProjection} from '../../../../../src/ol/proj.js';
import {getUid} from '../../../../../src/ol/util.js';
const baseFrameState = {
@@ -15,11 +18,11 @@ const baseFrameState = {
projection: getProjection('EPSG:3857'),
resolution: 1,
rotation: 0,
center: [0, 0]
center: [0, 0],
},
layerStatesArray: [{}],
layerIndex: 0,
pixelRatio: 1
pixelRatio: 1,
};
const simpleVertexShader = `
@@ -70,140 +73,166 @@ const hitFragmentShader = `
gl_FragColor = v_hitColor;
}`;
describe('ol.renderer.webgl.PointsLayer', function() {
describe('constructor', function() {
describe('ol.renderer.webgl.PointsLayer', function () {
describe('constructor', function () {
let target;
beforeEach(function() {
beforeEach(function () {
target = document.createElement('div');
target.style.width = '256px';
target.style.height = '256px';
document.body.appendChild(target);
});
afterEach(function() {
afterEach(function () {
document.body.removeChild(target);
});
it('creates a new instance', function() {
it('creates a new instance', function () {
const layer = new VectorLayer({
source: new VectorSource()
source: new VectorSource(),
});
const renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader
fragmentShader: simpleFragmentShader,
});
expect(renderer).to.be.a(WebGLPointsLayerRenderer);
});
});
describe('#prepareFrame', function() {
describe('#prepareFrame', function () {
let layer, renderer, frameState;
beforeEach(function() {
beforeEach(function () {
layer = new VectorLayer({
source: new VectorSource(),
renderBuffer: 10
renderBuffer: 10,
});
renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader,
hitVertexShader: hitVertexShader,
hitFragmentShader: hitFragmentShader
hitFragmentShader: hitFragmentShader,
});
frameState = Object.assign({
size: [2, 2],
extent: [-100, -100, 100, 100]
}, baseFrameState);
frameState = Object.assign(
{
size: [2, 2],
extent: [-100, -100, 100, 100],
},
baseFrameState
);
});
it('calls WebGlHelper#prepareDraw', function() {
it('calls WebGlHelper#prepareDraw', function () {
const spy = sinon.spy(renderer.helper, 'prepareDraw');
renderer.prepareFrame(frameState);
expect(spy.called).to.be(true);
});
it('fills up a buffer with 2 triangles per point', function(done) {
layer.getSource().addFeature(new Feature({
geometry: new Point([10, 20])
}));
layer.getSource().addFeature(new Feature({
geometry: new Point([30, 40])
}));
it('fills up a buffer with 2 triangles per point', function (done) {
layer.getSource().addFeature(
new Feature({
geometry: new Point([10, 20]),
})
);
layer.getSource().addFeature(
new Feature({
geometry: new Point([30, 40]),
})
);
renderer.prepareFrame(frameState);
const attributePerVertex = 3;
renderer.worker_.addEventListener('message', function(event) {
renderer.worker_.addEventListener('message', function (event) {
if (event.data.type !== WebGLWorkerMessageType.GENERATE_BUFFERS) {
return;
}
expect(renderer.verticesBuffer_.getArray().length).to.eql(2 * 4 * attributePerVertex);
expect(renderer.verticesBuffer_.getArray().length).to.eql(
2 * 4 * attributePerVertex
);
expect(renderer.indicesBuffer_.getArray().length).to.eql(2 * 6);
expect(renderer.verticesBuffer_.getArray()[0]).to.eql(10);
expect(renderer.verticesBuffer_.getArray()[1]).to.eql(20);
expect(renderer.verticesBuffer_.getArray()[4 * attributePerVertex + 0]).to.eql(30);
expect(renderer.verticesBuffer_.getArray()[4 * attributePerVertex + 1]).to.eql(40);
expect(
renderer.verticesBuffer_.getArray()[4 * attributePerVertex + 0]
).to.eql(30);
expect(
renderer.verticesBuffer_.getArray()[4 * attributePerVertex + 1]
).to.eql(40);
done();
});
});
it('fills up the hit render buffer with 2 triangles per point', function(done) {
layer.getSource().addFeature(new Feature({
geometry: new Point([10, 20])
}));
layer.getSource().addFeature(new Feature({
geometry: new Point([30, 40])
}));
it('fills up the hit render buffer with 2 triangles per point', function (done) {
layer.getSource().addFeature(
new Feature({
geometry: new Point([10, 20]),
})
);
layer.getSource().addFeature(
new Feature({
geometry: new Point([30, 40]),
})
);
renderer.prepareFrame(frameState);
const attributePerVertex = 8;
renderer.worker_.addEventListener('message', function(event) {
renderer.worker_.addEventListener('message', function (event) {
if (event.data.type !== WebGLWorkerMessageType.GENERATE_BUFFERS) {
return;
}
if (!renderer.hitVerticesBuffer_.getArray()) {
return;
}
expect(renderer.hitVerticesBuffer_.getArray().length).to.eql(2 * 4 * attributePerVertex);
expect(renderer.hitVerticesBuffer_.getArray().length).to.eql(
2 * 4 * attributePerVertex
);
expect(renderer.indicesBuffer_.getArray().length).to.eql(2 * 6);
expect(renderer.hitVerticesBuffer_.getArray()[0]).to.eql(10);
expect(renderer.hitVerticesBuffer_.getArray()[1]).to.eql(20);
expect(renderer.hitVerticesBuffer_.getArray()[4 * attributePerVertex + 0]).to.eql(30);
expect(renderer.hitVerticesBuffer_.getArray()[4 * attributePerVertex + 1]).to.eql(40);
expect(
renderer.hitVerticesBuffer_.getArray()[4 * attributePerVertex + 0]
).to.eql(30);
expect(
renderer.hitVerticesBuffer_.getArray()[4 * attributePerVertex + 1]
).to.eql(40);
done();
});
});
it('clears the buffers when the features are gone', function(done) {
it('clears the buffers when the features are gone', function (done) {
const source = layer.getSource();
source.addFeature(new Feature({
geometry: new Point([10, 20])
}));
source.addFeature(
new Feature({
geometry: new Point([10, 20]),
})
);
source.removeFeature(source.getFeatures()[0]);
source.addFeature(new Feature({
geometry: new Point([10, 20])
}));
source.addFeature(
new Feature({
geometry: new Point([10, 20]),
})
);
renderer.prepareFrame(frameState);
renderer.worker_.addEventListener('message', function(event) {
renderer.worker_.addEventListener('message', function (event) {
if (event.data.type !== WebGLWorkerMessageType.GENERATE_BUFFERS) {
return;
}
const attributePerVertex = 3;
expect(renderer.verticesBuffer_.getArray().length).to.eql(4 * attributePerVertex);
expect(renderer.verticesBuffer_.getArray().length).to.eql(
4 * attributePerVertex
);
expect(renderer.indicesBuffer_.getArray().length).to.eql(6);
done();
});
});
it('rebuilds the buffers only when not interacting or animating', function() {
it('rebuilds the buffers only when not interacting or animating', function () {
const spy = sinon.spy(renderer, 'rebuildBuffers_');
frameState.viewHints[ViewHint.INTERACTING] = 1;
@@ -222,7 +251,7 @@ describe('ol.renderer.webgl.PointsLayer', function() {
expect(spy.called).to.be(true);
});
it('rebuilds the buffers only when the frame extent changed', function() {
it('rebuilds the buffers only when the frame extent changed', function () {
const spy = sinon.spy(renderer, 'rebuildBuffers_');
renderer.prepareFrame(frameState);
@@ -236,7 +265,7 @@ describe('ol.renderer.webgl.PointsLayer', function() {
expect(spy.callCount).to.be(2);
});
it('triggers source loading when the extent changes', function() {
it('triggers source loading when the extent changes', function () {
const spy = sinon.spy(layer.getSource(), 'loadFeatures');
renderer.prepareFrame(frameState);
@@ -251,7 +280,7 @@ describe('ol.renderer.webgl.PointsLayer', function() {
expect(spy.getCall(1).args[0]).to.eql([0, 10, 40, 50]); // renderBuffer is 10
});
it('triggers source loading when the source revision changes', function() {
it('triggers source loading when the source revision changes', function () {
const spy = sinon.spy(layer.getSource(), 'loadFeatures');
renderer.prepareFrame(frameState);
@@ -266,39 +295,51 @@ describe('ol.renderer.webgl.PointsLayer', function() {
});
});
describe('#forEachFeatureAtCoordinate', function() {
describe('#forEachFeatureAtCoordinate', function () {
let layer, renderer, feature, feature2;
beforeEach(function() {
beforeEach(function () {
feature = new Feature({geometry: new Point([0, 0]), id: 1});
feature2 = new Feature({geometry: new Point([14, 14]), id: 2});
layer = new VectorLayer({
source: new VectorSource({
features: [feature, feature2]
})
features: [feature, feature2],
}),
});
renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader,
hitVertexShader: hitVertexShader,
hitFragmentShader: hitFragmentShader
hitFragmentShader: hitFragmentShader,
});
});
it('correctly hit detects a feature', function(done) {
const transform = composeTransform(createTransform(), 20, 20, 1, -1, 0, 0, 0);
const frameState = Object.assign({
extent: [-20, -20, 20, 20],
size: [40, 40],
coordinateToPixelTransform: transform
}, baseFrameState);
it('correctly hit detects a feature', function (done) {
const transform = composeTransform(
createTransform(),
20,
20,
1,
-1,
0,
0,
0
);
const frameState = Object.assign(
{
extent: [-20, -20, 20, 20],
size: [40, 40],
coordinateToPixelTransform: transform,
},
baseFrameState
);
let found;
const cb = function(feature) {
const cb = function (feature) {
found = feature;
};
renderer.prepareFrame(frameState);
renderer.worker_.addEventListener('message', function() {
renderer.worker_.addEventListener('message', function () {
if (!renderer.hitRenderInstructions_) {
return;
}
@@ -327,21 +368,33 @@ describe('ol.renderer.webgl.PointsLayer', function() {
});
});
it('correctly hit detects with pixelratio != 1', function(done) {
const transform = composeTransform(createTransform(), 20, 20, 1, -1, 0, 0, 0);
const frameState = Object.assign({
pixelRatio: 3,
extent: [-20, -20, 20, 20],
size: [40, 40],
coordinateToPixelTransform: transform
}, baseFrameState);
it('correctly hit detects with pixelratio != 1', function (done) {
const transform = composeTransform(
createTransform(),
20,
20,
1,
-1,
0,
0,
0
);
const frameState = Object.assign(
{
pixelRatio: 3,
extent: [-20, -20, 20, 20],
size: [40, 40],
coordinateToPixelTransform: transform,
},
baseFrameState
);
let found;
const cb = function(feature) {
const cb = function (feature) {
found = feature;
};
renderer.prepareFrame(frameState);
renderer.worker_.addEventListener('message', function() {
renderer.worker_.addEventListener('message', function () {
if (!renderer.hitRenderInstructions_) {
return;
}
@@ -371,14 +424,14 @@ describe('ol.renderer.webgl.PointsLayer', function() {
});
});
describe('#disposeInternal', function() {
it('terminates the worker and calls dispose on the helper', function() {
describe('#disposeInternal', function () {
it('terminates the worker and calls dispose on the helper', function () {
const layer = new VectorLayer({
source: new VectorSource()
source: new VectorSource(),
});
const renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader
fragmentShader: simpleFragmentShader,
});
const spyHelper = sinon.spy(renderer.helper, 'disposeInternal');
@@ -389,67 +442,79 @@ describe('ol.renderer.webgl.PointsLayer', function() {
});
});
describe('featureCache_', function() {
describe('featureCache_', function () {
let source, layer, features;
function getCache(feature, renderer) {
return renderer.featureCache_[getUid(feature)];
}
beforeEach(function() {
beforeEach(function () {
source = new VectorSource();
layer = new VectorLayer({
source
source,
});
features = [
new Feature({
id: 'A',
test: 'abcd',
geometry: new Point([0, 1])
geometry: new Point([0, 1]),
}),
new Feature({
id: 'D',
test: 'efgh',
geometry: new Point([2, 3])
geometry: new Point([2, 3]),
}),
new Feature({
id: 'C',
test: 'ijkl',
geometry: new Point([4, 5])
})
geometry: new Point([4, 5]),
}),
];
});
it('contains no features initially', function() {
it('contains no features initially', function () {
const renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader
fragmentShader: simpleFragmentShader,
});
expect(renderer.featureCount_).to.be(0);
});
it('contains the features initially present in the source', function() {
it('contains the features initially present in the source', function () {
source.addFeatures(features);
const renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader
fragmentShader: simpleFragmentShader,
});
expect(renderer.featureCount_).to.be(3);
expect(getCache(features[0], renderer).feature).to.be(features[0]);
expect(getCache(features[0], renderer).geometry).to.be(features[0].getGeometry());
expect(getCache(features[0], renderer).properties['test']).to.be(features[0].get('test'));
expect(getCache(features[0], renderer).geometry).to.be(
features[0].getGeometry()
);
expect(getCache(features[0], renderer).properties['test']).to.be(
features[0].get('test')
);
expect(getCache(features[1], renderer).feature).to.be(features[1]);
expect(getCache(features[1], renderer).geometry).to.be(features[1].getGeometry());
expect(getCache(features[1], renderer).properties['test']).to.be(features[1].get('test'));
expect(getCache(features[1], renderer).geometry).to.be(
features[1].getGeometry()
);
expect(getCache(features[1], renderer).properties['test']).to.be(
features[1].get('test')
);
expect(getCache(features[2], renderer).feature).to.be(features[2]);
expect(getCache(features[2], renderer).geometry).to.be(features[2].getGeometry());
expect(getCache(features[2], renderer).properties['test']).to.be(features[2].get('test'));
expect(getCache(features[2], renderer).geometry).to.be(
features[2].getGeometry()
);
expect(getCache(features[2], renderer).properties['test']).to.be(
features[2].get('test')
);
});
it('contains the features added to the source', function() {
it('contains the features added to the source', function () {
const renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader
fragmentShader: simpleFragmentShader,
});
source.addFeature(features[0]);
@@ -459,17 +524,25 @@ describe('ol.renderer.webgl.PointsLayer', function() {
expect(renderer.featureCount_).to.be(2);
expect(getCache(features[0], renderer).feature).to.be(features[0]);
expect(getCache(features[0], renderer).geometry).to.be(features[0].getGeometry());
expect(getCache(features[0], renderer).properties['test']).to.be(features[0].get('test'));
expect(getCache(features[0], renderer).geometry).to.be(
features[0].getGeometry()
);
expect(getCache(features[0], renderer).properties['test']).to.be(
features[0].get('test')
);
expect(getCache(features[1], renderer).feature).to.be(features[1]);
expect(getCache(features[1], renderer).geometry).to.be(features[1].getGeometry());
expect(getCache(features[1], renderer).properties['test']).to.be(features[1].get('test'));
expect(getCache(features[1], renderer).geometry).to.be(
features[1].getGeometry()
);
expect(getCache(features[1], renderer).properties['test']).to.be(
features[1].get('test')
);
});
it('does not contain the features removed to the source', function() {
it('does not contain the features removed to the source', function () {
const renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader
fragmentShader: simpleFragmentShader,
});
source.addFeatures(features);
@@ -479,17 +552,25 @@ describe('ol.renderer.webgl.PointsLayer', function() {
expect(renderer.featureCount_).to.be(2);
expect(getCache(features[0], renderer).feature).to.be(features[0]);
expect(getCache(features[0], renderer).geometry).to.be(features[0].getGeometry());
expect(getCache(features[0], renderer).properties['test']).to.be(features[0].get('test'));
expect(getCache(features[0], renderer).geometry).to.be(
features[0].getGeometry()
);
expect(getCache(features[0], renderer).properties['test']).to.be(
features[0].get('test')
);
expect(getCache(features[2], renderer).feature).to.be(features[2]);
expect(getCache(features[2], renderer).geometry).to.be(features[2].getGeometry());
expect(getCache(features[2], renderer).properties['test']).to.be(features[2].get('test'));
expect(getCache(features[2], renderer).geometry).to.be(
features[2].getGeometry()
);
expect(getCache(features[2], renderer).properties['test']).to.be(
features[2].get('test')
);
});
it('contains up to date properties and geometry', function() {
it('contains up to date properties and geometry', function () {
const renderer = new WebGLPointsLayerRenderer(layer, {
vertexShader: simpleVertexShader,
fragmentShader: simpleFragmentShader
fragmentShader: simpleFragmentShader,
});
source.addFeatures(features);
@@ -499,10 +580,16 @@ describe('ol.renderer.webgl.PointsLayer', function() {
expect(renderer.featureCount_).to.be(3);
expect(getCache(features[0], renderer).feature).to.be(features[0]);
expect(getCache(features[0], renderer).geometry.getCoordinates()).to.eql([10, 20]);
expect(getCache(features[0], renderer).properties['test']).to.be(features[0].get('test'));
expect(getCache(features[0], renderer).properties['added']).to.be(features[0].get('added'));
expect(getCache(features[0], renderer).geometry.getCoordinates()).to.eql([
10,
20,
]);
expect(getCache(features[0], renderer).properties['test']).to.be(
features[0].get('test')
);
expect(getCache(features[0], renderer).properties['added']).to.be(
features[0].get('added')
);
});
});
});