@windycom/plugin-devtools 1.0.2-beta.2 → 1.0.5

package/types/client/d.ts.files/LabelsLayer.d.ts

@@ -0,0 +1,51 @@
+import { Timestamp } from '@windy/types.d';
+
+type CityDivId = string; // `${x}:${y}`
+type CityLabelId = string; // `${lat}/${lon}`
+
+/** Loaded forecast data from `/citytile/*` URL endpoint */
+export type CityForecastData = {
+    /**
+     * Forecasted temperatures for cities on the tile
+     */
+    forecast: {
+        /**
+         * Keys (coordinates) are in "lat/lon" format, value the forecasted temperature
+         */
+        [coordinates: string]: number[];
+    };
+    /** Reftime */
+    reftime: Timestamp;
+    /** Time from reftime in hours for every temperature value in the returned array */
+    hours: number[];
+};
+
+/**
+ * Loaded labels data from tiles.windy.com endpoint
+ * Format of inner arrays is [id, title to show, category of label used for CSS class, lon, lat, width in px, height in px]
+ */
+export type CityLabelData = [string, string, string, number, number, number, number][];
+
+/** Represantation of single one HTML label with its temperature data */
+export interface CityLabel {
+    /** Id of the label, it is same as a key for CityForecastData, so it is used for pairing label with temperature data */
+    id: CityLabelId;
+
+    /** HTML element of the label for binding labels and temperature values */
+    el: HTMLDivElement;
+
+    /** Forecast data with temperature in K, it is lazy loaded with forecast request */
+    data?: number[];
+}
+
+/** Representation of one leaflet tile with its CityLabels */
+export interface CityDiv {
+    /** Labels included in the leaflet tile */
+    labels: CityLabel[];
+
+    /** Mercator URL frag in format <z>/<x>/<y>. It is lazy binded when tile is created */
+    urlFrag?: string;
+
+    /* Array of timestamps for which the temperatures are forecasted. Lazy loaded with forecast request */
+    timestamps?: Timestamp[];
+}

package/types/client/d.ts.files/LandMask.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Leaflet layer with alpha-inverse sea mask
+ */
+export class LandMask extends L.TileLayer {
+    seaColorL: number;
+    ctx: CanvasRenderingContext2D | null;
+    _tileOnError(
+        done: L.DoneCallback,
+        tile: HTMLImageElement | HTMLCanvasElement,
+        e: string | Event,
+    ): void;
+    getTempCtx(): CanvasRenderingContext2D | null;
+    getTileUrl(coords: L.Coords): string;
+    createTile(coords: L.Coords, done: L.DoneCallback): HTMLCanvasElement | HTMLImageElement;
+    createImageTile(coords: L.Coords, done: L.DoneCallback): HTMLImageElement;
+    createCanvasTile(coords: L.Coords, done: L.DoneCallback): HTMLCanvasElement;
+}

package/types/client/d.ts.files/Layer.d.ts

