@windycom/plugin-devtools 3.0.2 → 3.0.3

package/types/client/IDB.d.ts

@@ -1,10 +1,22 @@
+import { Evented } from '@windy/Evented';
 import type { Timestamp } from '@windy/types.d';
+import type { IdbConnection } from '@windy/idbConnection';
 /**
  * List of all collections we will need in our database
  * remember to update this list when adding new collections
  * Collections MUST be created at once
  */
-export declare const allUsedCollections: readonly ["customColors", "installedPlugins", "likedStoryComments", "log", "markedNotams", "popularLocations", "searchRecents2", "seenArticles", "seenPromos", "seenStories", "slidedCapAlerts", "userAlerts", "userFavs"];
+export declare const allUsedCollections: readonly ["customColors", "installedPlugins2", "likedStoryComments", "log", "markedNotams", "popularLocations", "searchRecents2", "upvotedArticles", "seenPromos", "slidedCapAlerts", "userAlerts", "userFavs"];
+interface IdbEvent {
+    _nativeSync: [{
+        storeId: DatabaseStore;
+        syncToNativeStorage: boolean;
+    }];
+}
+/**
+ * Used by nativeStorage.ts to sync IDB with native storage
+ */
+export declare const idbEmitter: Evented<IdbEvent>;
 /**
  * Allowed data types for storage
  */
@@ -15,14 +27,18 @@ export type BackendItem<V> = {
     value: V;
 };
 export type BackendPayload<V> = BackendItem<V>[];
-export type SupportedApiEndpoints = 'notams' | 'colors' | 'alerts' | 'favs';
+/**
+ * Any objecgs synced with cloud MUST have an unique id property
+ */
+export type SupportedApiEndpoints = 'notams' | 'colors' | 'alerts' | 'favs' | 'plugins';
 export type StoredObjectWithId = {
     id: string;
 };
 export interface IDBParams {
     storeId: DatabaseStore;
-    initPromise: Promise<IDBDatabase>;
+    connection: IdbConnection;
     backendApiEndpoint?: SupportedApiEndpoints;
+    syncToNativeStorage?: boolean;
 }
 /**
  * Wrapper around IndexedDB to provide async storage
@@ -33,7 +49,7 @@ export declare class IDB<K extends string | number, V, W = V> {
     private storeId;
     private memoryCache;
     private cacheIsValid;
-    private initPromise;
+    private connection;
     /**
      * Is this db synced with backend?
      *
@@ -45,6 +61,10 @@ export declare class IDB<K extends string | number, V, W = V> {
      * URL of the API endpoint, where data should be stored
      */
     private apiEndpoint;
+    /**
+     * Should this DB sync with mobile native storage
+     */
+    private syncToNativeStorage;
     /**
      * Timestamp of last db update on this device (used only when collection has userBackend)
      */
@@ -67,3 +87,4 @@ export declare class IDB<K extends string | number, V, W = V> {
      */
     loadFromCloud(): Promise<boolean>;
 }
+export {};

package/types/client/LabelsLayer.d.ts

