@pirireis/webglobeplugins 0.9.11 → 0.9.13

package/heatwave/isobar/quadtreecontours.js

@@ -1,30 +1,17 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaleParameters = scaleParameters;
 // © 2019 3D Robotics. License: Apache-2.0
 /* eslint no-plusplus: "off", prefer-rest-params: "off" */
-var OUTSIDE = 0;
-var ABOVE = 1;
-var BELOW = 2;
-var WITHIN = 3;
+const OUTSIDE = 0;
+const ABOVE = 1;
+const BELOW = 2;
+const WITHIN = 3;
 // Build mipmap layer N from layer N+1
-function mipmapReduce(_a) {
-    var min = _a.min, max = _a.max, width = _a.width, height = _a.height, scale = _a.scale;
-    var outWidth = Math.ceil(width / 2);
-    var outHeight = Math.ceil(height / 2);
+function mipmapReduce({ min, max, width, height, scale }) {
+    const outWidth = Math.ceil(width / 2);
+    const outHeight = Math.ceil(height / 2);
     function reduceWith(data, reduce) {
-        var out = new Float32Array(outWidth * outHeight);
-        var x;
-        var y;
+        const out = new Float32Array(outWidth * outHeight);
+        let x;
+        let y;
         for (y = 0; y < Math.floor(height / 2); y++) {
             for (x = 0; x < Math.floor(width / 2); x++) {
                 out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 0) * width + (x * 2 + 1)], data[(y * 2 + 1) * width + (x * 2 + 0)], data[(y * 2 + 1) * width + (x * 2 + 1)]);
@@ -44,18 +31,18 @@ function mipmapReduce(_a) {
         return out;
     }
     function minFinite() {
-        var r = Infinity;
-        for (var i = 0; i < arguments.length; i++) { // significantly faster than the code Babel generates for ...args
-            var v = arguments[i];
+        let r = Infinity;
+        for (let i = 0; i < arguments.length; i++) { // significantly faster than the code Babel generates for ...args
+            const v = arguments[i];
             if (v < r)
                 r = v;
         }
         return r;
     }
     function maxFinite() {
-        var r = -Infinity;
-        for (var i = 0; i < arguments.length; i++) {
-            var v = arguments[i];
+        let r = -Infinity;
+        for (let i = 0; i < arguments.length; i++) {
+            const v = arguments[i];
             if (v > r)
                 r = v;
         }
@@ -69,45 +56,43 @@ function mipmapReduce(_a) {
         scale: scale * 2,
     };
 }
-var ContourMipmap = /** @class */ (function () {
-    function ContourMipmap(raster, width, height) {
+class ContourMipmap {
+    constructor(raster, width, height) {
         // Bottom mipmap layer is just the raster: at each pixel the minimum and maximum are the same
-        this.levels = [{ min: raster, max: raster, width: width, height: height, scale: 1 }];
+        this.levels = [{ min: raster, max: raster, width, height, scale: 1 }];
         while (this.levels[0].width > 1 || this.levels[0].height > 1) {
             this.levels.unshift(mipmapReduce(this.levels[0]));
         }
     }
     // Get the minimum elevation in the mipmap
-    ContourMipmap.prototype.min = function () { return this.levels[0].min[0]; };
+    min() { return this.levels[0].min[0]; }
     // Get the maximum elevation in the mipmap
-    ContourMipmap.prototype.max = function () { return this.levels[0].max[0]; };
+    max() { return this.levels[0].max[0]; }
     // Get an array of contour levels for a specified contour interval
-    ContourMipmap.prototype.intervals = function (interval) {
+    intervals(interval) {
         if (interval <= 0)
             throw new Error('Contour interval must be positive');
-        var min = this.min();
-        var max = this.max();
-        var levels = [];
-        var level = Math.ceil(min / interval) * interval;
+        const min = this.min();
+        const max = this.max();
+        const levels = [];
+        let level = Math.ceil(min / interval) * interval;
         while (level < max) {
             levels.push(level);
             level += interval;
         }
         return levels;
-    };
+    }
     // Walk the quadtree for a specified contour level, and pass quadtree nodes
     // and contour line segments to the callbacks. This is used for visualizing
     // the quadtree; in most cases you should use .contour() instead, which
     // assembles the line segments into lines and rings.
-    ContourMipmap.prototype.evaluateContour = function (contourLevel, _a, addLine, addNode) {
-        var _this = this;
-        var maxMipmapLevel = _a.maxMipmapLevel;
+    evaluateContour(contourLevel, { maxMipmapLevel }, addLine, addNode) {
         maxMipmapLevel = maxMipmapLevel || this.levels.length - 1;
         // Test the mipmap at the given coordinate and level, returning whether the contour line is ABOVE, BELOW, or WITHIN this mipmap cell
         // If the mipmap is out of bounds or NaN at that point, OUTSIDE is returned.
-        var evaluate = function (l, x, y) {
-            var ml = _this.levels[l];
-            var i = ml.width * y + x;
+        const evaluate = (l, x, y) => {
+            const ml = this.levels[l];
+            const i = ml.width * y + x;
             if (x >= ml.width || y >= ml.height || !Number.isFinite(ml.min[i]) || !Number.isFinite(ml.max[i]))
                 return OUTSIDE;
             if (ml.min[i] >= contourLevel)
@@ -125,8 +110,8 @@ var ContourMipmap = /** @class */ (function () {
         // level, it is added directly, otherwise split the edge and recurse at a
         // more detailed mipmap level.
         function edgeH(l, x, y) {
-            var e1 = evaluate(l, x, y);
-            var e2 = evaluate(l, x + 1, y);
+            const e1 = evaluate(l, x, y);
+            const e2 = evaluate(l, x + 1, y);
             if (e1 === ABOVE && e2 === BELOW) {
                 addLine(l, x + 1, y + 1, x + 1, y);
             }
@@ -143,8 +128,8 @@ var ContourMipmap = /** @class */ (function () {
         // Like edgeH, but for horizontal contour lines between the passed cell
         // and its vertical neighbor below.
         function edgeV(l, x, y) {
-            var e1 = evaluate(l, x, y);
-            var e2 = evaluate(l, x, y + 1);
+            const e1 = evaluate(l, x, y);
+            const e2 = evaluate(l, x, y + 1);
             if (e1 === ABOVE && e2 === BELOW) {
                 addLine(l, x, y + 1, x + 1, y + 1);
             }
@@ -160,7 +145,7 @@ var ContourMipmap = /** @class */ (function () {
         // It recurses into the four quadrants of the cell, and also uses edgeH and
         // edgeV to add the contour lines that exist between quadrants.
         function node(l, x, y) {
-            var e = evaluate(l, x, y);
+            let e = evaluate(l, x, y);
             if (e === WITHIN) {
                 node(l + 1, x * 2 + 0, y * 2 + 0);
                 node(l + 1, x * 2 + 1, y * 2 + 0);
@@ -177,7 +162,7 @@ var ContourMipmap = /** @class */ (function () {
             }
         }
         node(0, 0, 0);
-    };
+    }
     // Generate a contour line for a specified value
     //
     // level: Value in the input array at which to draw a contour line
@@ -191,28 +176,25 @@ var ContourMipmap = /** @class */ (function () {
     // }
     //
     // Returns an array of lines, where each line is an array of [x, y] pairs.
-    ContourMipmap.prototype.contour = function (level, _a) {
-        var _this = this;
-        var _b = _a === void 0 ? {} : _a, maxMipmapLevel = _b.maxMipmapLevel, _c = _b.smoothKernelWidth, smoothKernelWidth = _c === void 0 ? 2 : _c, _d = _b.smoothCycles, smoothCycles = _d === void 0 ? 2 : _d, _e = _b.minPoints, minPoints = _e === void 0 ? 0 : _e;
+    contour(level, { maxMipmapLevel, smoothKernelWidth = 2, smoothCycles = 2, minPoints = 0 } = {}) {
         // Use the quadtree algorithm to generate line segments that make up the contour
-        var segments = [];
-        this.evaluateContour(level, { maxMipmapLevel: maxMipmapLevel }, function (l, x1, y1, x2, y2) {
-            var scale = _this.levels[l].scale;
-            var start = [scale * x1, scale * y1];
-            var end = [scale * x2, scale * y2];
-            segments.push({ start: start, end: end });
+        const segments = [];
+        this.evaluateContour(level, { maxMipmapLevel }, (l, x1, y1, x2, y2) => {
+            const scale = this.levels[l].scale;
+            const start = [scale * x1, scale * y1];
+            const end = [scale * x2, scale * y2];
+            segments.push({ start, end });
         });
-        segments.sort(function (a, b) { return key(a.start) - key(b.start); });
+        segments.sort((a, b) => key(a.start) - key(b.start));
         // .. and then join them together into rings
         // An arbitrary function to use a 2D point as a Map key
         function key(a) { return a[0] + a[1] * 65536; }
-        var fragmentStart = new Map();
-        var fragmentEnd = new Map();
-        var rings = [];
-        segments.forEach(function (_a) {
-            var start = _a.start, end = _a.end;
-            var a = fragmentEnd.get(key(start));
-            var b = fragmentStart.get(key(end));
+        const fragmentStart = new Map();
+        const fragmentEnd = new Map();
+        const rings = [];
+        segments.forEach(({ start, end }) => {
+            const a = fragmentEnd.get(key(start));
+            const b = fragmentStart.get(key(end));
             if (a && b) {
                 fragmentEnd.delete(key(start));
                 fragmentStart.delete(key(end));
@@ -223,7 +205,7 @@ var ContourMipmap = /** @class */ (function () {
                 }
                 else {
                     // Join two lines together
-                    var c = a.concat(b);
+                    const c = a.concat(b);
                     fragmentStart.set(key(c[0]), c);
                     fragmentEnd.set(key(c[c.length - 1]), c);
                 }
@@ -242,46 +224,45 @@ var ContourMipmap = /** @class */ (function () {
             }
             else {
                 // New line doesn't connect to any existing line
-                var c = [start, end];
+                const c = [start, end];
                 fragmentStart.set(key(start), c);
                 fragmentEnd.set(key(end), c);
             }
             if (fragmentStart.size !== fragmentEnd.size) {
-                console.error("Contour remaining fragment size mismatch ".concat(fragmentStart.size, " ").concat(fragmentEnd.size));
+                console.error(`Contour remaining fragment size mismatch ${fragmentStart.size} ${fragmentEnd.size}`);
             }
         });
-        var smoothOpts = {
+        const smoothOpts = {
             kernelWidth: smoothKernelWidth,
             cycles: smoothCycles,
         };
         // Closed rings and any unclosed line strings
-        return __spreadArray(__spreadArray([], rings, true), fragmentStart.values(), true).filter(function (l) { return l.length >= minPoints && l.length >= smoothKernelWidth * 2; })
-            .map(function (l) { return smooth(l, smoothOpts); });
-    };
-    return ContourMipmap;
-}());
+        return [...rings, ...fragmentStart.values()]
+            .filter(l => l.length >= minPoints && l.length >= smoothKernelWidth * 2)
+            .map(l => smooth(l, smoothOpts));
+    }
+}
 // Smooth a line by repeatedly applying a rectangular filter to approximate
 // a gaussian filter. It detects closed loops and preserves them.
 // The line is passed as an array of `[x, y]` pairs.
 //
 // kernelWidth: Width of the rectangular filter kernel
 // cycles: Number of times to apply the kernel
-function smooth(line, _a) {
-    var _b = _a.kernelWidth, kernelWidth = _b === void 0 ? 2 : _b, _c = _a.cycles, cycles = _c === void 0 ? 2 : _c;
-    var isLoop = line[0][0] === line[line.length - 1][0] && line[0][1] === line[line.length - 1][1];
-    var pointAt;
+function smooth(line, { kernelWidth = 2, cycles = 2 }) {
+    const isLoop = line[0][0] === line[line.length - 1][0] && line[0][1] === line[line.length - 1][1];
+    let pointAt;
     if (isLoop) {
-        pointAt = function (i) { return line[(i + line.length) % line.length]; };
+        pointAt = i => line[(i + line.length) % line.length];
     }
     else {
-        pointAt = function (i) { return line[Math.min(Math.max(i, 0), line.length - 1)]; };
+        pointAt = i => line[Math.min(Math.max(i, 0), line.length - 1)];
     }
-    var sc = 1.0 / (kernelWidth * 2);
-    for (var cycle = 0; cycle < cycles; cycle++) {
-        var px = 0;
-        var py = 0;
+    const sc = 1.0 / (kernelWidth * 2);
+    for (let cycle = 0; cycle < cycles; cycle++) {
+        let px = 0;
+        let py = 0;
         if (isLoop) {
-            for (var i = line.length - kernelWidth; i < line.length; i++) {
+            for (let i = line.length - kernelWidth; i < line.length; i++) {
                 px += line[i][0];
                 py += line[i][1];
             }
@@ -290,12 +271,12 @@ function smooth(line, _a) {
             px = line[0][0] * kernelWidth;
             py = line[0][1] * kernelWidth;
         }
-        for (var i = 0; i < kernelWidth; i++) {
+        for (let i = 0; i < kernelWidth; i++) {
             px += line[i][0];
             py += line[i][1];
         }
-        var res = line.slice();
-        for (var i = 0; i < line.length; i++) {
+        const res = line.slice();
+        for (let i = 0; i < line.length; i++) {
             res[i] = [px * sc, py * sc];
             px += pointAt(i + kernelWidth)[0] - pointAt(i - kernelWidth)[0];
             py += pointAt(i + kernelWidth)[1] - pointAt(i - kernelWidth)[1];
@@ -309,8 +290,9 @@ function smooth(line, _a) {
     return line;
 }
 function scaleParameters(minLongitude, minLatitude, maxLongitude, maxLatitude, width, height) {
-    var scaleX = (maxLongitude - minLongitude) / width;
-    var scaleY = (maxLatitude - minLatitude) / height;
-    return { scaleX: scaleX, scaleY: scaleY };
+    const scaleX = (maxLongitude - minLongitude) / width;
+    const scaleY = (maxLatitude - minLatitude) / height;
+    return { scaleX, scaleY };
 }
-exports.default = ContourMipmap;
+export default ContourMipmap;
+export { scaleParameters };

package/heatwave/plugins/heatwaveglobeshell.js

@@ -1,17 +1,6 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var util_1 = require("../../util");
-var programs_1 = require("../../programs");
-var typecheck_1 = require("../../util/check/typecheck");
+import { getColorRampModed, DataManager, PointCoordinatesDataCalculator } from "../../util";
+import { GlobeShellWiggle, Float2LegendWithRatio } from "../../programs";
+import { opacityCheck } from "../../util/check/typecheck";
 /**
  * @param id : string
  * @param dataManager : DataManager
@@ -19,9 +8,8 @@ var typecheck_1 = require("../../util/check/typecheck");
  * @param dataWidthHeight : {width: number, height: number}
  * @param options : {bbox: number[], minMaxEdges: {min: number, max: number}, escapeValue: number, resolution: number[], meshPartition: number[]}
  */
-var HeatWaveGlobeShellPlugin = /** @class */ (function () {
-    function HeatWaveGlobeShellPlugin(id, dataManager, colorRampData, dataWidthHeight, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.bbox, bbox = _c === void 0 ? [-180, -90, 180, 90] : _c, _d = _b.minMaxEdges, minMaxEdges = _d === void 0 ? { min: -99999, max: 99999 } : _d, _e = _b.escapeValue, escapeValue = _e === void 0 ? 99999 : _e, _f = _b.resolution, resolution = _f === void 0 ? [2056, 2056] : _f, _g = _b.yFlip, yFlip = _g === void 0 ? true : _g;
+export default class HeatWaveGlobeShellPlugin {
+    constructor(id, dataManager, colorRampData, dataWidthHeight, { bbox = [-180, -90, 180, 90], minMaxEdges = { min: -99999, max: 99999 }, escapeValue = 99999, resolution = [2056, 2056], yFlip = true, } = {}) {
         this.id = id;
         this.dataManager = dataManager;
         this._dataWidthHeight = dataWidthHeight;
@@ -40,63 +28,60 @@ var HeatWaveGlobeShellPlugin = /** @class */ (function () {
         this.enabled = false;
         this.isAble = false;
     }
-    HeatWaveGlobeShellPlugin.prototype.setHeight = function (height) {
+    setHeight(height) {
         this.globeShell.setHeight(height);
-    };
-    HeatWaveGlobeShellPlugin.prototype.drawHeat = function () {
-        var gl = this.gl;
+    }
+    drawHeat() {
+        const gl = this.gl;
         gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
         gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._coloredHeatTexture, 0);
         gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        var currentWidth = gl.canvas.width;
-        var currentHeight = gl.canvas.height;
-        gl.viewport.apply(gl, __spreadArray([0, 0], this._resolution, false));
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        const currentWidth = gl.canvas.width;
+        const currentHeight = gl.canvas.height;
+        gl.viewport(0, 0, ...this._resolution);
         this.heatProgram.draw();
         gl.viewport(0, 0, currentWidth, currentHeight);
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
         gl.useProgram(currentProgram);
         this.globe.DrawRender();
-    };
-    HeatWaveGlobeShellPlugin.prototype.setEscapeValue = function (escapeValue) {
+    }
+    setEscapeValue(escapeValue) {
         this._escapeValue = escapeValue;
         this.heatProgram.setEscapeValue(escapeValue);
-    };
-    HeatWaveGlobeShellPlugin.prototype._createPointCoordinatesDataCalculator = function () {
-        this.coordinatesDataCalculator = new util_1.PointCoordinatesDataCalculator(this._bbox, this._dataWidthHeight.width, this._dataWidthHeight.height);
+    }
+    _createPointCoordinatesDataCalculator() {
+        this.coordinatesDataCalculator = new PointCoordinatesDataCalculator(this._bbox, this._dataWidthHeight.width, this._dataWidthHeight.height);
         this.dataManager.register(this._coordinatesDataCalculatorID(), this.coordinatesDataCalculator.updateData.bind(this.coordinatesDataCalculator));
-    };
-    HeatWaveGlobeShellPlugin.prototype._coordinatesDataCalculatorID = function () {
+    }
+    _coordinatesDataCalculatorID() {
         return this.id + "_coordinatesDataCalculator";
-    };
-    HeatWaveGlobeShellPlugin.prototype.updateTime = function (time) {
+    }
+    updateTime(time) {
         this.dataManager.updateTime(time);
         this.globe.DrawRender();
-    };
-    HeatWaveGlobeShellPlugin.prototype.setWiggle = function (_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.wiggleInKm, wiggleInKm = _c === void 0 ? null : _c, _d = _b.wiggleSpeed, wiggleSpeed = _d === void 0 ? null : _d;
-        this.globeShell.setWiggle({ wiggleInKm: wiggleInKm, wiggleSpeed: wiggleSpeed });
-    };
-    HeatWaveGlobeShellPlugin.prototype.setMinMaxEdges = function (min, max) {
-        if (min === void 0) { min = null; }
-        if (max === void 0) { max = null; }
+    }
+    setWiggle({ wiggleInKm = null, wiggleSpeed = null } = {}) {
+        this.globeShell.setWiggle({ wiggleInKm, wiggleSpeed });
+    }
+    setMinMaxEdges(min = null, max = null) {
         if (min)
             this._minMaxEdges.min = min;
         if (max)
             this._minMaxEdges.max = max;
         this.heatProgram.setMinMaxEdges(this._minMaxEdges.min, this._minMaxEdges.max);
         this.drawHeat();
-    };
-    HeatWaveGlobeShellPlugin.prototype.setBBox = function (minLon, minLat, maxLon, maxLat) {
+    }
+    setBBox(minLon, minLat, maxLon, maxLat) {
         this._bbox = [minLon, minLat, maxLon, maxLat];
-        this.globeShell.setBBox({ minLon: minLon, minLat: minLat, maxLon: maxLon, maxLat: maxLat });
+        this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
         this.drawHeat();
-    };
-    HeatWaveGlobeShellPlugin.prototype.getPointCoordinatesDataCalculator = function () {
+    }
+    getPointCoordinatesDataCalculator() {
         if (!this.coordinatesDataCalculator)
             this._createPointCoordinatesDataCalculator();
         return this.coordinatesDataCalculator;
-    };
+    }
     /**
      * @param {*} values n + 1 number of color hex values without alpha channel. Ex: ["#ff0000", "#00ff00", "#0000ff"]
      * @param {*} thresholds n number of thresholds. Ex: [0, 10, 20]
@@ -105,26 +90,23 @@ var HeatWaveGlobeShellPlugin = /** @class */ (function () {
      * There are maximum 256 pixels in the color ramp.
      * The first values array is minimum edge value which is the first pixel, the second comes one pixel after the first.
      */
-    HeatWaveGlobeShellPlugin.prototype.setColorRamp = function (values, thresholds, mode) {
-        if (mode === void 0) { mode = "interpolated"; }
-        var lowest = thresholds[0];
-        var highest = thresholds[thresholds.length - 1];
-        var range = highest - lowest;
-        var clampedThresholds = thresholds.map(function (t) { return (t - lowest) / range; });
-        var colors = (0, util_1.getColorRampModed)(values, clampedThresholds, mode);
+    setColorRamp(values, thresholds, mode = "interpolated") {
+        const lowest = thresholds[0];
+        const highest = thresholds[thresholds.length - 1];
+        const range = highest - lowest;
+        const clampedThresholds = thresholds.map((t) => (t - lowest) / range);
+        const colors = getColorRampModed(values, clampedThresholds, mode);
         this.heatProgram.setColorRampTextureData(colors, 256);
         this.heatProgram.setColorRampRange(lowest, highest);
         this.drawHeat();
-    };
-    HeatWaveGlobeShellPlugin.prototype.off = function () {
+    }
+    off() {
         this._isOn = false;
-    };
-    HeatWaveGlobeShellPlugin.prototype.on = function () {
+    }
+    on() {
         this._isOn = true;
-    };
-    HeatWaveGlobeShellPlugin.prototype._updateData = function (ratio, textureData0, textureData1) {
-        if (textureData0 === void 0) { textureData0 = null; }
-        if (textureData1 === void 0) { textureData1 = null; }
+    }
+    _updateData(ratio, textureData0 = null, textureData1 = null) {
         if (!textureData0 || !textureData1) {
             if (this._disCarded)
                 return;
@@ -142,35 +124,34 @@ var HeatWaveGlobeShellPlugin = /** @class */ (function () {
             this.heatProgram.setFloatTextureData(textureData0, textureData1, this._dataWidthHeight.width, this._dataWidthHeight.height, this._yFlip);
         }
         this.drawHeat();
-    };
-    HeatWaveGlobeShellPlugin.prototype.setDataWidthHeight = function (width, height) {
-        this._dataWidthHeight = { width: width, height: height };
+    }
+    setDataWidthHeight(width, height) {
+        this._dataWidthHeight = { width, height };
         this.heatProgram.setDataWidthHeight(width, height);
         this.setGeometry();
-    };
-    HeatWaveGlobeShellPlugin.prototype.draw3D = function () {
+    }
+    draw3D() {
         if (!this._isOn)
             return;
         // if (!this.isAble) return;
         this.gl.disable(this.gl.DEPTH_TEST);
         this.globeShell.draw();
         this.gl.enable(this.gl.DEPTH_TEST);
-    };
-    HeatWaveGlobeShellPlugin.prototype.setOpacity = function (opacity) {
-        (0, typecheck_1.opacityCheck)(opacity);
+    }
+    setOpacity(opacity) {
+        opacityCheck(opacity);
         this.globeShell.setOpacity(opacity);
-    };
-    HeatWaveGlobeShellPlugin.prototype._setAfterInit = function () {
-        var _a = this._bbox, minLon = _a[0], minLat = _a[1], maxLon = _a[2], maxLat = _a[3];
-        this.globeShell.setBBox({ minLon: minLon, minLat: minLat, maxLon: maxLon, maxLat: maxLat });
+    }
+    _setAfterInit() {
+        const [minLon, minLat, maxLon, maxLat] = this._bbox;
+        this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
         this.setColorRamp(this._colorRampData.values, this._colorRampData.thresholds, this._colorRampData.mode);
         delete this._colorRampData;
         this.setMinMaxEdges(this._minMaxEdges.min, this._minMaxEdges.max);
         this.setEscapeValue(this._escapeValue);
-    };
-    HeatWaveGlobeShellPlugin.prototype._init = function (globe, gl) {
-        var _this = this;
-        this.globeShell = new programs_1.GlobeShellWiggle(gl, globe, {
+    }
+    _init(globe, gl) {
+        this.globeShell = new GlobeShellWiggle(gl, globe, {
             minLon: this._bbox[0],
             minLat: this._bbox[1],
             maxLon: this._bbox[2],
@@ -181,24 +162,24 @@ var HeatWaveGlobeShellPlugin = /** @class */ (function () {
             eastWestTied: false,
             displayMesh: false
         });
-        this.heatProgram = new programs_1.Float2LegendWithRatio(gl);
+        this.heatProgram = new Float2LegendWithRatio(gl);
         this._frameBuffer = gl.createFramebuffer();
-        this.dataManager.register(this.id, function (ratio, t1, t2) { return _this._updateData(ratio, t1, t2); });
+        this.dataManager.register(this.id, (ratio, t1, t2) => this._updateData(ratio, t1, t2));
         this.setResolution(this._resolution[0], this._resolution[1]);
-    };
-    HeatWaveGlobeShellPlugin.prototype.init = function (globe, gl) {
+    }
+    init(globe, gl) {
         this.globe = globe;
         this.gl = gl;
         this._init(globe, gl);
         this._setAfterInit();
-    };
-    HeatWaveGlobeShellPlugin.prototype.setGeometry = function () {
+    }
+    setGeometry() {
         // globeShell has an implicit program, registered and sets its own geometry.
         return;
-    };
+    }
     // sets Density of middle texture which is used with framebuffers
-    HeatWaveGlobeShellPlugin.prototype.setResolution = function (width, height) {
-        var gl = this.gl;
+    setResolution(width, height) {
+        const gl = this.gl;
         this._resolution = [width, height];
         this._coloredHeatTexture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, this._coloredHeatTexture);
@@ -209,8 +190,8 @@ var HeatWaveGlobeShellPlugin = /** @class */ (function () {
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
         gl.bindTexture(gl.TEXTURE_2D, null);
         this.globeShell.setTexture(this._coloredHeatTexture);
-    };
-    HeatWaveGlobeShellPlugin.prototype.free = function () {
+    }
+    free() {
         if (this.coordinatesDataCalculator) {
             this.dataManager.unregister(this._coordinatesDataCalculatorID());
             this.coordinatesDataCalculator = null;
@@ -218,7 +199,5 @@ var HeatWaveGlobeShellPlugin = /** @class */ (function () {
         this.dataManager.unregister(this.id);
         this.globeShell.free();
         this.heatProgram.free();
-    };
-    return HeatWaveGlobeShellPlugin;
-}());
-exports.default = HeatWaveGlobeShellPlugin;
+    }
+}

package/index.js

@@ -1,58 +1,12 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pointheatmap = exports.partialring = exports.arrowfield = exports.programs = exports.util = exports.heatwave = exports.compassrose = exports.rangerings = exports.timetracks = exports.waveparticles = exports.wind = void 0;
-var wind = __importStar(require("./wind"));
-exports.wind = wind;
-var waveparticles = __importStar(require("./waveparticles"));
-exports.waveparticles = waveparticles;
-var timetracks = __importStar(require("./timetracks"));
-exports.timetracks = timetracks;
-var arrowfield = __importStar(require("./arrowfield"));
-exports.arrowfield = arrowfield;
-var rangerings = __importStar(require("./rangerings"));
-exports.rangerings = rangerings;
-var partialring = __importStar(require("./partialrings"));
-exports.partialring = partialring;
-var compassrose = __importStar(require("./compassrose"));
-exports.compassrose = compassrose;
-var heatwave = __importStar(require("./heatwave"));
-exports.heatwave = heatwave;
-var util = __importStar(require("./util"));
-exports.util = util;
-var programs = __importStar(require("./programs"));
-exports.programs = programs;
-var pointheatmap = __importStar(require("./point-heat-map"));
-exports.pointheatmap = pointheatmap;
+import * as wind from "./wind";
+import * as waveparticles from "./waveparticles";
+import * as timetracks from "./timetracks";
+import * as arrowfield from "./arrowfield";
+import * as rangerings from "./rangerings";
+import * as partialring from "./partialrings";
+import * as compassrose from "./compassrose";
+import * as heatwave from "./heatwave";
+import * as util from "./util";
+import * as programs from "./programs";
+import * as pointheatmap from "./point-heat-map";
+export { wind, waveparticles, timetracks, rangerings, compassrose, heatwave, util, programs, arrowfield, partialring, pointheatmap };