@windycom/plugin-devtools 3.0.1 → 3.0.3

package/types/client/SwitchableTileCache.d.ts

@@ -0,0 +1,104 @@
+import { Bounds, LeafletGlMap, TileCache, type Coords } from '@leafletGl';
+type OnCacheDestroy = () => void;
+export type Cache<TTile> = {
+    cache: TileCache<TTile>;
+    /**
+     * Completely cleans up the cache: disposes of the internal TileCache, un-registers event listeners, cleans up tile preprocessor.
+     */
+    destroy: OnCacheDestroy;
+};
+/**
+ * This class serves as a tile cache with the added functionality of
+ * being able to swap the internal set of tiles (internal tile cache)
+ * for a new set of tiles, but only once the new tiles are fully loaded.
+ *
+ * This is useful for when you want to eg. swap current forecast refTime or model and only display the new data once it is fully ready.
+ *
+ * Additionally, this class supports {@link awaitTile} function, which asynchronously waits for a given tile to be loaded.
+ * This does not trigger a new tile load, but waits for the tile to become required by the current map view.
+ */
+export declare class SwitchableTileCache<TTile> {
+    private _nextCache;
+    private _currentCache;
+    private _keepBuffer;
+    private _maxLowerZoom;
+    private _maxHigherZoom;
+    private _lastMapBounds;
+    private _lastMapZoom;
+    onSwitch?: () => void;
+    get currentCache(): Cache<TTile>;
+    get keepBuffer(): number;
+    /**
+     * Gets the map bounds, as computed at the last {@link update} call,
+     * with {@link keepBuffer} taken into account.
+     */
+    get lastBounds(): Bounds;
+    /**
+     * Gets the map integer zoom, as computed at the last {@link update} call.
+     */
+    get lastZoom(): number;
+    /**
+     * Creates a new instance of {@link SwitchableTileCache}.
+     * @param initialCache - The initial tile cache to be used.
+     * @param keepBuffer - How many extra tiles in each of the four directions should be loaded in addition to the set that optimally covers the current map view.
+     * @param maxLowerZoom - If a tile at the specified zoom level is unavailable, its parent or children may be rendered instead.
+     * This value is the maximal allowed difference in zoom levels when rendering a **less** detailed tile instead of the ideal one.
+     * @param maxHigherZoom - If a tile at the specified zoom level is unavailable, its parent or children may be rendered instead.
+     * This value is the maximal allowed difference in zoom levels when rendering a **more** detailed tile instead of the ideal one.
+     */
+    constructor(initialCache: Cache<TTile>, keepBuffer?: number, maxLowerZoom?: number, maxHigherZoom?: number);
+    /**
+     * Initializes a switch to the supplied tile cache.
+     * The current cache is switched for the supplied one once the supplied cache is done loading.
+     * Loading of new tiles for the current cache is suspended in the meantime.
+     * If a switch to another new cache was already taking place, then that new cache gets deleted.
+     *
+     * When you pass a cache to this function, you must not use that object directly anymore,
+     * as it will now be managed and later disposed of by this class.
+     *
+     * You may not pass the same instance of a tle cache to this function multiple times.
+     */
+    setCache(cache: Cache<TTile>): void;
+    /**
+     * Updates the caches with the map's current view and zoom.
+     * Call every time the map moves.
+     */
+    update(map: LeafletGlMap): void;
+    /**
+     * Returns an ordered array of tile coords that should be rendered to optimally cover the current map view.
+     * May return tiles of different zoom level than what is optimal, depending on
+     * what tiles are currently available and on the cache settings.
+     * Is not affected by `keepBuffer`.
+     */
+    getRenderableCoords(): Coords[];
+    /**
+     * Returns the data in the current cache associated with the given tile.
+     * May return `null` both when the tile load failed and when the tile is not present at all.
+     * Distinguish between these two cases using {@link hasTile}.
+     */
+    getTile(coords: Coords): TTile | null;
+    /**
+     * Returns whether the current cache has loaded the given tile.
+     */
+    hasTile(coords: Coords): boolean;
+    /**
+     * Asynchronously returns a tile once it is loaded.
+     * However the loading of this tile can only be triggered by the user moving the map
+     * and the tile becoming visible in the map view.
+     * Always returns tiles from the latest cache available at the time of calling this function:
+     * returns tiles from the next cache, if any is present, otherwise returns tiles from the current cache.
+     *
+     * You can optionally supply an abort signal. Signalling it will cancel the tile request
+     * and remove it from the internal queues.
+     */
+    awaitTile(coords: Coords, abort?: AbortSignal): Promise<any>;
+    /**
+     * Deletes all resources associated with this {@link SwitchableTileCache}, including its internal caches.
+     */
+    dispose(): void;
+    /**
+     * Updates one of the internal tile caches with up-to-date map bounds and zoom.
+     */
+    private _updateInternal;
+}
+export {};