@@ -1,2 +1,69 @@
-declare const _default: any;
-export default _default;
+import { GridLayer, LeafletGlMap, type Coords, type GridLayerOptions } from '@leafletGl';
+import type { CityDiv, CityDivId, CityLabel, CityLabelData } from './d.ts.files/LabelsLayer.d';
+import type { Products } from './d.ts.files/rootScope.d';
+import type { MetricIdent, MetricItem } from './d.ts.files/Metric.d';
+import type { CityTemperaturesDto } from '@windy-types/citytile2';
+/**
+ * Leaflet layer with city labels and temperatures
+ */
+declare class LabelsLayer extends GridLayer<CityLabelData> {
+    static defaultOptions: Required<GridLayerOptions>;
+    /** Currently selected product in client */
+    product?: Products;
+    /** Cache of leaflet tiles with labels and temperatures */
+    cityDivs: Record<CityDivId, CityDiv>;
+    /** Currently selected forecast timestamp in client */
+    ts: number;
+    /** Whether hooks are binded (true) or not (false) */
+    hasHooks: boolean;
+    forecastLoaded: boolean;
+    /** URL for getting label tiles */
+    tilesUrl?: string;
+    /** Current reftime in client */
+    refTime?: string;
+    /** Temperature unit */
+    temperatureUnit?: MetricItem;
+    constructor(options?: GridLayerOptions);
+    onAdd(leafletMap: LeafletGlMap): this;
+    onRemove(leafletMap: LeafletGlMap): this;
+    /** Creates and stores URL for fetching label tiles */
+    createTilesUrl(): void;
+    /** Update labels (e.g. when language is changed) */
+    updateLabels(): void;
+    /**
+     * Updates product name and reference time, also can fetch and update temperature data
+     * @param refreshWeather Whether fetch forecast data or not (true from store event)
+     */
+    updateProduct(refreshWeather?: boolean): Promise<void>;
+    /** Click event for labels */
+    onClick(sourceEl: HTMLElement): void;
+    /** TS change event whenever client's timestamp (progress bar) is changed */
+    onTsChange(ts: number): void;
+    /** Load new data when temperature unit is changed  */
+    onMetricChanged(ident: MetricIdent, item: MetricItem): void;
+    /** Update temp values for all tiles, e.g. when timestamp or metric is changed (it doesn't fetch new data from the server) */
+    refreshWeather(): void;
+    /** Redraw whole layer as it was first loaded */
+    _reset(): void;
+    /** Returns array of all cities in a form { id, el } */
+    toArray(): CityLabel[];
+    getCityDivs(): CityDiv[];
+    /** Fetch forecast temperature data for the tile */
+    loadTileForecast(tileDiv: CityDiv): void;
+    /** Callback when forecast data are retrieved */
+    onForecastLoaded(tileDiv: CityDiv, data: CityTemperaturesDto): void;
+    protected _loadTileData(coords: Coords, abort: AbortSignal): Promise<CityLabelData | null>;
+    protected _createTileContents(tileRoot: HTMLElement, coords: Coords, data: CityLabelData): void;
+    /**
+     * Adds DIVs with labels to the DOM, it does not fetch any data (called e.g. after retrieving labels data)
+     * It does not render temperature which is appended to this div later
+     */
+    private renderTile;
+    private getIndexToCityTileData;
+    /**
+     * Render forecast data for the tile, it does not fetch forecast data (called e.g. whenever refreshWeather is called)
+     * Enhances DIV with data-id="id" with loaded weather.
+     */
+    private renderWeather;
+}
+export default LabelsLayer;

package/types/client/Layer.d.ts

