@windycom/plugin-devtools 1.0.1

package/types/MetricClasses.d.ts

@@ -0,0 +1,37 @@
+import { Metric } from '@windy/Metric';
+import type { MetricItem, MetricInitParams } from '@windy/Metric.d';
+import type { NumValue } from '@windy/types.d';
+export declare class NumberedMetric extends Metric<number> {
+    /**
+     * produces converted number value without label
+     */
+    convertNumber(value: NumValue, forcedPrecision?: number, metric?: MetricItem): number;
+}
+export declare class CapAlertMetric extends Metric<number> {
+    /**
+     * Can be called by accident by some part of code
+     */
+    convertNumber(_value: NumValue): number;
+}
+export declare class PtypeMetric extends Metric<string> {
+    convertNumber(i: number): string;
+}
+export declare class UVIndexMetric extends Metric<string> {
+    convertNumber(i: number): string;
+    convertValue(i: number): string;
+}
+export declare class FogMetric extends Metric<string> {
+    convertNumber(i: number): string;
+    convertValue(i: number): string;
+}
+export declare class SatelliteMetric extends NumberedMetric {
+    constructor(params: MetricInitParams);
+    /**
+     * Dynamic update from minifest/info.json
+     * @param pars various pars depending on concrete instance
+     */
+    updateLines(pars: [number, number]): void;
+}
+export declare class PrecipMetric extends NumberedMetric {
+    initProperties(): void;
+}

package/types/MobileCalendar.d.ts

@@ -0,0 +1,47 @@
+import { Scrollable } from '@windy/Scrollable';
+import type { Calendar } from '@windy/Calendar';
+import type { ScrollableInitParams } from '@windy/Scrollable';
+import type { TimeFormatFunction } from '@windy/format.d';
+import type { Timestamp } from '@windy/types.d';
+export type MobileCalendarInitParams = {
+    boxEl: HTMLDivElement;
+    wrapperEl: HTMLDivElement;
+    scrolling: boolean;
+    noAnimation: boolean;
+    tsPx: number;
+    calExpandedTimeout: ReturnType<typeof setTimeout> | null;
+    UIident: string;
+    bindedStore?: 'timestamp';
+} & ScrollableInitParams;
+export declare class MobileCalendar extends Scrollable {
+    private scrolling;
+    private noAnimation;
+    private wrapperEl;
+    /**
+     * timestamp per pixel ratio - must be in sync with CSS
+     * 3 hour = 20px
+     */
+    private tsPx;
+    /**
+     * Handle of a timeout that controls the `mobile-calendar-expanded` class
+     */
+    private calExpandedTimeout;
+    private bindedStore;
+    localeHours: TimeFormatFunction;
+    zuluMode: boolean;
+    boxEl: HTMLDivElement;
+    UIident: string;
+    timestamp: Timestamp;
+    calendar: Calendar | null;
+    constructor(params: MobileCalendarInitParams);
+    unmount(): void;
+    onscroll(ev: Event): void;
+    render(): void;
+    renderBox(): void;
+    /**
+     * Scrolls to selected ts
+     */
+    set(ts: Timestamp, UIident?: string): void;
+    protected onscrollend(): void;
+    private slideUp;
+}

package/types/NamProducts.d.ts

@@ -0,0 +1,5 @@
+import { Product } from '@windy/Product';
+import type { ProductInitParams } from '@windy/Product';
+export declare class NamProducts extends Product {
+    constructor(params: Partial<ProductInitParams>);
+}

package/types/OfflineMessagesClasses.d.ts