@@ -0,0 +1,184 @@
+import { NumberedMetric, PrecipMetric, PtypeMetric, UVIndexMetric } from '@windy/MetricClasses';
+import { DataQuality, FileSuffix } from '@windy/Product.d';
+import { WeatherParameters } from '@windy/interfaces.d';
+import { Levels, Overlays } from '@windy/rootScope.d';
+import { NumValue, Path } from '@windy/types.d';
+
+// TODO: Move to particles.d.ts later
+export type ParticlesIdent = 'wind' | 'waves' | 'currents';
+
+// TODO: Move to Patternator.d.ts later on
+export type Patterntype = 'cclPattern' | 'rainPattern' | 'ptypePattern';
+
+export type TransformFunction = (x: NumValue) => NumValue;
+
+export type RenderChannels = 'R' | 'RG' | 'B';
+
+/**
+ * All available layers and their metric value type
+ */
+export interface LayerMetricType {
+    capAlerts: undefined;
+    pressureIsolines: undefined;
+    ghIsolines: undefined;
+    tempIsolines: undefined;
+    deg0Isolines: undefined;
+    windParticles: undefined;
+    ecmwfWindParticles: undefined;
+    ecmwfWindParticles150h: undefined;
+    ecmwfWindParticles500h: undefined;
+    ecmwfWindParticles600h: undefined;
+    waveParticles: undefined;
+    currentParticles: undefined;
+    currentsTideParticles: undefined;
+    wind: NumberedMetric;
+    temp: NumberedMetric;
+    wetbulbtemp: NumberedMetric;
+    solarpower: NumberedMetric;
+    uvindex: UVIndexMetric;
+    dewpoint: NumberedMetric;
+    gust: NumberedMetric;
+    gustAccu: NumberedMetric;
+    rh: NumberedMetric;
+    pressure: NumberedMetric;
+    ccl: NumberedMetric;
+    rain: PrecipMetric;
+    ptype: PtypeMetric;
+    thunder: NumberedMetric;
+    clouds: NumberedMetric;
+    lclouds: NumberedMetric;
+    mclouds: NumberedMetric;
+    hclouds: NumberedMetric;
+    cape: NumberedMetric;
+    cbase: NumberedMetric;
+    fog: NumberedMetric;
+    snowAccu: NumberedMetric;
+    rainAccu: NumberedMetric;
+    waves: NumberedMetric;
+    wwaves: NumberedMetric;
+    swell1: NumberedMetric;
+    swell2: NumberedMetric;
+    swell3: NumberedMetric;
+    swell: NumberedMetric;
+    currents: NumberedMetric;
+    currentsTide: NumberedMetric;
+    sst: NumberedMetric;
+    visibility: NumberedMetric;
+    snowcover: NumberedMetric;
+    cloudtop: NumberedMetric;
+    deg0: NumberedMetric;
+    cosc: NumberedMetric;
+    dustsm: NumberedMetric;
+    radar: NumberedMetric;
+    satellite: NumberedMetric;
+    gtco3: NumberedMetric;
+    pm2p5: NumberedMetric;
+    no2: NumberedMetric;
+    aod550: NumberedMetric;
+    tcso2: NumberedMetric;
+    go3: NumberedMetric;
+    gh: NumberedMetric;
+    efiWind: NumberedMetric;
+    efiTemp: NumberedMetric;
+    efiRain: NumberedMetric;
+    moistureAnom40: PrecipMetric;
+    moistureAnom100: PrecipMetric;
+    drought40: NumberedMetric;
+    drought100: NumberedMetric;
+    soilMoisture40: NumberedMetric;
+    soilMoisture100: NumberedMetric;
+    fwi: NumberedMetric;
+    dfm10h: NumberedMetric;
+    turbulence: NumberedMetric;
+    icing: NumberedMetric;
+}
+
+/**
+ * All layers available
+ */
+export type Layers = keyof LayerMetricType;
+
+/**
+ * These properties are passed directly to renderer by enhancing returned params
+ */
+interface RenderParams {
+    /**
+     * Which channels contain tile rendering data
+     */
+    renderFrom?: RenderChannels;
+
+    /**
+     * Not confirmed: Display map as a sea, meaning the sea layers are below surface layers
+     */
+    sea?: boolean;
+
+    /**
+     * Display map as a land, meaning the sea area is hidden with mask
+     */
+    landOnly?: boolean;
+
+    /**
+     * Identifier of particle type
+     */
+    particlesIdent?: ParticlesIdent;
+
+    /**
+     * Have no clue what this is
+     */
+    isMultiColor?: boolean;
+
+    /**
+     * Have no clue what this is
+     */
+    interpolateNearestG?: boolean;
+
+    /**
+     * Name of interpolator method
+     */
+    interpolate?: 'interpolateOverlay' | 'interpolateWaves';
+
+    /**
+     * Used patternator
+     */
+    pattern?: Patterntype;
+}
+
+/**
+ * Set of params required to render the layer
+ */
+interface FullRenderParameters extends WeatherParameters, RenderParams {
+    layer: Layers;
+    server: string;
+    JPGtransparency?: boolean;
+    PNGtransparency?: boolean;
+    transformR?: TransformFunction;
+    transformG?: TransformFunction;
+    transformB?: TransformFunction;
+    directory: string;
+    filename: string | Overlays | Layers;
+    fileSuffix: FileSuffix;
+
+    /**
+     * Specifi zoom of mercator data tiles in dependence of map zoom
+     */
+    dataQuality?: DataQuality;
+    maxTileZoom?: {
+        free: number;
+        premium: number;
+    };
+
+    /**
+     * bump data quality by 1 level for particular overlay/layer
+     */
+    upgradeDataQuality?: boolean;
+
+    /**
+     * Force to slect particular zoom of data tiles
+     */
+    dataTilesZoom?: number;
+
+    level: Levels;
+    refTime: string;
+    fullPath: string;
+    path: Path;
+}

