Enable linting

.eslintignore

@@ -0,0 +1 @@
+*.d.ts

.github/workflows/test.yml

@@ -13,5 +13,9 @@ jobs:
       - uses: actions/setup-node@v3
         with:
           node-version: 18
+      - name: CI
+        run: npm ci
+      - name: Lint
+        run: npm run lint
       - name: Pseudo release
         run: buildtools/release.sh

package.json

@@ -9,6 +9,7 @@
     "build-umd": "cross-env NODE_ENV=production TARGET=umd webpack --progress --bail",
     "start": "cross-env DEV_SERVER=1 NODE_ENV=development TARGET=examples webpack serve --port 3000 --progress --bail --static-directory .",
     "typecheck": "tsc --pretty",
+    "lint": "eslint src",
     "doc": "typedoc --name ol-cesium --excludeExternals --out dist/apidoc --entryPoints src/index.library.js --tsconfig ./tsconfig.json"
   },
   "main": "./dist/olcesium.js",

src/olcs/AbstractSynchronizer.ts

@@ -28,7 +28,7 @@ abstract class AbstractSynchronizer<T extends ImageryLayer | VectorLayerCounterp
   /**
    * Map of listen keys for OpenLayers layer layers ids (from getUid).
    */
-  protected  olLayerListenKeys: Record<string, Array<EventsKey>> = {};
+  protected olLayerListenKeys: Record<string, Array<EventsKey>> = {};
   /**
    * Map of listen keys for OpenLayers layer groups ids (from getUid).
    */

src/olcs/OLCesium.ts