@@ -0,0 +1,30 @@
+import { Window } from '@windy/Window';
+import type { DownloadProgress } from '@plugins/offline/offline.d';
+import type { Timestamp } from '@windy/types';
+export declare class OfflineModeTopMessage extends Window {
+    lastTimeDownloaded: Timestamp;
+    timer: ReturnType<typeof setInterval> | null;
+    constructor(lastTimeDownloaded: Timestamp);
+    onclose(): void;
+    onopen(): void;
+}
+export declare class DownloadingProgressTopMessage extends Window {
+    bindedOnProgress: ({ data }: {
+        data: DownloadProgress;
+    }) => void;
+    progressEl: HTMLDivElement;
+    progressBarEl: HTMLDivElement;
+    constructor();
+    onProgress({ data }: {
+        data: DownloadProgress;
+    }): void;
+    onclose(): void;
+    onopen(): void;
+}
+export declare class GoOfflineModeTopMessage extends Window {
+    expires: Timestamp;
+    timer: ReturnType<typeof setInterval> | null;
+    constructor(expires: Timestamp);
+    onclose(): void;
+    onopen(): void;
+}

package/types/Overlay.d.ts

@@ -0,0 +1,150 @@
+import type { Layer } from '@windy/Layer';
+import type { LayerMetricType, Layers } from '@windy/Layer.d';
+import type { Metric } from '@windy/Metric';
+import type { DirectionFunction } from '@windy/format.d';
+import type { Iconfont } from '@windy/iconfont.d';
+import type { Overlays } from '@windy/rootScope.d';
+import type { RGBNumValues } from '@windy/tileInterpolator.d';
+import type { LoadedTranslations } from '@windy/trans.d';
+import type { HTMLString } from '@windy/types';
+export type UsedOverlays = Overlays | 'gh' | 'swell' | 'satelliteIRBT';
+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;
+export declare class Overlay<I extends Overlays | 'gh' = Overlays | 'gh', M extends I extends Layers ? LayerMetricType[I] : undefined = I extends Layers ? LayerMetricType[I] : undefined, L extends Layer<M> | undefined = I extends Layers ? Layer<M> : undefined> {
+    /**
+     * Main ident
+     */
+    ident: I;
+    /**
+     * Translation string
+     */
+    trans: keyof LoadedTranslations;
+    /**
+     * Shortened version of translation string
+     *
+     * Used only on fav overlays in desktop. It is worth to
+     * fill only for overlays with long names, that are used
+     * as a default fav overlay in desktop.
+     */
+    transShort?: keyof LoadedTranslations;
+    /**
+     * Overlay has more levels
+     */
+    hasMoreLevels?: boolean;
+    /**
+     * Icon used in menus and such
+     */
+    icon: Iconfont;
+    /**
+     * Layers used
+     */
+    layers: I extends Layers ? [...Layers[], I] | [I, ...Layers[]] : undefined;
+    /**
+     * Is the overlay supported in globe mode. Default: false
+     */
+    globeNotSupported: boolean;
+    /**
+     * Show interpolated weather value over cities, when user switches to POI cities
+     * TODO: Unify property with hideWxLabels
+     */
+    poiInCities: boolean;
+    /**
+     * Hide interpolated weather value over cities, when user switches to POI cities
+     */
+    hideWxLabels?: boolean;
+    /**
+     * Eg. in day-switcher we need as short name as possible
+     */
+    shortname?: string;
+    /**
+     * Eg. in overlays gallery it is needed to have more specific name of the layer
+     */
+    fullname?: string;
+    /**
+     * When overlay represents group of other layers, this can be used to get the whole group menu icon independently from the layer
+     */
+    menuIcon?: Iconfont;
+    /**
+     * When overlay represents group of other layers, this can be used to name the whole group in menu independently from the layer
+     */
+    menuTrans?: keyof LoadedTranslations;
+    /**
+     * Hide overlay from listing in all the menus
+     */
+    partOf?: Overlays;
+    /**
+     * Applies class 'hide-particles' to the body
+     */
+    hideParticles?: boolean;
+    /**
+     * Given overlay display accumulation
+     */
+    isAccu?: boolean;
+    /**
+     * allwaysOn
+     */
+    allwaysOn?: boolean;
+    /**
+     * Programatically injected properties from particulat Metric instance
+     */
+    m: M;
+    convertValue: MetricProperty<M, 'convertValue'>;
+    convertNumber: MetricProperty<M, 'convertNumber'>;
+    setMetric: MetricProperty<M, 'setMetric'>;
+    cycleMetric: MetricProperty<M, 'cycleMetric'>;
+    listMetrics: MetricProperty<M, 'listMetrics'>;
+    /**
+     * Programatically injected properties from particulat Layer instance
+     */
+    c: LayerProperty<L, 'c'>;
+    l: LayerProperty<L, 'l'>;
+    cm: LayerProperty<L, 'cm'>;
+    constructor(params: OverlayInitParams);
+    /**
+     * Render's overlay's legend inside  el
+     */
+    paintLegend(el: HTMLDivElement): void;
+    /**
+     * Return translated description of overlay
+     *
+     * @param short If true, return shortened version of description if avail
+     */
+    getName(short?: boolean): string;
+    /**
+     * Get menu title
+     *
+     * @param short If true, return shortened version of description if avail
+     */
+    getMenuName(short?: boolean): string;
+    /**
+     * Return ident of menu item (usualy `ident` but some inner overlays has `partOf` and are not directly in menu)
+     */
+    getMenuIdent(): Overlays;
+    /**
+     * Custom onopen methods, currently unused
+     */
+    onopen?(): void;
+    onclose?(): void;
+    /**
+     * Create part of inner text of picker
+     * @param values Interpolated values
+     */
+    createPickerHTML(values: RGBNumValues, _directionFormattingFunction: DirectionFunction): HTMLString;
+    /**
+     * In case of picker interpolator returns null value, this method is called
+     * (is consumed by PickerMobile only so far)
+     */
+    createPickerInvalidHTML(): HTMLString;
+    /**
+     * Create title for picker content
+     * @param alternativeContent Alternative text inside title
+     */
+    createPickerTitle(alternativeContent?: string): HTMLString;
+    /**
+     * Just proxy to the Metric's metric property
+     */
+    get metric(): "" | import("./Metric").MetricItem;
+    protected initProperties(): void;
+}
+export {};