package/types/client/TileLayer.d.ts

@@ -1,8 +1,17 @@
 import { Renderer } from '@windy/Renderer';
-import type { FullRenderParameters } from '@windy/Layer.d';
-import type { RendererInitParams, Renderers } from '@windy/Renderer.d';
+import type { FullRenderParameters, WeatherParameters } from '@windy/interfaces';
+import type { RendererInitParams, Renderers } from '@windy/Renderer';
+import type { Layers } from '@windy/Layer';
+import type { Timestamp } from '@windy/types';
 export declare class TileLayer extends Renderer {
+    private readonly _layerId;
+    private _lastUsedMapParams;
+    private _initializeCallbackSet;
     constructor(params: RendererInitParams);
-    onopen(params?: FullRenderParameters): void;
+    onopen(params: FullRenderParameters): void;
     close(rqrdRenderers: Renderers[]): void;
+    redraw(): void;
+    paramsChanged(layerIdent: Layers, weatherParams: WeatherParameters, timestamp: Timestamp): Promise<void>;
+    private _ensureMapAndSetParams;
+    private _initialize;
 }

package/types/client/TileLayerCustom.d.ts

@@ -0,0 +1,51 @@
+import { MapLibreMap } from '@leafletGl';
+import { EventManager } from '@windy/EventManager';
+import type { CustomLayerInterface, CustomRenderMethodInput } from '@leafletGl';
+import type { FullRenderParameters } from '@windy/interfaces';
+/**
+ * This is the "main" layer class for rendering forecast layers.
+ * It implement's MapLibre's custom layer interface (`onAdd`, `onRemove` and `render`)
+ * and several helper methods for handling render params change and layer enable/disable.
+ */
+export declare class TileLayerCustom implements CustomLayerInterface {
+    private _renderer;
+    private _enabled;
+    private _hasSea;
+    private _landOnly;
+    private _latestParams;
+    private _switchableCache;
+    private _paramsChangeId;
+    readonly eventManager: EventManager;
+    readonly type: "custom";
+    id: string;
+    constructor(layerId: string, params: FullRenderParameters);
+    get switchableCache(): any;
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, _options: CustomRenderMethodInput): void;
+    onAdd(_maplibreMap: MapLibreMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Hides/shows the layer
+     *   - useful for example in case when we cycle between various TileLayer renderers
+     *   - for the old one (e.g. accumulation) we need to hide the layer and for the new one (e.g. tileLayer) we need to show it
+     */
+    enableDisableLayer(enable: boolean): void;
+    paramsChanged(newParams: FullRenderParameters, layerReopen?: boolean): void;
+    onRemove(_maplibreMap: MapLibreMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    private _init;
+    private _onUpdate;
+    /**
+     * Sets land or sea mask visibility.
+     * Called when {@link _switchableCache} switches to a new set of tiles
+     * or when {@link _switchableCache} is first created.
+     */
+    private _updateLandSeaMask;
+    /**
+     * Creates a tile cache from the current {@link _latestParams}
+     * and passes this cache to {@link _switchableCache}.
+     *
+     * If no instance of {@link _switchableCache} exists, it is created.
+     * and {@link _updateLandSeaMask} is called.
+     *
+     * Call when {@link _latestParams} changes.
+     */
+    private _updateCache;
+}

package/types/client/TileLayerMulti.d.ts

@@ -0,0 +1,53 @@
+import { TileLayer, type TileLayerOptions } from '@leafletGl';
+/**
+ * Rectangle coords at a specific zoom level; left and top are inclusive, right and bottom tiles excluded.
+ * `[ left, top, right, bottom, zoom ]`
+ */
+export type TileDefPatch = [number, number, number, number, number];
+export type TileDef = {
+    /**
+     * The main tile url.
+     */
+    url: string;
+    subdomains?: string | string[];
+    /**
+     * Tile URL for the patch region, if any is present.
+     */
+    patchUrl?: string;
+    /**
+     * Rectangle coords at a specific zoom level; left and top are inclusive, right and bottom tiles excluded.
+     * `[ left, top, right, bottom, zoom ]`
+     */
+    patch?: TileDefPatch;
+};
+/**
+ * @class Wrapper class over LeafletGl's TileLayer used for loading data from various sources based on zoom.
+ * These sources are defined in the {@link tileDefs} object.
+ * Can optionally apply a "patch", a rectangular region which loads different tiles that the rest of the map.
+ */
+export declare class TileLayerMulti extends TileLayer {
+    /**
+     * Map of zoom level -> tile def.
+     * Each tiledef contains:
+     * - tile url
+     * - patch region precomputed for the current zoom level (if a patch is present)
+     * - patch tile url
+     */
+    private _preparedTileDefs;
+    /**
+     * Maps tile coords X/Y/Z to the index of the corresponding string segment when the tile url is split with `/`.
+     */
+    private _urlMapping;
+    /**
+     * Creates a TileLayerMulti object.
+     * Each tile source url is defined by its url, its upper bound zoom level and an optional patch.
+     * @param tileDefs - An object where a TileDef with a given numeric key is applied to all zoom levels
+     * lower than and including its key and that are not yet covered by a different TileDef with a lower numeric key.
+     * @param options - Standard TileLayer options. Optional.
+     */
+    constructor(tileDefs: Record<number, TileDef>, options?: TileLayerOptions);
+    /**
+     * @summary Handler for constructing the correct tile url based on the zoom
+     */
+    private _modifyTileRequest;
+}

package/types/client/TileLayerPreprocessorStandalone.d.ts

@@ -0,0 +1,45 @@
+import { type TileHeader } from '@windy/TileLayerUtils';
+import { PreprocessedTileParams } from '@windy/TilePreprocessor';
+import type { FullRenderParameters } from '@windy/interfaces';
+/**
+ * A refactored TileLayer preprocessor intended for use with the new tile management.
+ * Assumes that it is only created once for a given set of render params and then disposed when render params change.
+ * Render params may not be changed after initialization.
+ */
+export declare class TileLayerPreprocessorStandalone {
+    private static _textures;
+    private static _texturesLoadPromise;
+    private _renderer;
+    private _primaryGradient?;
+    private _secondaryGradient?;
+    private _renderProperties;
+    private _ptypeColors;
+    private _params;
+    private _gl;
+    private _initialized;
+    private _destroyed;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, params: FullRenderParameters);
+    init(): Promise<void>;
+    /**
+     * Renders a tile with the preprocessing shader into the currently bound framebuffer.
+     */
+    renderTile(gl: WebGLRenderingContext | WebGL2RenderingContext, tileTexture: WebGLTexture, tileHeader: TileHeader, tileParams: PreprocessedTileParams): void;
+    destroy(): void;
+    private _bindUniforms;
+    /**
+     * @summary Initializes the preprocessor renderer including its shader program and geometry
+     */
+    private _initRenderer;
+    /**
+     * @summary Function called on each params update (in case user changed color palette)
+     */
+    private _createUpdateGradients;
+    /**
+     * Ensures that pattern textures are loaded.
+     * Either initiates the load and awaits it, or,
+     * if the textures are already loaded, returns immediately.
+     * If called while the textures are loading, waits until they are ready.
+     */
+    private _prepareTextures;
+    private static _prepareTextures;
+}

