autumnplot-gl 2.0.0-beta.1

package/lib/RawField.js

@@ -0,0 +1,340 @@
+import { lambertConformalConic } from "./Map";
+import { layer_worker } from "./PlotComponent";
+import { zip } from "./utils";
+import { WGLBuffer } from "autumn-wgl";
+class Cache {
+    constructor(compute_value) {
+        this.cached_value = null;
+        this.compute_value = compute_value;
+    }
+    getValue(...args) {
+        if (this.cached_value === null) {
+            this.cached_value = this.compute_value(...args);
+        }
+        return this.cached_value;
+    }
+}
+async function makeWGLDomainBuffers(gl, grid, native_grid) {
+    native_grid = native_grid !== undefined ? native_grid : grid;
+    const texcoord_margin_r = 1 / (2 * native_grid.ni);
+    const texcoord_margin_s = 1 / (2 * native_grid.nj);
+    const grid_cell_size_multiplier = (grid.ni * grid.nj) / (native_grid.ni * native_grid.nj);
+    const { lats: field_lats, lons: field_lons } = grid.getCoords();
+    const domain_coords = await layer_worker.makeDomainVerticesAndTexCoords(field_lats, field_lons, grid.ni, grid.nj, texcoord_margin_r, texcoord_margin_s);
+    for (let icd = 0; icd < domain_coords['grid_cell_size'].length; icd++) {
+        domain_coords['grid_cell_size'][icd] *= grid_cell_size_multiplier;
+    }
+    const vertices = new WGLBuffer(gl, domain_coords['vertices'], 2, gl.TRIANGLE_STRIP);
+    const texcoords = new WGLBuffer(gl, domain_coords['tex_coords'], 2, gl.TRIANGLE_STRIP);
+    const grid_cell_size = new WGLBuffer(gl, domain_coords['grid_cell_size'], 1, gl.TRIANGLE_STRIP);
+    return { 'vertices': vertices, 'texcoords': texcoords, 'cellsize': grid_cell_size };
+}
+async function makeWGLBillboardBuffers(gl, grid, thin_fac, max_zoom) {
+    const { lats: field_lats, lons: field_lons } = grid.getCoords();
+    const bb_elements = await layer_worker.makeBBElements(field_lats, field_lons, grid.ni, grid.nj, thin_fac, max_zoom);
+    const vertices = new WGLBuffer(gl, bb_elements['pts'], 3, gl.TRIANGLE_STRIP);
+    const texcoords = new WGLBuffer(gl, bb_elements['tex_coords'], 2, gl.TRIANGLE_STRIP);
+    return { 'vertices': vertices, 'texcoords': texcoords };
+}
+class Grid {
+    constructor(type, is_conformal, ni, nj) {
+        this.type = type;
+        this.is_conformal = is_conformal;
+        this.ni = ni;
+        this.nj = nj;
+        this._buffer_cache = new Cache((gl) => {
+            const new_ni = Math.max(Math.floor(this.ni / 50), 20);
+            const new_nj = Math.max(Math.floor(this.nj / 50), 20);
+            return makeWGLDomainBuffers(gl, this.copy({ ni: new_ni, nj: new_nj }), this);
+        });
+        this._billboard_buffer_cache = new Cache((gl, thin_fac, max_zoom) => {
+            return makeWGLBillboardBuffers(gl, this, thin_fac, max_zoom);
+        });
+    }
+    async getWGLBuffers(gl) {
+        return await this._buffer_cache.getValue(gl);
+    }
+    async getWGLBillboardBuffers(gl, thin_fac, max_zoom) {
+        return await this._billboard_buffer_cache.getValue(gl, thin_fac, max_zoom);
+    }
+}
+/** A plate carree (a.k.a. lat/lon) grid with uniform grid spacing */
+class PlateCarreeGrid extends Grid {
+    /**
+     * Create a plate carree grid
+     * @param ni     - The number of grid points in the i (longitude) direction
+     * @param nj     - The number of grid points in the j (latitude) direction
+     * @param ll_lon - The longitude of the lower left corner of the grid
+     * @param ll_lat - The latitude of the lower left corner of the grid
+     * @param ur_lon - The longitude of the upper right corner of the grid
+     * @param ur_lat - The latitude of the upper right corner of the grid
+     */
+    constructor(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat) {
+        super('latlon', true, ni, nj);
+        this.ll_lon = ll_lon;
+        this.ll_lat = ll_lat;
+        this.ur_lon = ur_lon;
+        this.ur_lat = ur_lat;
+        this._ll_cache = new Cache(() => {
+            const dlon = (this.ur_lon - this.ll_lon) / (this.ni - 1);
+            const dlat = (this.ur_lat - this.ll_lat) / (this.nj - 1);
+            const lons = new Float32Array(this.ni * this.nj);
+            const lats = new Float32Array(this.ni * this.nj);
+            for (let i = 0; i < this.ni; i++) {
+                for (let j = 0; j < this.nj; j++) {
+                    const idx = i + j * this.ni;
+                    lons[idx] = this.ll_lon + i * dlon;
+                    lats[idx] = this.ll_lat + j * dlat;
+                }
+            }
+            return { 'lons': lons, 'lats': lats };
+        });
+    }
+    copy(opts) {
+        opts = opts !== undefined ? opts : {};
+        const ni = opts.ni !== undefined ? opts.ni : this.ni;
+        const nj = opts.nj !== undefined ? opts.nj : this.nj;
+        const ll_lon = opts.ll_lon !== undefined ? opts.ll_lon : this.ll_lon;
+        const ll_lat = opts.ll_lat !== undefined ? opts.ll_lat : this.ll_lat;
+        const ur_lon = opts.ur_lon !== undefined ? opts.ur_lon : this.ur_lon;
+        const ur_lat = opts.ur_lat !== undefined ? opts.ur_lat : this.ur_lat;
+        return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat);
+    }
+    /**
+     * Get a list of longitudes and latitudes on the grid (internal method)
+     */
+    getCoords() {
+        return this._ll_cache.getValue();
+    }
+    transform(x, y, opts) {
+        return [x, y];
+    }
+    getThinnedGrid(thin_x, thin_y) {
+        const dlon = (this.ur_lon - this.ll_lon) / this.ni;
+        const dlat = (this.ur_lat - this.ll_lat) / this.nj;
+        const ni = Math.ceil(this.ni / thin_x);
+        const nj = Math.ceil(this.nj / thin_y);
+        const ni_remove = (this.ni - 1) % thin_x;
+        const nj_remove = (this.nj - 1) % thin_y;
+        const ll_lon = this.ll_lon;
+        const ll_lat = this.ll_lat;
+        const ur_lon = this.ur_lon - ni_remove * dlon;
+        const ur_lat = this.ur_lat - nj_remove * dlat;
+        return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat);
+    }
+}
+/** A Lambert conformal conic grid with uniform grid spacing */
+class LambertGrid extends Grid {
+    /**
+     * Create a Lambert conformal conic grid
+     * @param ni      - The number of grid points in the i (longitude) direction
+     * @param nj      - The number of grid points in the j (latitude) direction
+     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection
+     * @param lat_0   - The center latitude for the projection
+     * @param lat_std - The standard latitudes for the projection
+     * @param ll_x    - The x coordinate in projection space of the lower-left corner of the grid
+     * @param ll_y    - The y coordinate in projection space of the lower-left corner of the grid
+     * @param ur_x    - The x coordinate in projection space of the upper-right corner of the grid
+     * @param ur_y    - The y coordinate in projection space of the upper-right corner of the grid
+     */
+    constructor(ni, nj, lon_0, lat_0, lat_std, ll_x, ll_y, ur_x, ur_y) {
+        super('lcc', true, ni, nj);
+        this.lon_0 = lon_0;
+        this.lat_0 = lat_0;
+        this.lat_std = lat_std;
+        this.ll_x = ll_x;
+        this.ll_y = ll_y;
+        this.ur_x = ur_x;
+        this.ur_y = ur_y;
+        this.lcc = lambertConformalConic({ lon_0: lon_0, lat_0: lat_0, lat_std: lat_std });
+        this._ll_cache = new Cache(() => {
+            const lons = new Float32Array(this.ni * this.nj);
+            const lats = new Float32Array(this.ni * this.nj);
+            for (let i = 0; i < this.ni; i++) {
+                const x = this.ll_x + (this.ur_x - this.ll_x) * i / (this.ni - 1);
+                for (let j = 0; j < this.nj; j++) {
+                    const y = this.ll_y + (this.ur_y - this.ll_y) * j / (this.nj - 1);
+                    const [lon, lat] = this.lcc(x, y, { inverse: true });
+                    const idx = i + j * this.ni;
+                    lons[idx] = lon;
+                    lats[idx] = lat;
+                }
+            }
+            return { lons: lons, lats: lats };
+        });
+    }
+    copy(opts) {
+        opts = opts !== undefined ? opts : {};
+        const ni = opts.ni !== undefined ? opts.ni : this.ni;
+        const nj = opts.nj !== undefined ? opts.nj : this.nj;
+        const ll_x = opts.ll_x !== undefined ? opts.ll_x : this.ll_x;
+        const ll_y = opts.ll_y !== undefined ? opts.ll_y : this.ll_y;
+        const ur_x = opts.ur_x !== undefined ? opts.ur_x : this.ur_x;
+        const ur_y = opts.ur_y !== undefined ? opts.ur_y : this.ur_y;
+        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y);
+    }
+    /**
+     * Get a list of longitudes and latitudes on the grid (internal method)
+     */
+    getCoords() {
+        return this._ll_cache.getValue();
+    }
+    transform(x, y, opts) {
+        opts = opts === undefined ? {} : opts;
+        const inverse = 'inverse' in opts ? opts.inverse : false;
+        return this.lcc(x, y, { inverse: inverse });
+    }
+    getThinnedGrid(thin_x, thin_y) {
+        const dx = (this.ur_x - this.ll_x) / this.ni;
+        const dy = (this.ur_y - this.ll_y) / this.nj;
+        const ni = Math.ceil(this.ni / thin_x);
+        const nj = Math.ceil(this.nj / thin_y);
+        const ni_remove = (this.ni - 1) % thin_x;
+        const nj_remove = (this.nj - 1) % thin_y;
+        const ll_x = this.ll_x;
+        const ll_y = this.ll_y;
+        const ur_x = this.ur_x - ni_remove * dx;
+        const ur_y = this.ur_y - nj_remove * dy;
+        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y);
+    }
+}
+/** A class representing a raw 2D field of gridded data, such as height or u wind. */
+class RawScalarField {
+    /**
+     * Create a data field.
+     * @param grid - The grid on which the data are defined
+     * @param data - The data, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid.
+     */
+    constructor(grid, data) {
+        this.grid = grid;
+        this.data = data;
+        if (grid.ni * grid.nj != data.length) {
+            throw `Data size (${data.length}) doesn't match the grid dimensions (${grid.ni} x ${grid.nj}; expected ${grid.ni * grid.nj} points)`;
+        }
+    }
+    getThinnedField(thin_x, thin_y) {
+        const new_grid = this.grid.getThinnedGrid(thin_x, thin_y);
+        const new_data = new Float32Array(new_grid.ni * new_grid.nj);
+        for (let i = 0; i < new_grid.ni; i++) {
+            for (let j = 0; j < new_grid.nj; j++) {
+                const idx_old = i * thin_x + this.grid.ni * j * thin_y;
+                const idx = i + new_grid.ni * j;
+                new_data[idx] = this.data[idx_old];
+            }
+        }
+        return new RawScalarField(new_grid, new_data);
+    }
+    /**
+     * Create a new field by aggregating a number of fields using a specific function
+     * @param func - A function that will be applied each element of the field. It should take the same number of arguments as fields you have and return a single number.
+     * @param args - The RawScalarFields to aggregate
+     * @returns a new gridded field
+     * @example
+     * // Compute wind speed from u and v
+     * wind_speed_field = RawScalarField.aggreateFields(Math.hypot, u_field, v_field);
+     */
+    static aggregateFields(func, ...args) {
+        function* mapGenerator(gen, func) {
+            for (const elem of gen) {
+                yield func(elem);
+            }
+        }
+        const zipped_args = zip(...args.map(a => a.data));
+        const agg_data = new Float32Array(mapGenerator(zipped_args, (a) => func(...a)));
+        return new RawScalarField(args[0].grid, agg_data);
+    }
+}
+/** A class representing a 2D gridded field of vectors */
+class RawVectorField {
+    /**
+     * Create a vector field.
+     * @param grid - The grid on which the vector components are defined
+     * @param u    - The u (east/west) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid
+     * @param v    - The v (north/south) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid
+     * @param opts - Options for creating the vector field.
+     */
+    constructor(grid, u, v, opts) {
+        opts = opts === undefined ? {} : opts;
+        this.u = new RawScalarField(grid, u);
+        this.v = new RawScalarField(grid, v);
+        this.relative_to = opts.relative_to === undefined ? 'grid' : opts.relative_to;
+        this._rotate_cache = new Cache(() => {
+            const grid = this.u.grid;
+            const coords = grid.getCoords();
+            const u_rot = new Float32Array(coords.lats.length);
+            const v_rot = new Float32Array(coords.lats.length);
+            for (let icd = 0; icd < coords.lats.length; icd++) {
+                const lon = coords.lons[icd];
+                const lat = coords.lats[icd];
+                const u = this.u.data[icd];
+                const v = this.v.data[icd];
+                const [x, y] = grid.transform(lon, lat);
+                const [x_pertlon, y_pertlon] = grid.transform(lon + 0.01, lat);
+                const mag_pertlon = Math.hypot(x - x_pertlon, y - y_pertlon);
+                const x_dotlon = (x_pertlon - x) / mag_pertlon;
+                const y_dotlon = (y_pertlon - y) / mag_pertlon;
+                let x_dotlat, y_dotlat;
+                if (grid.is_conformal) {
+                    // If the grid is conformal, v and u are rotated by the same amount in the same direction.
+                    x_dotlat = -y_dotlon;
+                    y_dotlat = x_dotlon;
+                }
+                else {
+                    // If the grid is non-conformal, we need a fully general change of basis from grid coordinates to earth coordinates.
+                    const [x_pertlat, y_pertlat] = grid.transform(lon, lat + 0.01);
+                    const mag_pertlat = Math.hypot(x - x_pertlat, y - y_pertlat);
+                    x_dotlat = (x_pertlat - x) / mag_pertlat;
+                    y_dotlat = (y_pertlat - y) / mag_pertlat;
+                }
+                u_rot[icd] = x_dotlon * u + y_dotlon * v;
+                v_rot[icd] = x_dotlat * u + y_dotlat * v;
+            }
+            return { u: new RawScalarField(grid, u_rot), v: new RawScalarField(grid, v_rot) };
+        });
+    }
+    getThinnedField(thin_x, thin_y) {
+        const thin_u = this.u.getThinnedField(thin_x, thin_y);
+        const thin_v = this.v.getThinnedField(thin_x, thin_y);
+        return new RawVectorField(thin_u.grid, thin_u.data, thin_v.data, { relative_to: this.relative_to });
+    }
+    get grid() {
+        return this.u.grid;
+    }
+    toEarthRelative() {
+        let u, v;
+        if (this.relative_to == 'earth') {
+            u = this.u;
+            v = this.v;
+        }
+        else {
+            const { u: u_, v: v_ } = this._rotate_cache.getValue();
+            u = u_;
+            v = v_;
+        }
+        return new RawVectorField(u.grid, u.data, v.data, { relative_to: 'earth' });
+    }
+}
+/** A class grid of wind profiles */
+class RawProfileField {
+    /**
+     * Create a grid of wind profiles
+     * @param grid     - The grid on which the profiles are defined
+     * @param profiles - The wind profiles themselves, which should be given as a 1D array in row-major order, with the first profile being at the lower-left corner of the grid
+     */
+    constructor(grid, profiles) {
+        this.profiles = profiles;
+        this.grid = grid;
+    }
+    /** Get the gridded storm motion vector field (internal method) */
+    getStormMotionGrid() {
+        const u = new Float32Array(this.grid.ni * this.grid.nj);
+        const v = new Float32Array(this.grid.ni * this.grid.nj);
+        this.profiles.forEach(prof => {
+            const idx = prof.ilon + this.grid.ni * prof.jlat;
+            u[idx] = prof.smu;
+            v[idx] = prof.smv;
+        });
+        return new RawVectorField(this.grid, u, v, { relative_to: 'grid' });
+    }
+}
+export { RawScalarField, RawVectorField, RawProfileField, PlateCarreeGrid, LambertGrid, Grid };