@@ -46,7 +46,7 @@ const BoundingSphereState: Record<string, number> = {
    * The BoundingSphere does not exist.
    */
   FAILED: 2,
-}
+};
 
 type SceneOptions = {
   canvas: HTMLCanvasElement;
@@ -130,7 +130,7 @@ class OLCesium {
   constructor(options: OLCesiumOptions) {
     this.map_ = options.map;
 
-    this.time_ = options.time || function () {
+    this.time_ = options.time || function() {
       return Cesium.JulianDate.now();
     };
 
@@ -176,10 +176,10 @@ class OLCesium {
       this.canvas_.style['imageRendering'] = imageRenderingValue();
     }
 
-    this.canvas_.oncontextmenu = function () {
+    this.canvas_.oncontextmenu = function() {
       return false;
     };
-    this.canvas_.onselectstart = function () {
+    this.canvas_.onselectstart = function() {
       return false;
     };
 
@@ -382,7 +382,7 @@ class OLCesium {
 
     this.canvas_.width = width;
     this.canvas_.height = height;
-    (<PerspectiveFrustum>this.scene_.camera.frustum).aspectRatio = width / height;
+    (<PerspectiveFrustum> this.scene_.camera.frustum).aspectRatio = width / height;
   }
 
   getCamera(): olcsCamera {
@@ -440,14 +440,14 @@ class OLCesium {
 
         this.map_.addInteraction = interaction => this.pausedInteractions_.push(interaction);
         this.map_.removeInteraction = (interaction) => {
-          let interactionRemoved = false
+          let interactionRemoved = false;
           this.pausedInteractions_ = this.pausedInteractions_.filter((i) => {
             const removed = i !== interaction;
-            if(!interactionRemoved) interactionRemoved = removed
-            return removed
-          })
+            if (!interactionRemoved) {interactionRemoved = removed;}
+            return removed;
+          });
           return interactionRemoved ? interaction : undefined;
-        }
+        };
 
         const rootGroup = this.map_.getLayerGroup();
         if (rootGroup.getVisible()) {

src/olcs/RasterSynchronizer.ts

@@ -95,10 +95,10 @@ class RasterSynchronizer extends olcsAbstractSynchronizer<ImageryLayer> {
 
             const ip = csObj.imageryProvider;
             if (ip) {
-               // @ts-ignore TS2341
-               ip.tileCache?.clear();
-               // @ts-ignore TS2341
-               ip.styleFunction_ = currentStyleFunction;
+              // @ts-ignore TS2341
+              ip.tileCache?.clear();
+              // @ts-ignore TS2341
+              ip.styleFunction_ = currentStyleFunction;
             }
           }
           this.scene.requestRender();

src/olcs/VectorSynchronizer.ts

@@ -21,7 +21,7 @@ import {Primitive, PrimitiveCollection, Scene} from 'cesium';
 
 class VectorSynchronizer extends olcsAbstractSynchronizer<VectorLayerCounterpart> {
   protected converter: olcsFeatureConverter;
-  private csAllPrimitives_: PrimitiveCollection
+  private csAllPrimitives_: PrimitiveCollection;
   /**
    * Unidirectionally synchronize OpenLayers vector layers to Cesium.
    */
@@ -36,7 +36,7 @@ class VectorSynchronizer extends olcsAbstractSynchronizer<VectorLayerCounterpart
 
   addCesiumObject(counterpart: VectorLayerCounterpart) {
     console.assert(counterpart);
-    const collection = <PrimitiveCollectionCounterpart>counterpart.getRootPrimitive()
+    const collection = <PrimitiveCollectionCounterpart>counterpart.getRootPrimitive();
     collection.counterpart = counterpart;
     this.csAllPrimitives_.add(counterpart.getRootPrimitive());
   }

src/olcs/core.ts

@@ -403,7 +403,7 @@ export function sourceToImageryProvider(
           source.getImageExtent()[2],
           source.getImageExtent()[3],
           new Cesium.Rectangle()
-      )
+      );
       provider = new Cesium.SingleTileImageryProvider({
         url: source.getUrl(),
         rectangle
@@ -456,7 +456,7 @@ export function sourceToImageryProvider(
  * Creates Cesium.ImageryLayer best corresponding to the given ol.layer.Layer.
  * Only supports raster layers and export function images
  */
-export function tileLayerToImageryLayer(olMap: Map, olLayer: BaseLayer, viewProj: Projection): ImageryLayer | null  {
+export function tileLayerToImageryLayer(olMap: Map, olLayer: BaseLayer, viewProj: Projection): ImageryLayer | null {
 
   if (!(olLayer instanceof olLayerTile) && !(olLayer instanceof olLayerImage) &&
   !(olLayer instanceof VectorTileLayer)) {
@@ -784,7 +784,7 @@ export function calcResolutionForDistance(distance: number, latitude: number, sc
  */
 export function limitCameraToBoundingSphere(camera: Camera, boundingSphere: BoundingSphere, ratio: (height: number) => number): () => void {
   let blockLimiter = false;
-  return function () {
+  return function() {
     if (!blockLimiter) {
       const position = camera.position;
       const carto = Cesium.Cartographic.fromCartesian(position);

src/olcs/core/VectorLayerCounterpart.ts

@@ -17,11 +17,9 @@ export type OlFeatureToCesiumContext = {
   primitives: PrimitiveCollection
 };
 
-export type PrimitiveCollectionCounterpart = PrimitiveCollection & {counterpart: VectorLayerCounterpart};
-
 
 class VectorLayerCounterpart {
-  olListenKeys: EventsKey[] = []
+  olListenKeys: EventsKey[] = [];
   context: OlFeatureToCesiumContext;
   private rootCollection_: PrimitiveCollection;
   /**
@@ -57,3 +55,4 @@ class VectorLayerCounterpart {
 
 
 export default VectorLayerCounterpart;
+export type PrimitiveCollectionCounterpart = PrimitiveCollection & {counterpart: VectorLayerCounterpart};

src/olcs/print/drawCesiumMask.ts

@@ -12,29 +12,6 @@ interface ProgramInfo {
   }
 }
 
-/**
- *
- */
-export function autoDrawMask(scene: Scene, getScalings: () => number[]) {
-  const canvas = scene.canvas;
-  const ctx = canvas.getContext("webgl2") || canvas.getContext("webgl");
-
-  if (getScalings) {
-    if (!postUnlistener) {
-      const drawer = new MaskDrawer(ctx);
-      postUnlistener = scene.postRender.addEventListener(() => {
-        drawer.drawMask(getScalings());
-      });
-    }
-  }
-  else if (postUnlistener) {
-    postUnlistener();
-    // FIXME: destroy program
-    postUnlistener = null;
-  }
-  scene.requestRender();
-}
-
 
 // CC0 from https://github.com/mdn/dom-examples/tree/main/webgl-examples/tutorial/sample2
 
@@ -49,12 +26,12 @@ export class MaskDrawer {
     this.programInfo = {
       program: shaderProgram,
       attribLocations: {
-        vertexPosition: gl.getAttribLocation(shaderProgram, "aVertexPosition")
+        vertexPosition: gl.getAttribLocation(shaderProgram, 'aVertexPosition')
       },
       uniformLocations: {
         uScaling: gl.getUniformLocation(
-          shaderProgram,
-          "uScaling"
+            shaderProgram,
+            'uScaling'
         )
       }
     };
@@ -93,8 +70,8 @@ export class MaskDrawer {
     const vsSource = this.getVertexShaderSource();
     const fsSource = this.getFragmentShaderSource();
     const vertexShader = MaskDrawer.loadShader(gl, gl.VERTEX_SHADER, vsSource),
-      fragmentShader = MaskDrawer.loadShader(gl, gl.FRAGMENT_SHADER, fsSource),
-      shaderProgram = gl.createProgram();
+        fragmentShader = MaskDrawer.loadShader(gl, gl.FRAGMENT_SHADER, fsSource),
+        shaderProgram = gl.createProgram();
 
     gl.attachShader(shaderProgram, vertexShader);
     gl.attachShader(shaderProgram, fragmentShader);
@@ -104,9 +81,9 @@ export class MaskDrawer {
 
     if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
       throw new Error(
-        `Unable to initialize the shader program: ${gl.getProgramInfoLog(
-          shaderProgram
-        )}`
+          `Unable to initialize the shader program: ${gl.getProgramInfoLog(
+              shaderProgram
+          )}`
       );
     }
 
@@ -126,12 +103,12 @@ export class MaskDrawer {
 
     gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);
     gl.vertexAttribPointer(
-      programInfo.attribLocations.vertexPosition,
-      2,
-      gl.FLOAT,
-      false,
-      0,
-      0
+        programInfo.attribLocations.vertexPosition,
+        2,
+        gl.FLOAT,
+        false,
+        0,
+        0
     );
     gl.enableVertexAttribArray(programInfo.attribLocations.vertexPosition);
     gl.useProgram(programInfo.program);
@@ -140,37 +117,37 @@ export class MaskDrawer {
     // Draw a first time to fill the stencil area while keeping the destination color
     gl.enable(gl.STENCIL_TEST);
     gl.stencilFunc(
-      gl.ALWAYS,
-      1,
-      0xFF
+        gl.ALWAYS,
+        1,
+        0xFF
     );
     gl.stencilOp(
-      gl.KEEP,
-      gl.KEEP,
-      gl.REPLACE
+        gl.KEEP,
+        gl.KEEP,
+        gl.REPLACE
     );
     gl.uniform2fv(
-      programInfo.uniformLocations.uScaling,
-      scaling
+        programInfo.uniformLocations.uScaling,
+        scaling
     );
     gl.blendFunc(gl.ZERO, gl.ONE);
     gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
 
 
     // Now draw again the whole viewport and darken the pixels that are not on the stencil
     gl.stencilFunc(
-      gl.EQUAL,
-      0,
-      0xFF
+        gl.EQUAL,
+        0,
+        0xFF
     );
     gl.stencilOp(
-      gl.KEEP,
-      gl.KEEP,
-      gl.KEEP
+        gl.KEEP,
+        gl.KEEP,
+        gl.KEEP
     );
     gl.uniform2fv(
-      programInfo.uniformLocations.uScaling,
-      [1, 1]
+        programInfo.uniformLocations.uScaling,
+        [1, 1]
     );
     gl.blendFunc(gl.ZERO, gl.SRC_ALPHA);
     gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
@@ -188,11 +165,34 @@ export class MaskDrawer {
 
     if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
       throw new Error(
-        `An error occurred compiling the shaders: ${gl.getShaderInfoLog(shader)}`
+          `An error occurred compiling the shaders: ${gl.getShaderInfoLog(shader)}`
       );
       // gl.deleteShader(shader);
     }
 
     return shader;
   }
 }
+
+/**
+ *
+ */
+export function autoDrawMask(scene: Scene, getScalings: () => number[]) {
+  const canvas = scene.canvas;
+  const ctx = canvas.getContext('webgl2') || canvas.getContext('webgl');
+
+  if (getScalings) {
+    if (!postUnlistener) {
+      const drawer = new MaskDrawer(ctx);
+      postUnlistener = scene.postRender.addEventListener(() => {
+        drawer.drawMask(getScalings());
+      });
+    }
+  }
+  else if (postUnlistener) {
+    postUnlistener();
+    // FIXME: destroy program
+    postUnlistener = null;
+  }
+  scene.requestRender();
+}