package/types/OverlayClasses.d.ts

@@ -0,0 +1,29 @@
+import { Overlay } from '@windy/Overlay';
+import type { DirectionFunction } from '@windy/format.d';
+import type { Overlays } from '@windy/rootScope.d';
+import type { RGBNumValues } from '@windy/tileInterpolator.d';
+import type { LoadedTranslations } from '@windy/trans.d';
+export declare class CurrentOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+    createPickerHTML(values: RGBNumValues, formatDir: DirectionFunction): string;
+}
+export declare class WaveOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+    createPickerHTML(values: RGBNumValues, formatDir: DirectionFunction): string;
+}
+export declare class AwpOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+    labels: {
+        [value: number]: keyof LoadedTranslations;
+    };
+    createPickerHTML(values: RGBNumValues): string;
+}
+export declare class FwiOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+    labels: {
+        [value: number]: keyof LoadedTranslations;
+    };
+    createPickerHTML(values: RGBNumValues): string;
+}
+export declare class RainPtypeOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+    createPickerHTML(values: RGBNumValues): string;
+}
+export declare class CloudsOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+    createPickerHTML(values: RGBNumValues): string;
+}

package/types/Particles.d.ts

@@ -0,0 +1,111 @@
+import type { RGBAString, RGBA } from '@windy/Color.d';
+import type { Levels } from '@windy/rootScope.d';
+import type { ExtendedRenderParams } from '@windy/interfaces.d';
+import type { CustomParticles } from '@windy/dataSpecifications.d';
+export type ParticlesInitParams = Pick<Particles, 'multiplier' | 'velocity' | 'glMinSpeedParam' | 'glSpeedCurvePowParam' | 'glMaxSpeedParam' | 'glParticleWidth' | 'glParticleLengthEx' | 'glSpeedPx' | 'glCountMul'> & Partial<Pick<Particles, 'configurable' | 'glVelocity' | 'glOpacity' | 'glBlending' | 'getBlendingAlpha' | 'animation' | 'styles' | 'lineWidth' | 'getIntensityFun' | 'getStyles'>>;
+export declare class Particles {
+    /**
+     * Parameters below are configurable via particlesConfig
+     */
+    configurable: boolean;
+    /**
+     * Custom user particles configuration
+     */
+    config: CustomParticles;
+    /**
+     * Type of animation
+     */
+    animation: 'dot' | 'wavecle';
+    /**
+     * Blue particles on detailed map
+     */
+    stylesBlue: RGBAString[];
+    /**
+     * Holder for alternative styles
+     */
+    styles?: RGBAString[];
+    /**
+     * width of particle based on zoom level
+     */
+    lineWidth: number[];
+    /**
+     * Speed reduction based on zoom level
+     */
+    zoom2speed: number[];
+    /**
+     * Reducing velocity of particles based on level (considering high winds up there)
+     */
+    level2reduce: Record<Levels, number>;
+    /**
+     * For particles.config.opacity values 0..1 we change only opacity
+     * For vlauer 1..2 we change also color
+     */
+    colors: RGBA[];
+    /**
+     * amount and speedof patricles on screen as a function of zoom
+     * value = 1 / ( constant * Math.pow(pow, (mapZoom - zoom)))
+     */
+    multiplier: {
+        constant: number;
+        pow: number;
+        zoom: number;
+    };
+    velocity: {
+        max: number;
+        damper: number;
+    };
+    /**
+     * webGL config
+     */
+    glSpeedCurvePowParam: number;
+    glMinSpeedParam: number;
+    glMaxSpeedParam: number;
+    glParticleWidth: number;
+    glParticleLengthEx: number;
+    glSpeedPx: number;
+    glVelocity: number;
+    glOpacity: number;
+    glBlending: number;
+    glCountMul: number;
+    constructor(params: ParticlesInitParams);
+    /**
+     * Return function that, will create intensity number
+     * based on particle force and location
+     */
+    getIntensityFun(): (force: number) => number;
+    /**
+     * Returns magnitude 2 screen velocity fun
+     *
+     * screenSpeed = c * ( 1 - 1 / ( a * c * magnitude - 1) )
+     *
+     * c = velocity.max * userConfig * level2reduce
+     * a = velocity.damper
+     *
+     * `a`, `c` jsou koeficienty. Pricemz `c` je max. obrazovkova
+     * rychlost a tim `a` si doladis prubeh te funkce. Cim vyssi bude `a`,
+     * tim rychleji to poroste k tomu `c` a naopak cim bude `a` blize k nule,
+     * tim pomaleji to poroste.
+     *
+     * Both a,c coefs are multiplied by user (0.5 - 1.5) and zoom level (0.6 - 1)
+     */
+    getVelocityFun(params: ExtendedRenderParams): (mag: number) => number;
+    getAmountMultiplier(): number;
+    /**
+     * Returns amount of particles for given wscreen size, based on zoom
+     * and speed2pixel ratio. If speed2pixel is lower than 1, we multiply amount by
+     * 1 + 1.5 * ( 1 - speed2pixel )
+     */
+    getAmount(params: ExtendedRenderParams): number;
+    getLineWidth(params: ExtendedRenderParams): number;
+    /**
+     * resulting table looks like this for opacity 1
+     * ['rgba(200,200,200,1)','rgba(215,215,215,1)','rgba(235,235,235,
+     */
+    getStyles(params?: ExtendedRenderParams): RGBAString[] | undefined;
+    getMaxAge(): number;
+    /**
+     * Blending opacity, for 'repainting' new canvas and letting particles to
+     * fade. If speed2pixel ratio is low we increase lengt of particles
+     */
+    getBlendingAlpha(params?: ExtendedRenderParams): string | number;
+}