package/types/client/TileLayerRenderer.d.ts

@@ -0,0 +1,24 @@
+import { GlRenderer } from '@windy/glUtils';
+import type { ReadyTile } from '@windy/tileHelpers';
+import type { SwitchableTileCache } from '@windy/SwitchableTileCache';
+/**
+ * Handles rendering of already preprocessed tiles with a simple shader.
+ * Does not depend on current map/render params,
+ * only needs a {@link SwitchableTileCache} instance in order to render its tiles.
+ * Has no internal state other than compiled shaders and empty placeholder texture.
+ */
+export declare class TileLayerRenderer extends GlRenderer {
+    private _emptyPlaceholderTexture;
+    private _bindings;
+    constructor(gl: WebGL2RenderingContext | WebGLRenderingContext);
+    render(_gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * Renders the layer using the currently loaded tiles in the current cache of the supplied SwitchableTileCache.
+     */
+    renderTiles(gl: WebGL2RenderingContext | WebGLRenderingContext, cache: SwitchableTileCache<ReadyTile>): void;
+    /**
+     * @summary Renderer destructor
+     */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    private _initializeRenderer;
+}

package/types/client/TileLayerUtils.d.ts

@@ -0,0 +1,43 @@
+import { GlTexture } from '@windy/glUtils';
+import type { Color } from '@windy/Color';
+import type { DataQuality } from '@windy/Product';
+import type { Vector2 } from '@windy/math';
+export type TileHeader = {
+    decoderRstep: number;
+    decoderRmin: number;
+    decoderGstep: number;
+    decoderGmin: number;
+    decoderBstep: number;
+    decoderBmin: number;
+};
+/**
+ * TileLayer min-max zoom - affects all tileLayer-based layers (tileLayer, accumulations, etc)
+ */
+export declare const tileLayerZoomBounds: Vector2;
+export type GradientProps = {
+    texture: GlTexture | null;
+    mul: number;
+    add: number;
+} | null;
+export declare function decodeHeader(imageData: Uint8Array | Uint8ClampedArray, width: number): Float32Array;
+export declare function processHeader(decodedHeader: Float32Array): TileHeader;
+export declare function imageBitmapToUint8Array(imageBitmap: ImageBitmap): Uint8Array;
+/**
+ * Creates color gradient texture
+ * @param colorObj Color instance
+ * @returns texture with additional params
+ */
+export declare function createGradientObject(gl: WebGL2RenderingContext | WebGLRenderingContext, colorObj: Color): GradientProps;
+export declare function prepareRainPattern(gl: WebGL2RenderingContext | WebGLRenderingContext): GlTexture;
+/**
+ * @summary Returns data zoom offset for the supplied data quality
+ *  - zoom offset is used to offset the current map/tile zoom for fetching data tiles
+ * @param dataQuality
+ */
+export declare function dataQualityToZoomOffset(dataQuality: DataQuality): number;
+export declare const decodedTileDataSize = 257;
+/**
+ * Returns a 257x257 texture containing the image with the header removed.
+ */
+export declare function decodeImageBytesCompact(imageData: Uint8Array | Uint8ClampedArray): Uint8Array;
+export declare function decodeImage(imageData: Uint8Array): Promise<ImageBitmap>;

package/types/client/TilePreprocessor.d.ts

@@ -0,0 +1,27 @@
+import type { GlTexture } from '@windy/glUtils';
+import type { Coords } from '@leafletGl';
+export declare enum TilePreprocessorType {
+    NONE = 0,
+    RADAR_FLOW = 1,
+    RADAR_DATA_WEBP = 2,
+    SATELLITE_DATA = 3,
+    SATELLITE_FLOW = 4,
+    TILE_LAYER = 5,
+    RADAR_PTYPE = 6
+}
+export declare class PreprocessedTileParams {
+    tileCoords: Coords;
+    payload?: unknown;
+}
+export declare abstract class TilePreprocessor {
+    /**
+     * @summary Renders given tile (texture) using the preprocessor into the the currently bound framebuffer
+     * @param tileTexture Texture to preprocess
+     * @param params Additional optional parameters which might be required for some preprocessing
+     */
+    abstract renderTile(gl: WebGLRenderingContext | WebGL2RenderingContext, tileTexture: GlTexture, tileParams: PreprocessedTileParams): void;
+    /**
+     * @summary Deletes the preprocessor (releases its resources)
+     */
+    abstract destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+}

package/types/client/TopoMap.d.ts

@@ -1,9 +1,9 @@
 import { Renderer } from '@windy/Renderer';
-import type { FullRenderParameters } from '@windy/Layer.d';
-import type { Renderers } from '@windy/Renderer.d';
+import { TileLayer } from '@leafletGl';
+import type { Renderers } from '@windy/Renderer';
 export declare class TopoMap extends Renderer {
-    baseLayer: L.GridLayer | null;
-    open(_params: FullRenderParameters): Promise<void>;
+    baseLayer: TileLayer | null;
+    open(): Promise<void>;
     close(rqrdRenderers: Renderers[]): void;
     addOrUpdateBaseLayer(): void;
     removeBaseLayer(): void;

package/types/client/WindowPlugin.d.ts

@@ -6,11 +6,9 @@ import type { WindowInitParams } from '@windy/Window';
 import type { PluginOpeningOptions, WindowClosingOptions } from '@windy/interfaces.d';
 import type { InterpolatorFactory } from '@windy/interpolator';
 import type { PluginsOpenParams, PluginsQsParams } from '@windy/plugin-params.d';
-import type { BottomSveltePlugins, SveltePanePlugins, SveltePlugins, TagPlugins } from '@windy/plugins.d';
+import type { WindowPlugins } from '@windy/plugins.d';
 import type { ListeningPriority } from '@windy/singleclick.d';
 import type { LoadedTranslations, ParsedQueryString } from '@windy/types';
-export interface WindowPlugins extends TagPlugins, SveltePlugins, SveltePanePlugins, BottomSveltePlugins {
-}
 /** Allowed params to WindowPlugin constructor (private and protected props are omited by default) */
 export type WindowPluginInitParams<P extends keyof WindowPlugins> = PluginInitParams<P> & Omit<WindowInitParams, 'ident' | 'html'> & Partial<Omit<WindowPlugin<P>, 'open' | 'load' | 'refs' | 'node' | 'domEl'>>;
 export declare abstract class WindowPlugin<P extends keyof WindowPlugins> extends Plugin<P> {
@@ -146,10 +144,13 @@ export declare abstract class WindowPlugin<P extends keyof WindowPlugins> extend
     beforeLoad(..._args: unknown[]): void;
     /**
      * Called by router when URL matches plugin's router (feel free to overload it)
+     *
+     * Typing is difficult here, because captured groups provide just object with string values
+     * and we dunno that it adheres to PluginsOpenParams[P] type.
+     *
+     * Yet the return type MUST BE PluginsOpenParams[P] so it can be used
      */
-    onRouteMatch({ groups }: string[] & {
-        groups: PluginsOpenParams[P];
-    }, _qs?: ParsedQueryString): PluginsOpenParams[P] | undefined;
+    onRouteMatch(regExpGroups: Record<string, string>, _qs?: ParsedQueryString): PluginsOpenParams[P];
     /**
      * When called with params, it will create valid URL for plugin
      * as defined in router property.

package/types/client/appsFlyer.d.ts

@@ -1,2 +1,3 @@
-export declare const appsFlyerPromise: Promise<undefined>;
+import type { AppsFlyerPlugin } from 'appsflyer-capacitor-plugin/src/definitions';
+export declare const appsFlyerPromise: Promise<AppsFlyerPlugin | undefined>;
 export declare function logAppsFlyerProductChange(): void;

package/types/client/baseMap.d.ts

@@ -1,13 +1,23 @@
 export type MapTilesKeys = 'graymap' | 'landmaskmap' | 'simplemap' | 'graymapPatch5' | 'graymapPatch11' | 'simplemapPatch5' | 'simplemapPatch9' | 'sznmap' | 'winter' | 'satLocal' | 'sat';
+/**
+ * Last zoom level at which the gray base map is displayed.
+ * At higher zooms, outdoor map is used instead.
+ */
+export declare const grayMapZoomEnd = 11;
 /**
  * Return just record of different map tilesURLs that we use as basemap
  */
 export declare const mapTilesRecord: (patchType?: string | null) => Record<MapTilesKeys, string>;
+export declare const baseMapLayerId = "raster-basemap";
 /**
  * Adds basemap to Leaflet map or updates source of tiles it if already exists
  */
-export declare function addOrUpdateBasemap(map: L.Map): void;
+export declare function addOrUpdateBasemap(): void;
 /**
  * Remove basemap from Leaflet map
  */
-export declare function removeBasemap(map: L.Map): void;
+export declare function removeBasemap(): void;
+/**
+ * Move basemap to a new bucket
+ */
+export declare function reorderBasemapLayer(newBucketId: number): void;

package/types/client/broadcast.d.ts

@@ -6,7 +6,7 @@
  * @module broadcast
  *
  */
-import type { Broadcast } from './broadcast.d';
+import type { Broadcast } from './d.ts.files/broadcast.d';
 declare const bcast: Broadcast;
 /**
  * Major broadcast service for sending events to other parts of Windy.

package/types/client/cityLabels.d.ts

@@ -3,8 +3,7 @@
  *
  * @module cityLabels.ts
  */
-export declare const labelsLayer: any;
-export declare const add: () => void;
-export declare const remove: () => void;
+import LabelsLayer from '@windy/LabelsLayer';
 export declare const disable: () => void;
 export declare const enable: () => void;
+export declare const cityLabels: LabelsLayer;

package/types/client/colorGradients.d.ts

@@ -1,13 +1,7 @@
 /**
  * Reusable color gradients
  */
-import type { RGBA, ColorGradient } from '@windy/Color.d';
-import type { NumValue } from '@windy/types';
-export declare const moistureAnomaly: RGBA[];
-export declare const airPollutant: RGBA[];
-export declare const cloudBaseAndVisibility: RGBA[];
-export declare const radarGradientAndValues: ColorGradient;
-/**
- * Creates a color gradient from array of prepared ones
- */
-export declare const createColorGradient: (gradient: RGBA[], numValues: NumValue[]) => ColorGradient;
+import type { RGBString } from '@windy/types.d';
+export declare const moistureAnomaly: RGBString[];
+export declare const airPollutant: RGBString[];
+export declare const cloudBaseAndVisibility: RGBString[];

package/types/client/colors.d.ts

@@ -1,4 +1,3 @@
-import { Color } from '@windy/Color';
-import type { ColorIdent } from '@windy/Color.d';
+import { Color, type ColorIdent } from '@windy/Color';
 declare const colors: Record<ColorIdent, Color>;
 export default colors;

package/types/client/css.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/client/customProtocol.d.ts

@@ -0,0 +1,11 @@
+import type { CustomProtocol, TileDataPreprocessCallback, TransformedUrlPayload } from '@windy/mapUtils.d';
+/**
+ * @summary Registers custom protocol to the maplibre, which tells maplibre that we would like to take responsibility for fetching these tiles
+ *  - this is useful when we want to modify the original tile request url etc.
+ *  - for example to inject additional parameters such as timestamp, satellite key etc., since maplibre supports only {x}/{y}/{z} parameters
+ * @param protocol Placeholder protocol (e.g. "myProtocol") which is set to the tile url instead of the standard http/https protocol and which is used by maplibre to differentiate between tiles to be intercepted
+ * @param urlTransformCallback Callback function to be called for each intercepted tile request
+ *   - the provided callback should take two parameters (the current tile url and the custom protocol) and should output valid tile url or empty string in case the tile should be aborted
+ * @param usePlaceholderImage Whether to use "no-data" placeholder tile in case the original tile could not be loaded
+ */
+export declare function registerCustomTileProtocol(protocol: CustomProtocol, urlTransformCallback: (url: string, protocol: string) => TransformedUrlPayload, tilePreprocessCallback?: TileDataPreprocessCallback, fallbackImageData?: ArrayBuffer, replaceEmpty?: boolean): void;

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

@@ -1,4 +1,4 @@
-import type { Texture2D } from 'plugins/_shared/gl-lib/gl-lib';
+import type { Texture2D } from '@plugins/shared/gl-lib/gl-lib';
 import type {
     Mat2,
     Mat2d,
@@ -18,10 +18,6 @@ export interface CustomError extends Error {
     full?: string;
 }
 
-// export type WebGLProgramObject = {
-//     [whatever: string]: any;
-// };
-
 export type UniformName = `u${string}`;
 
 export type AttributeName = `a${string}`;

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

@@ -6,6 +6,7 @@ import {
     SatelliteMetric,
     UVIndexMetric,
 } from '@windy/MetricClasses';
+import { Metric } from '@windy/Metric';
 import { NumValue } from '@windy/types.d';
 
 /*
@@ -46,6 +47,7 @@ export type MetricItem =
     | 'type'
     | 'l/km²'
     | 'W/m²'
+    | 'kW/m'
     | 'drought'
     | 'fwi'
     | 'mm/h'
@@ -53,7 +55,9 @@ export type MetricItem =
     | 'uvindex'
     | 'EDR'
     | 'km²'
-    | 'acres';
+    | 'acres'
+    | 'AQI'
+    | 'gr./m³';
 
 /**
  * # @windy/metrics
@@ -116,11 +120,14 @@ export interface MetricTypes {
     fwi: NumberedMetric;
     dfm10h: NumberedMetric;
     solarpower: NumberedMetric;
+    wavePower: NumberedMetric;
     uvindex: UVIndexMetric;
     capAlerts: NumberedMetric;
     turbulence: NumberedMetric;
     icing: NumberedMetric;
     area: NumberedMetric;
+    aqi: NumberedMetric;
+    pollen: NumberedMetric;
 }
 
 /** @ignore */
@@ -190,4 +197,18 @@ export interface Conversion {
 export type ConvObj = { [K in MetricItem]?: Conversion };
 
 /** @ignore */
-export type MetricInitParams = Pick<NumberedMetric, 'ident'> & Partial<NumberedMetric>;
+export type MetricInitParams = Pick<Metric, 'ident'> &
+    Partial<
+        Pick<
+            Metric,
+            | 'lines'
+            | 'conv'
+            | 'backConv'
+            | 'defaults'
+            | 'cohesion'
+            | 'nativeSync'
+            | 'description'
+            | 'separator'
+            | 'discreteLegend'
+        >
+    >;

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

@@ -39,6 +39,7 @@ export interface NumberRange {
 
 export interface AlertConditionBase {
     type: AlertConditionType;
+    valid?: boolean;
 }
 
 export interface CloudinessAlertCondition extends AlertConditionBase {