package/types/client/d.ts.files/Metric.d.ts

@@ -0,0 +1,192 @@
+import {
+    FogMetric,
+    NumberedMetric,
+    PrecipMetric,
+    PtypeMetric,
+    SatelliteMetric,
+    UVIndexMetric,
+} from '@windy/MetricClasses';
+import { NumValue } from '@windy/types.d';
+
+/*
+ * List of all supported metric identifiers
+ */
+export type MetricItem =
+    | 'K'
+    | '°C'
+    | '°F'
+    | 'kt'
+    | 'bft'
+    | 'm/s'
+    | 'mph'
+    | 'km/h'
+    | '%'
+    | 'rules'
+    | 'hPa'
+    | 'inHg'
+    | 'mmHg'
+    | 'mm'
+    | 'in'
+    | 'cm'
+    | 'in'
+    | 'J/kg'
+    | 'DU'
+    | 'AOD'
+    | 'µg/m³'
+    | 'mg/m²'
+    | 'm'
+    | 'ft'
+    | 'km'
+    | 'mi'
+    | 'NM'
+    | 'sm'
+    | 'ppbv'
+    | 'dBZ'
+    | 'ptype'
+    | 'type'
+    | 'l/km²'
+    | 'W/m²'
+    | 'drought'
+    | 'fwi'
+    | 'mm/h'
+    | 'in/h'
+    | 'uvindex'
+    | 'EDR'
+    | 'km²'
+    | 'acres';
+
+/**
+ * # @windy/metrics
+ *
+ * Contains already initialized instances of {@link Metric.Metric | Metric } classes, to recalculate
+ * raw weather data, into units, that has user selected as his favorite, units
+ *
+ * @example
+ * ```typescript
+ * import metrics from '@windy/metrics';
+ *
+ * metrics.temp.convertNumber(234.9);
+ * // converts 234.9 from Kelvin to Celsius or Fahrenheit
+ * // based on users settings
+ *
+ * metrics.temp.convertValue(234.9);
+ * // outputs string either -24.2°C or -11.5°F
+ * ```
+ * Complete list of Windy's supported metrics
+ */
+export interface MetricTypes {
+    temp: NumberedMetric;
+    wind: NumberedMetric;
+    rh: NumberedMetric;
+    clouds: NumberedMetric;
+    pressure: NumberedMetric;
+    rain: PrecipMetric;
+    snow: NumberedMetric;
+    cape: NumberedMetric;
+    gtco3: NumberedMetric;
+    aod550: NumberedMetric;
+    pm2p5: NumberedMetric;
+    no2: NumberedMetric;
+    tcso2: NumberedMetric;
+    go3: NumberedMetric;
+    altitude: NumberedMetric;
+    elevation: NumberedMetric;
+    distance: NumberedMetric;
+    speed: NumberedMetric;
+    waves: NumberedMetric;
+    currents: NumberedMetric;
+    visibility: NumberedMetric;
+    visibilityNoRules: NumberedMetric;
+    so2: NumberedMetric;
+    dust: NumberedMetric;
+    cosc: NumberedMetric;
+    radar: NumberedMetric;
+    satellite: SatelliteMetric;
+    ptype: PtypeMetric;
+    gh: NumberedMetric;
+    fog: FogMetric;
+    lightDensity: NumberedMetric;
+    efiWind: NumberedMetric;
+    efiTemp: NumberedMetric;
+    efiRain: NumberedMetric;
+    drought: NumberedMetric;
+    moistureAnom40: PrecipMetric;
+    moistureAnom100: PrecipMetric;
+    fwi: NumberedMetric;
+    dfm10h: NumberedMetric;
+    solarpower: NumberedMetric;
+    uvindex: UVIndexMetric;
+    capAlerts: NumberedMetric;
+    turbulence: NumberedMetric;
+    icing: NumberedMetric;
+    area: NumberedMetric;
+}
+
+/** @ignore */
+export type MetricIdent = keyof MetricTypes;
+
+/** @ignore */
+export type NumberedMetricIdent = keyof Pick<
+    MetricTypes,
+    {
+        [M in keyof MetricTypes]: MetricTypes[M] extends NumberedMetric ? M : never;
+    }[keyof MetricTypes]
+>;
+
+/** @ignore */
+export type MetricKey = `metric_${MetricIdent}`;
+
+type LegendItem = number | string;
+
+type LegendDescription = MetricItem[]; // It is possible that some legends have custom desc
+
+/**
+ * Lines defining the legend. First column MUST be number, but we keep te type as easy as possible
+ *
+ * 1st column: value,
+ * 2nd column: text for first metric (°C for example)
+ * 3rd column: text for second metric (°F for example)
+ * 4th column: and so on
+ */
+type LegendLines = [number, LegendItem, ...LegendItem[]][];
+
+/** @ignore */
+export interface Legend {
+    /**
+     * Legend description
+     */
+    description: LegendDescription;
+
+    /**
+     * Array defining how the legend will look like
+     */
+    lines: LegendLines;
+}
+
+export interface Conversion {
+    /**
+     * Conversion function
+     */
+    conversion: (x: NumValue) => NumValue;
+
+    /**
+     * Decimal precision
+     */
+    precision: number;
+
+    /**
+     * How should we mark Not Available in packer
+     */
+    na?: string;
+
+    /**
+     * Optional label
+     */
+    label?: string;
+}
+
+/** @ignore */
+export type ConvObj = { [K in MetricItem]?: Conversion };
+
+/** @ignore */
+export type MetricInitParams = Pick<NumberedMetric, 'ident'> & Partial<NumberedMetric>;