package/types/Plugin.d.ts

@@ -0,0 +1,112 @@
+import type { WindowClosingOptions } from '@windy/interfaces.d';
+import type { SupportedLangFiles } from '@windy/lang-files.d';
+import type { Plugins } from '@windy/plugins.d';
+type LangFileKey = keyof SupportedLangFiles;
+export type PluginIdent = keyof Plugins;
+export type PluginPane = 
+/** Right Hand pane */
+'rhpane'
+/** Small bottom location (like radar control) that can adjust its size and coexist with LH,RHpane */
+ | 'small-bottom'
+/** Big bottom location, that cant coexist with LH, RH panes like detail/station/rplanner */
+ | 'bottom'
+/** Pop up window in the middle of the page like subscription */
+ | 'center'
+/** Top location on mobile devices like picker-mobile, distance etc */
+ | 'top'
+/** Plugin is embedded into detail as nearest webcam/station/airq */
+ | 'nearest'
+/** Bottom plugin that ducks under mobile time controls (use only in exception) */
+ | 'small-bottom-bottom'
+/** External plugin embedded to HP */
+ | 'embedded';
+/** Allowed params to Plugin constructor (private and protected props are omited by default) */
+export type PluginInitParams<P extends PluginIdent> = Pick<Plugin<P>, 'ident'> & Partial<Omit<Plugin<P>, 'isLoaded' | 'isOpen' | 'load' | 'open'>>;
+export declare class Plugin<P extends PluginIdent> {
+    protected static iAm: "plugin";
+    /**
+     * Status of the plugin (is being loaded right now)
+     */
+    protected loading: boolean;
+    /**
+     * Main promise of plugin being loaded
+     */
+    protected promise?: Promise<void | boolean>;
+    /**
+     * Plugin ident, witohout any prefix, just id
+     */
+    ident: P;
+    /**
+     * FQDN URL of plugin .js file
+     */
+    location: string;
+    /**
+     * Required language files
+     */
+    langFiles?: LangFileKey[];
+    /**
+     * Status of the plugin (is loaded or not)
+     */
+    isLoaded: boolean;
+    /**
+     * Into which pane is plugin opened. This property is used by pluginCtrl only
+     * and should prevent opening several overlapping plugins at the same location
+     * especially on desktop or tablet devices.
+     *
+     * On mobile phones, most of the plugins (expecially LH, RH pane) become
+     * fullsctreen plugins.
+     */
+    pane?: PluginPane;
+    /**
+     * Is the tag currentlly open?
+     */
+    isOpen?: boolean;
+    /**
+     * After opening, plugin is not closed automatically by pluginCtrl
+     *
+     * Other methods of closing are possible
+     */
+    neverClose?: boolean;
+    /**
+     * After loading, plugin is automatically resolved with require
+     * should replace previous AutoOpenPlugin class.
+     *
+     * NOTE: autoPen plugins do not use parametr passe to open method
+     * Is the plugin resolved by require?
+     */
+    isResolved?: boolean;
+    /**
+     * Resolved plugin after calling require
+     */
+    plugin?: WPluginModules[`@plugins/${P}`] & AdditionalPluginAssets;
+    /**
+     * Whenever set, this plugin (when opened) disables opening
+     * of mobile picker on map interaction. Shoul be used with
+     * bottm, top pane plugins and plugins, that can be opened
+     * in half
+     */
+    disableMobilePicker?: boolean;
+    constructor(params: PluginInitParams<P>);
+    /**
+     * Loads the plugin
+     */
+    load(): Promise<void | boolean>;
+    /**
+     * Opens the plugin (note, that opening args are ignored)
+     */
+    open(..._args: unknown[]): Promise<void | boolean>;
+    /**
+     * Ready to be overloaded
+     */
+    close(_opts?: WindowClosingOptions): void;
+    /**
+     * Ready to be overloaded
+     */
+    redraw(..._args: unknown[]): void;
+    /**
+     * Ready to be overloaded
+     */
+    paramsChanged(..._args: unknown[]): void;
+    protected initProperties(): void;
+}
+export {};