@@ -22,12 +22,14 @@ export interface LayerMetricType {
     ecmwfWindParticles500h: undefined;
     ecmwfWindParticles600h: undefined;
     waveParticles: undefined;
+    waveParticlesWaves: undefined;
     currentParticles: undefined;
     currentsTideParticles: undefined;
     wind: NumberedMetric;
     temp: NumberedMetric;
     wetbulbtemp: NumberedMetric;
     solarpower: NumberedMetric;
+    wavePower: NumberedMetric;
     uvindex: UVIndexMetric;
     dewpoint: NumberedMetric;
     gust: NumberedMetric;
@@ -64,7 +66,6 @@ export interface LayerMetricType {
     dustsm: NumberedMetric;
     radar: NumberedMetric;
     satellite: NumberedMetric;
-    radarPlus: NumberedMetric;
     gtco3: NumberedMetric;
     pm2p5: NumberedMetric;
     no2: NumberedMetric;

package/types/client/MetricClasses.d.ts

@@ -31,7 +31,7 @@ export declare class SatelliteMetric extends NumberedMetric {
      * Dynamic update from minifest/info.json
      * @param pars various pars depending on concrete instance
      */
-    updateLines(pars: [number, number], radarEnabled?: boolean): void;
+    updateLines(pars: [number, number], _radarEnabled?: boolean): void;
 }
 export declare class PrecipMetric extends NumberedMetric {
     initProperties(): void;

package/types/client/Overlay.d.ts

@@ -5,7 +5,7 @@ import type { Iconfont } from '@windy/iconfont.d';
 import type { Overlays } from '@windy/rootScope.d';
 import type { RGBNumValues } from '@windy/interpolatorTypes';
 import type { LoadedTranslations, HTMLString, RGBString } from '@windy/types';
-export type UsedOverlays = Overlays | 'swell' | 'satelliteIRBT';
+export type UsedOverlays = Overlays | 'swell';
 export type OverlayInitParams = Pick<Overlay, 'ident'> & Partial<Overlay>;
 type LayerProperty<L extends Layer | undefined, P extends keyof Layer> = L extends Layer ? L[P] : undefined;
 type MetricProperty<M extends Metric | undefined, P extends keyof Metric> = M extends Metric ? M[P] : undefined;
@@ -79,10 +79,6 @@ export declare class Overlay<I extends Overlays = Overlays, M extends I extends
      * Hides particle on/off switch in GUI (so far used only in desktop GUI)
      */
     hideParticles?: boolean;
-    /**
-     * Disables isolines on/off switch in GUI
-     */
-    hideIsolines?: boolean;
     /**
      * Given overlay display accumulation
      */

package/types/client/Product.d.ts

@@ -1,12 +1,13 @@
 import { Calendar } from '@windy/Calendar';
+import { type LeafletGlMap } from '@leafletGl';
 import type { MinifestObject } from '@windy/Calendar';
 import type { Layers } from '@windy/Layer';
 import type { LatLon } from '@windy/interfaces';
 import type { Isolines, Levels, Overlays, Products } from '@windy/rootScope.d';
-import type { ISODateString, ProductCategory, ProductIdent, Timestamp, Path, Minutes } from '@windy/types';
+import type { ISODateString, ProductCategory, ProductIdent, Timestamp, TimeRangeMs, Path, Minutes } from '@windy/types';
 export type DataQuality = 'normal' | 'high' | 'low' | 'ultra' | 'extreme';
 export type FileSuffix = 'png' | 'jpg' | 'webp';
-export type ProductInitParams = Pick<Product, 'modelName' | 'provider' | 'interval'> & Partial<Pick<Product, 'provider' | 'ident' | 'maxTileZoom' | 'animationSpeed' | 'animationSpeed1h' | 'fileSuffix' | 'fileSuffixFallback' | 'JPGtransparency' | 'PNGtransparency' | 'dataQuality' | 'betterDataQuality' | 'animation' | 'labelsTemp' | 'overlays' | 'preferredProduct' | 'isolines' | 'directory' | 'category' | 'modelIdent' | 'intervalPremium' | 'server' | 'modelResolution' | 'levels' | 'levelsOverride' | 'logo' | 'preferredWaveProduct' | 'preferredAirProduct' | 'hasAccumulations' | 'hasMinifest' | 'freeProduct' | 'hideProductSwitch' | 'modelDescription'>> & {
+export type ProductInitParams = Pick<Product, 'modelName' | 'provider' | 'interval'> & Partial<Pick<Product, 'provider' | 'ident' | 'maxTileZoom' | 'animationSpeed' | 'animationSpeed1h' | 'fileSuffix' | 'fileSuffixFallback' | 'JPGtransparency' | 'PNGtransparency' | 'dataQuality' | 'betterDataQuality' | 'animation' | 'labelsTemp' | 'overlays' | 'preferredProduct' | 'isolines' | 'directory' | 'category' | 'modelIdent' | 'intervalPremium' | 'server' | 'modelResolution' | 'levels' | 'levelsOverride' | 'logo' | 'preferredWaveProduct' | 'preferredAirProduct' | 'hasAccumulations' | 'hasMinifest' | 'freeProduct' | 'hideProductSwitch' | 'modelDescription' | 'supportsMeteogram'>> & {
     forecastSize?: number;
     bounds?: [number, number][][];
 };
@@ -15,7 +16,7 @@ export declare class Product {
      * Boundaries of the product in a format [[north, west], [north, east], [south, east], [south, west]] or any more accurate polygon
      */
     private bounds?;
-    private minifestExpirationTime;
+    protected minifestExpirationTime: TimeRangeMs;
     /**
      * Minifest loading promise
      */
@@ -76,7 +77,7 @@ export declare class Product {
     /**
      * Description of product for purpose of UI
      */
-    modelName: string;
+    modelName: string | '';
     modelResolution?: number;
     provider?: string;
     /**
@@ -169,6 +170,10 @@ export declare class Product {
      * Time when minifest was last updated
      */
     minifestLastUpdate?: Timestamp;
+    /**
+     * Point fcst backend for this product supports airgram/meteogram
+     */
+    supportsMeteogram?: boolean;
     constructor(params: ProductInitParams);
     getRefTimeISOFormat(): Promise<ISODateString | undefined>;
     getRefTime(): Promise<Path | undefined>;
@@ -184,7 +189,7 @@ export declare class Product {
     /**
      * Detects if the the bounds are in viewport
      */
-    boundsAreInViewport(map: L.Map): boolean;
+    boundsAreInViewport(map: LeafletGlMap): boolean;
     close(): void;
     open(): void;
     getCalendar(): Promise<Calendar | undefined>;

package/types/client/ProductClasses.d.ts

@@ -30,6 +30,13 @@ export declare class SatAndRadarPlusProduct extends Product {
     urlSuffFlow: string;
     constructor(params: SatelliteProductInitParams);
 }
+/**
+ * Auxiliary product with fake calendar required for rendering of isolines on top of overlays, that do not have calendar nor load minifest
+ *  - provides timestamp array with single timestamp pair equal to the current time
+ */
+export declare class FakeCalendarProduct extends Product {
+    loadMinifest(): Promise<MinifestObject>;
+}
 export declare class NamProducts extends Product {
     constructor(params: Partial<ProductInitParams>);
 }

package/types/client/Renderer.d.ts

@@ -3,9 +3,15 @@ import type { Timestamp, TransformFunction } from '@windy/types';
 import type { Layers } from '@windy/Layer';
 import type { InterpolatorFactory } from '@windy/interpolator';
 import type { BottomSveltePlugins, Plugins, SveltePlugins } from '@windy/plugins.d';
-import type { TileLayerCanvas } from '@windy/TileLayerCanvas.d';
-export type AllowedRenderPlugins = Pick<Plugins, 'radar' | 'satellite' | 'radar-plus' | 'cap-alerts' | 'isolines' | 'gl-particles'>;
-export type Renderers = 'tileLayer' | 'radar' | 'satellite' | 'radarPlus' | 'capAlerts' | 'isolines' | 'particles' | 'accumulations' | 'daySwitcher' | 'noUserControl' | 'topoMap';
+export type AllowedRenderPlugins = Pick<Plugins, 'radar' | 'radar-plus' | 'cap-alerts' | 'isolines' | 'gl-particles'>;
+interface DependencyModuleMap {
+    radar: WPluginModules['@plugins/radar'];
+    'radar-plus': WPluginModules['@plugins/radar-plus'];
+    'cap-alerts': WPluginModules['@plugins/cap-alerts'];
+    isolines: WPluginModules['@plugins/isolines'];
+    'gl-particles': WPluginModules['@plugins/gl-particles'];
+}
+export type Renderers = 'tileLayer' | 'radar' | 'radarPlus' | 'capAlerts' | 'isolines' | 'particles' | 'accumulations' | 'daySwitcher' | 'noUserControl' | 'topoMap';
 export interface TileParams extends TilePoint {
     url: string;
     intX: number;
@@ -26,7 +32,7 @@ export interface RendererInitParams {
  * Renderer class acts as a proxy between renderController and code, which is responsible for
  * rendering a particular layer
  */
-export declare class Renderer<K extends keyof AllowedRenderPlugins | undefined = undefined, P extends K extends keyof AllowedRenderPlugins ? WPluginModules[`@plugins/${K}`] : undefined = K extends keyof AllowedRenderPlugins ? WPluginModules[`@plugins/${K}`] : undefined> {
+export declare class Renderer {
     isOpen: boolean;
     /**
      * Ident of renderer. Not used in runtime, but essential for debugging.
@@ -44,11 +50,11 @@ export declare class Renderer<K extends keyof AllowedRenderPlugins | undefined =
      *  - redraw
      *  - interpolator
      */
-    dependency?: K;
+    dependency?: keyof AllowedRenderPlugins;
     /**
      * Loaded version of plugin dependency
      */
-    loadedDependency?: P | typeof TileLayerCanvas;
+    loadedDependency?: DependencyModuleMap[keyof DependencyModuleMap];
     /**
      * ID of plugin, that serve as user control, which can be attached to DOM
      * usually to #plugin-bottom div.
@@ -64,26 +70,17 @@ export declare class Renderer<K extends keyof AllowedRenderPlugins | undefined =
      * userControl opening and closing is handles by rndrCtrl
      */
     userControl?: AllowedUserControls;
-    /**
-     * Picker interpolation factory
-     */
+    /** Picker interpolation factory */
     interpolator?: InterpolatorFactory;
-    /**
-     * Instance of this renderer requires FullRenderParameters to be passed
-     * to renderer methods
-     */
+    /** Requires FullRenderParameters */
     requiresFullRenderParams: boolean;
     constructor(params: RendererInitParams);
+    private static hasProp;
     open(layerIdent: Layers, weatherParams: WeatherParameters, timestamp: Timestamp): Promise<void>;
-    /**
-     * Called by rndrCtrl. Requires list of required renderers,
-     * so we kno who will replace us. This parameters is here just because of
-     * TileLayer, which is just wrapper around Leaflet GridLayer, and we want to
-     * keep this Leaflet instance alive.
-     */
     close(_rqrdRenderers: Renderers[]): void;
     onopen(params?: FullRenderParameters): void;
     onclose(): void;
     paramsChanged(layerIdent: Layers, weatherParams: WeatherParameters, timestamp: Timestamp): Promise<void>;
     redraw(): void;
 }
+export {};

package/types/client/ShaderStorage.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @class Shader source storage for different WebGL contexts
+ *  - we aim for using WebGL1 shaders where possible to minimize duplicate code, unless we need some WebGL2-specific features
+ *  - therefore we use WebGL1 sources also in case of WebGL2 context, but it can be overridden in case it is necessary
+ */
+export declare class ShaderStorage {
+    static WGL2: {
+        vTileTextureBlit: string;
+        vScreenQuad: string;
+        fTileTextureBlit: string;
+        fTextureDebug: string;
+        fTextureBlit: string;
+        fTileLayerPreprocess: string;
+        fTileLayerPtypePreprocess: string;
+    };
+    static WGL1: {
+        vTileTextureBlit: string;
+        vScreenQuad: string;
+        fTileTextureBlit: string;
+        fTextureDebug: string;
+        fTextureBlit: string;
+        fTileLayerPreprocess: string;
+        fTileLayerPtypePreprocess: string;
+    };
+}

package/types/client/StartupElementPlugin.d.ts

@@ -0,0 +1,8 @@
+import { SveltePlugin } from '@windy/SveltePlugin';
+import type { SveltePluginInitParams } from '@windy/SveltePlugin';
+import type { StartupElementPlugins } from '@windy/plugins.d';
+export type StartupElementPluginInitParams<P extends keyof StartupElementPlugins> = Omit<SveltePluginInitParams<P>, 'ident'> & Pick<StartupElementPlugin<P>, 'ident'>;
+export declare class StartupElementPlugin<P extends keyof StartupElementPlugins> extends SveltePlugin<P> {
+    ident: P;
+    constructor(params: StartupElementPluginInitParams<P>);
+}

package/types/client/SveltePlugin.d.ts

@@ -1,10 +1,10 @@
 import { WindowPlugin } from '@windy/WindowPlugin';
 import type { WindowPluginInitParams } from '@windy/WindowPlugin';
 import type { PluginsOpenParams, PluginsQsParams } from '@windy/plugin-params.d';
-import type { BottomSveltePlugins, SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
+import type { BottomSveltePlugins, StartupElementPlugins, SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
 import type { InterpolatorFactory } from '@windy/interpolator';
 import type { FullRenderParameters } from '@windy/interfaces';
-export declare class SvelteApp<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins> {
+export declare class SvelteApp<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins | keyof StartupElementPlugins> {
     interpolator?: InterpolatorFactory;
     constructor(_args: {
         target: HTMLElement;
@@ -30,8 +30,8 @@ export declare class ExternalSvelteApp {
     $destroy(): void;
 }
 /** Allowed params to SveltePlugin constructor (private and protected props are omited by default) */
-export type SveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
-export declare class SveltePlugin<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins> extends WindowPlugin<P> {
+export type SveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins | keyof StartupElementPlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
+export declare class SveltePlugin<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins | keyof StartupElementPlugins> extends WindowPlugin<P> {
     /**
      * Holder of SvelteApp
      */

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/interfaces';
+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;
+}