package/types/client/d.ts.files/PoisOverlay.d.ts

@@ -0,0 +1,27 @@
+export class PoisOverlay extends L.Layer {
+    className?: string;
+    displayed?: boolean;
+    _container?: HTMLElement;
+    _markers?: Record<string, L.LatLng>;
+    constructor(className?: string);
+    initialize(this: this, className: string): void;
+    getHtml(
+        this: this,
+        id: string,
+        point: L.LatLng,
+        params: { html?: string; style?: string; attrs?: string[] },
+    ): string;
+    addPois(this: this, html: string, markers: Record<string, L.LatLng>): void;
+    getPane(this: this): HTMLElement | undefined;
+    removePois(this: this): void;
+    replaceMarker(this: this, id: string, html: string): void;
+    getAllMarkers(this: this): NodeListOf<HTMLElement>;
+    _reset(this: this): void;
+    forAllMarkers(this: this, fun: (point: L.LatLng) => L.Point): void;
+    getPosReset(this: this, point: L.LatLng): L.Point;
+    setPoistion(this: this, marker: HTMLElement, pos: L.Point): void;
+
+    // Just this typings rewrites of leaflet methods
+    onAdd(this: this, map: L.Map): this;
+    onRemove(this: this, map: L.Map): this;
+}

package/types/client/d.ts.files/Product.d.ts

@@ -0,0 +1,37 @@
+import { Overlays, Levels } from '@windy/rootScope.d';
+import { Bounds } from '@windy/interfaces.d';
+
+export type ProductKey = `lastMinifest/${string}`; // TODO - directory instead of string
+
+export interface ProductParam {
+    color: [number, number[]][];
+    description_en: string;
+    name_en: string;
+    encoding: {
+        func: string; // TODO: set exact function names
+        zero: number;
+    };
+    level: Levels[];
+    units: string;
+}
+
+export interface ProductInfoJson {
+    about: {
+        name: string;
+        copyright: string;
+        description: string;
+        modelResolution: number;
+        provider: string;
+        url: string;
+    };
+    bounds: null | Bounds;
+    interval: number;
+    maxZoom: number;
+    param: Record<Overlays, ProductParam>;
+    version: string;
+    zoom2zoom: string; // TODO: set exact string
+}
+
+export type DataQuality = 'normal' | 'high' | 'low' | 'ultra' | 'extreme';
+
+export type FileSuffix = 'png' | 'jpg' | 'webp';