package/lib/index.d.ts

@@ -0,0 +1,22 @@
+import { PlotComponent } from "./PlotComponent";
+import Contour, { ContourOptions } from "./Contour";
+import ContourFill, { ContourFillOptions } from "./ContourFill";
+import Barbs, { BarbsOptions } from "./Barbs";
+import Paintball, { PaintballOptions } from "./Paintball";
+import Hodographs, { HodographOptions } from './Hodographs';
+import { PlotLayer, MultiPlotLayer } from './PlotLayer';
+import { WindProfile } from "./AutumnTypes";
+import { MapType } from "./Map";
+import { ColorMap, Color } from './Colormap';
+import { makeColorBar, makePaintballKey, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions } from "./ColorBar";
+import { RawScalarField, RawVectorField, RawProfileField, Grid, GridType, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, LambertGrid } from "./RawField";
+declare const colormaps: {
+    bluered: (level_min: number, level_max: number, n_colors: number) => ColorMap;
+    redblue: (level_min: number, level_max: number, n_colors: number) => ColorMap;
+    pw_speed500mb: ColorMap;
+    pw_speed850mb: ColorMap;
+    pw_cape: ColorMap;
+    pw_t2m: ColorMap;
+    pw_td2m: ColorMap;
+};
+export { PlotComponent, Barbs, BarbsOptions, Contour, ContourOptions, ContourFill, ContourFillOptions, Paintball, PaintballOptions, Hodographs, HodographOptions, WindProfile, PlotLayer, MultiPlotLayer, MapType, ColorMap, colormaps, makeColorBar, makePaintballKey, Color, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions, RawScalarField, RawVectorField, RawProfileField, Grid, GridType, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, LambertGrid };