package/types/client/d.ts.files/Renderer.d.ts

@@ -0,0 +1,23 @@
+import { TransformFunction } from '@windy/Layer.d';
+import { TilePoint } from '@windy/interfaces.d';
+
+export type Renderers =
+    | 'tileLayer'
+    | 'radar'
+    | 'satellite'
+    | 'capAlerts'
+    | 'isolines'
+    | 'particles'
+    | 'accumulations'
+    | 'daySwitcher'
+    | 'noUserControl';
+
+export interface TileParams extends TilePoint {
+    url: string;
+    intX: number;
+    intY: number;
+    trans: number;
+    transformR: TransformFunction | null;
+    transformG: TransformFunction | null;
+    transformB: TransformFunction | null;
+}

package/types/client/d.ts.files/TileLayerCanvas.d.ts

@@ -0,0 +1,78 @@
+import { DataTile } from '@windy/dataLoader';
+
+import { FullRenderParameters } from '@windy/Layer.d';
+import { TileParams } from '@windy/Renderer.d';
+
+export type InternalTile = L.InternalTiles[string] & { el: HTMLCanvasElement };
+
+export class TileLayerCanvas extends L.GridLayer {
+    _tiles: Record<string, InternalTile>;
+    /**
+     * Latest params
+     */
+    latestParams: FullRenderParameters;
+
+    /**
+     * Incrementing counter, that keeps latestParams and actually rendered ile in sync
+     */
+    syncCounter: number;
+
+    /**
+     * While map is being moved
+     */
+    inMotion: boolean;
+
+    /**
+     * Wis sea applied to CSS tag?
+     */
+    hasSea: boolean;
+
+    landOnly: boolean;
+
+    className: string;
+
+    _tilesToLoad: number;
+
+    /**
+     * Owerwriting TileLayer method to disable redrawing layers w/o params
+     */
+    // @ts-expect-error We rape TS with overloading properties with properties of different input and output (TODO fix)
+    onAdd(this: this, map: L.Map): this;
+    onRemove(this: this, map: L.Map): this;
+    onMoveStart(this: this): void;
+    onMoveEnd(this: this): void;
+    checkLoaded(this: this): void;
+    redrawFinished(this: this): void;
+    /**
+     * Redrawing overlay after changing params
+     *
+     * 1. find visible tiles
+     * 2. remove invisible tiles
+     * 3. redraw visible tiles
+     */
+    redrawLayer(this: this): void;
+
+    removeOtherTiles(this: this, zoom: number, tileBounds: L.Bounds): void;
+
+    _removeTile(this: this, key: string): void;
+
+    /**
+     * Sort tiles from center out
+     */
+    sortTilesFromCenterOut(this: this, bounds: L.Bounds): L.Coords[];
+
+    redrawTile(this: this, tile: InternalTile): void;
+
+    paramsChanged(this: this, params: FullRenderParameters): void;
+
+    init(this: this, params: FullRenderParameters): void;
+
+    renderTile(
+        this: this,
+        step: 1 | 2,
+        canvas: HTMLCanvasElement,
+        rqrdSyncNum: number,
+        tInfo: TileParams,
+        dTile: DataTile,
+    ): void;
+}

package/types/client/d.ts.files/TileLayerMultiPatch.d.ts

@@ -0,0 +1,13 @@
+export class TileLayerMultiPatch extends L.TileLayerMulti {
+    _tileDefs?: Record<number, L.TileDef | null>;
+    _tileDefsBase?: Record<number, L.TileDef | null>;
+    _tileDefsPatch?: Record<number, L.TileDef | null>;
+    _patch?: Record<number, number[]>;
+    initialize(
+        this: this,
+        tileDefs?: Record<number, L.TileDef>,
+        options?: L.TileLayerOptions,
+    ): void;
+    getTileUrl(this: this, tilePoint: L.Point): string;
+    _convertPatchToZoom(this: this, patch: L.TileDefPatch, zoom: number): number[];
+}