package/lib/index.js

@@ -0,0 +1,20 @@
+import { PlotComponent } from "./PlotComponent";
+import Contour from "./Contour";
+import ContourFill from "./ContourFill";
+import Barbs from "./Barbs";
+import Paintball from "./Paintball";
+import Hodographs from './Hodographs';
+import { PlotLayer, MultiPlotLayer } from './PlotLayer';
+import { ColorMap, bluered, redblue, pw_speed500mb, pw_speed850mb, pw_cape, pw_t2m, pw_td2m } from './Colormap';
+import { makeColorBar, makePaintballKey } from "./ColorBar";
+import { RawScalarField, RawVectorField, RawProfileField, Grid, PlateCarreeGrid, LambertGrid } from "./RawField";
+const colormaps = {
+    bluered: bluered,
+    redblue: redblue,
+    pw_speed500mb: pw_speed500mb,
+    pw_speed850mb: pw_speed850mb,
+    pw_cape: pw_cape,
+    pw_t2m: pw_t2m,
+    pw_td2m: pw_td2m
+};
+export { PlotComponent, Barbs, Contour, ContourFill, Paintball, Hodographs, PlotLayer, MultiPlotLayer, ColorMap, colormaps, makeColorBar, makePaintballKey, RawScalarField, RawVectorField, RawProfileField, Grid, PlateCarreeGrid, LambertGrid };

package/lib/utils.d.ts

@@ -0,0 +1,9 @@
+declare const hex2rgba: (hexstr: string, out_type?: string) => [number, number, number, number];
+declare const rgba2hex: (rgba: [number, number, number, number], in_type?: string) => string;
+declare const hex2rgb: (hexstr: string, out_type?: string) => [number, number, number];
+declare const rgb2hex: (rgb: [number, number, number], in_type?: string) => string;
+declare const rgb2hsv: (rgb: [number, number, number]) => [number, number, number];
+declare const hsv2rgb: (hsv: [number, number, number]) => [number, number, number];
+declare function getMinZoom(jlat: number, ilon: number, thin_fac_base: number): number;
+declare function zip(...args: any[]): Generator<any[], void, unknown>;
+export { hex2rgba, rgba2hex, hex2rgb, rgb2hex, rgb2hsv, hsv2rgb, zip, getMinZoom };

package/lib/utils.js

@@ -0,0 +1,103 @@
+const hex2rgba = (hexstr, out_type) => {
+    out_type = out_type === undefined ? 'float' : out_type;
+    const match = hexstr.match(/#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?/i);
+    if (match === null) {
+        throw `Got '${hexstr}' in hex2rgba, which does not look like a hex color`;
+    }
+    let rgba = match.slice(1).filter(c => c !== undefined).map(c => parseInt(c, 16));
+    if (out_type == 'float') {
+        rgba = rgba.map(c => c / 255);
+    }
+    return rgba[3] === undefined ? [rgba[0], rgba[1], rgba[2], 1] : [rgba[0], rgba[1], rgba[2], rgba[3]];
+};
+const rgba2hex = (rgba, in_type) => {
+    in_type = in_type === undefined ? 'float' : in_type;
+    let rgba_ = rgba;
+    if (in_type == 'float') {
+        rgba_ = rgba_.map(c => Math.round(c * 255));
+    }
+    return '#' + rgba_.map(c => c.toString(16).padStart(2, '0').toUpperCase()).join('');
+};
+const hex2rgb = (hexstr, out_type) => {
+    const [r, g, b, a] = hex2rgba(hexstr, out_type);
+    return [r, g, b];
+};
+const rgb2hex = (rgb, in_type) => {
+    const [r, g, b] = rgb;
+    return rgba2hex([r, g, b, 0], in_type).slice(0, -2);
+};
+const rgb2hsv = (rgb) => {
+    const [r, g, b] = rgb;
+    const Cmax = Math.max(r, g, b);
+    const Cmin = Math.min(r, g, b);
+    const Delta = Cmax - Cmin;
+    let H;
+    if (Delta == 0) {
+        H = 0;
+    }
+    else if (Cmax == r) {
+        H = 60 * ((g - b) / Delta) % 6;
+    }
+    else if (Cmax == g) {
+        H = 60 * ((b - r) / Delta + 2);
+    }
+    else if (Cmax == b) {
+        H = 60 * ((r - g) / Delta + 4);
+    }
+    let S = Cmax == 0 ? 0 : Delta / Cmax;
+    let V = Cmax;
+    return [H, S, V];
+};
+const hsv2rgb = (hsv) => {
+    const [H, S, V] = hsv;
+    const C = V * S;
+    const X = C * (1 - Math.abs(H / 60 % 2 - 1));
+    const m = V - C;
+    let r_prime, g_prime, b_prime;
+    if (0 <= H && H < 60) {
+        r_prime = C;
+        g_prime = X, b_prime = 0;
+    }
+    else if (60 <= H && H < 120) {
+        r_prime = X;
+        g_prime = C, b_prime = 0;
+    }
+    else if (120 <= H && H < 180) {
+        r_prime = 0;
+        g_prime = C, b_prime = X;
+    }
+    else if (180 <= H && H < 240) {
+        r_prime = 0;
+        g_prime = X, b_prime = C;
+    }
+    else if (240 <= H && H < 300) {
+        r_prime = X;
+        g_prime = 0, b_prime = C;
+    }
+    else if (300 <= H && H < 360) {
+        r_prime = C;
+        g_prime = 0, b_prime = X;
+    }
+    return [r_prime + m, g_prime + m, b_prime + m];
+};
+function getMinZoom(jlat, ilon, thin_fac_base) {
+    const zoom_base = 1;
+    let zoom = zoom_base;
+    let thin_fac = thin_fac_base;
+    while (((jlat % thin_fac) != 0) || ((ilon % thin_fac) != 0)) {
+        zoom += 1;
+        thin_fac /= 2;
+    }
+    return zoom;
+}
+function* zip(...args) {
+    const iterators = args.map(x => x[Symbol.iterator]());
+    while (true) {
+        const current = iterators.map(x => x.next());
+        if (current.some(x => x.done)) {
+            break;
+        }
+        yield current.map(x => x.value);
+    }
+}
+export { hex2rgba, rgba2hex, hex2rgb, rgb2hex, rgb2hsv, hsv2rgb, zip, getMinZoom };

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "autumnplot-gl",
+    "version": "2.0.0-beta.1",
+    "description": "",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "files": [
+        "lib/**/*"
+    ],
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "docs": "npx typedoc --options typedoc.json",
+        "start": "webpack serve --open --mode=development",
+        "build-dist": "webpack --mode=production",
+        "build-npm": "./scripts/build_npm.sh"
+    },
+    "keywords": [],
+    "author": "Tim Supinie",
+    "license": "GPL-3.0-only",
+    "devDependencies": {
+        "@types/luxon": "^3.2.0",
+        "@types/mapbox-gl": "^2.7.10",
+        "@types/maplibre-gl": "^1.14.0",
+        "ts-loader": "^9.4.2",
+        "typedoc": "^0.23.24",
+        "typedoc-plugin-markdown": "^3.14.0",
+        "typescript": "^4.9.4",
+        "webpack": "^5.75.0",
+        "webpack-cli": "^5.0.1",
+        "webpack-dev-server": "^4.11.1",
+        "webpack-glsl-loader": "^1.0.1"
+    },
+    "dependencies": {
+        "autumn-wgl": "^1.1.0",
+        "comlink": "^4.3.1"
+    }
+}