@windycom/plugin-devtools 1.0.1

package/types/Product.d.ts

@@ -0,0 +1,211 @@
+import { Calendar } from '@windy/Calendar';
+import type { MinifestObject } from '@windy/Calendar.d';
+import type { Layers } from '@windy/Layer.d';
+import type { DataQuality, FileSuffix } from '@windy/Product.d';
+import type { HttpPayload } from '@windy/http.d';
+import type { LatLon } from '@windy/interfaces';
+import type { AcTimes, Isolines, Levels, Overlays, Products } from '@windy/rootScope.d';
+import type { ProductCategory, ProductIdent } from '@windy/types';
+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' | 'prefferedProduct' | 'pathGenerator' | 'isolines' | 'directory' | 'category' | 'modelIdent' | 'intervalPremium' | 'server' | 'modelResolution' | 'levels' | 'logo' | 'acTimes'>> & {
+    requiresInfoJson?: boolean;
+    forecastSize?: number;
+    bounds?: [number, number][][];
+};
+export declare class Product {
+    /**
+     * Minifest loading promise
+     */
+    protected loadingPromise?: null | Promise<Calendar | undefined | void>;
+    /**
+     * Version of minifest used
+     */
+    protected infoVersion?: string;
+    /**
+     * minifest loading timer
+     */
+    private refreshInterval?;
+    /**
+     *  Timestamp of last minifest check
+     */
+    private minifestTimestamp;
+    /**
+     * Boundaries of the product in a format [[north, west], [north, east], [south, east], [south, west]] or any more accurate polygon
+     */
+    private bounds?;
+    /**
+     * Has binded listeners
+     */
+    private hasListeners;
+    private bindedCheckNewMinifest;
+    /**
+     * When the product will expire (in ms)
+     */
+    private productExpires;
+    /**
+     * Unefective, but simple refTime solutions for data that are updated once a day
+     */
+    protected dailyCache?: string;
+    /**
+     * Must contain ident of self
+     */
+    ident: Products;
+    /**
+     * Maximum data tile resolution
+     */
+    maxTileZoom?: {
+        free: number;
+        premium: number;
+    };
+    /**
+     * Speed of animation in timestamp seconds per normal second
+     *
+     * for example 3600 = 1h per 1 second
+     */
+    animationSpeed: number;
+    animationSpeed1h: number;
+    /**
+     * Default fileSuffix. Can be overwriten by overlay
+     */
+    fileSuffix: FileSuffix;
+    /**
+     * Backup fileSuffix if fileSuffix not supported (used if webp not supported)
+     */
+    fileSuffixFallback?: FileSuffix;
+    /**
+     * Overlay uses transparency defined in B channel in JPG
+     */
+    JPGtransparency: boolean;
+    /**
+     * Overlay uses transparency defined in A channel in PNG
+     */
+    PNGtransparency: boolean;
+    /**
+     * Quality of downloaded data for this
+     * product. Can be overwritten by overlay
+     */
+    dataQuality: DataQuality;
+    /**
+     * Array of layers, where data quaility is one step
+     * better than 'dataQuality'. For instance ['rain','clouds']
+     */
+    betterDataQuality: Layers[];
+    /**
+     * Play/pause animation of this products is possible
+     */
+    animation: boolean;
+    /**
+     * Calendar used for this product
+     * (created during initialization)
+     */
+    calendar?: Calendar;
+    /**
+     * Description of product for purpose of UI
+     */
+    modelName: string;
+    modelResolution?: number;
+    provider?: string;
+    /**
+     * Update interval (in minutes)
+     */
+    interval: number;
+    intervalPremium?: number;
+    /**
+     * Usual length of forecast in hours (used upon creation of backup minifest)
+     */
+    forecastSize: number;
+    /** Directory (path in URL) on image server, if not provided, `category/modelIdent` is used */
+    directory: string;
+    /**
+     * Category of the model
+     */
+    category?: ProductCategory;
+    /**
+     * Server side model ident, used by DS and other BE services
+     * This should replace `ident` at some point, becasue `ident` is used only on client and BE needs to convert it to `modelIdent`
+     */
+    modelIdent?: ProductIdent;
+    /**
+     * Model can be used for temeperature in labels
+     */
+    labelsTemp: boolean;
+    /**
+     * Logo of provider in rh-bottom
+     */
+    logo?: string;
+    /**
+     * List of avail overlays
+     */
+    overlays: Overlays[];
+    /**
+     * List of avail levels
+     */
+    levels?: Levels[];
+    /**
+     * List of avail isolines
+     */
+    isolines: Isolines[];
+    requiresInfoJson: boolean;
+    /**
+     * If we drag out of bounds, which product we should use (must be global air product)
+     */
+    prefferedProduct: 'ecmwf' | 'gfs' | 'icon' | 'iconEu';
+    /**
+     * Holder of the latest minifest
+     */
+    minifest?: MinifestObject | null;
+    /**
+     * How the data image path should be constructed
+     */
+    pathGenerator: string;
+    /**
+     * List of available accumulationTime
+     */
+    acTimes?: AcTimes[];
+    /**
+     * Alternative server, where the data are loaded from
+     */
+    server?: string;
+    /**
+     * Some product (f.ex. StaticProduct) doesn't have meaningful
+     * information about the model and time of the next update.
+     * Set this to false to hide the info where not relevant (f.ex. Info plugin)
+     */
+    hasRefTime: boolean;
+    constructor(params: ProductInitParams);
+    refTime(): string;
+    getUpdateTimes(): {
+        refTime: string;
+        minUpdate: number;
+    } | {
+        refTime?: undefined;
+        minUpdate?: undefined;
+    };
+    moveTs(moveRight: boolean, isAccu?: boolean): boolean | void;
+    getMinifestUrl(): string;
+    loadMinifest(): Promise<HttpPayload<MinifestObject>>;
+    open(): Promise<void | Calendar>;
+    close(): void;
+    /**
+     * Checks if lat,lon is within bounds
+     */
+    pointIsInBounds<T extends LatLon>(this: this, paramsMap: T): boolean;
+    printLogo(): void;
+    getInfoFileUrl(): string;
+    getCalendar(): Promise<Calendar>;
+    protected expire(): void;
+    protected getStoreKey(): `lastMinifest/${string}`;
+    protected setMinifest(minifest: MinifestObject): void;
+    protected setExpireTime(): void;
+    /**
+     * Major reason for this error is user's bad connection, which is handled
+     * by standard no connetion red message
+     *
+     * We delay 0.3 sec to test properlly connection
+     */
+    protected showErrorMessage(err: string): void;
+    protected loadAndProcessMinifest(forced?: boolean): Promise<void>;
+    protected loadAndProcessInfo(): Promise<void>;
+    private loadInfo;
+    private checkNewMinifest;
+    private removeLogo;
+}

package/types/ProductSwitch.d.ts

@@ -0,0 +1,14 @@
+import { BindedSwitch } from '@windy/BindedSwitch';
+import type { BindedSwitchInitParams } from '@windy/BindedSwitch';
+export type ProductSwitchInitParams = {
+    showResolution?: boolean;
+} & Omit<BindedSwitchInitParams<'product'>, 'bindStore'>;
+export declare class ProductSwitch extends BindedSwitch<'product'> {
+    showResolution: boolean;
+    constructor(params: ProductSwitchInitParams);
+    printHTML(prods?: ("radar" | "satellite" | "capAlerts" | "cams" | "icon" | "drought" | "gfs" | "ecmwf" | "ecmwfAnalysis" | "ecmwfWaves" | "gfsWaves" | "iconWaves" | "efi" | "cmems" | "fireDanger" | "activeFires" | "nems" | "namConus" | "namHawaii" | "namAlaska" | "iconEu" | "iconD2" | "arome" | "aromeAntilles" | "aromeReunion" | "camsEu" | "iconEuWaves" | "hrrrAlaska" | "hrrrConus" | "bomAccess" | "ukv" | "mblue")[]): void;
+    /**
+     * The menu is already in a DOM since we do not modify products so often
+     */
+    protected redraw(): void;
+}

package/types/Renderer.d.ts

@@ -0,0 +1,69 @@
+import type { FullRenderParameters } from '@windy/Layer.d';
+import type { Renderers } from '@windy/Renderer.d';
+import type { InterpolatorFactory } from '@windy/interpolator';
+import type { BottomTagPlugins, Plugins } from '@windy/plugins.d';
+type AllowedRenderPlugins = Pick<Plugins, 'radar' | 'satellite' | 'cap-alerts' | 'isolines' | 'gl-particles' | 'particles'>;
+export interface RendererInitParams {
+    ident: Renderers;
+    dependency?: keyof AllowedRenderPlugins;
+    userControl?: keyof BottomTagPlugins;
+}
+/**
+ * Renderer class act as a proxy between renderController and code, which is responsible to
+ * render particullar 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> {
+    isOpen: boolean;
+    /**
+     * Ident of renderer. Not used in runtime, but essential for debugging.
+     * Do not remove
+     */
+    ident: Renderers;
+    /**
+     * Dependency plugin that wil be loaded before renderer is launched
+     *
+     * Dependency plugin can optinally export these methods:
+     *
+     *  - onRenderStart
+     *  - onRenderEnd
+     *  - paramsChanged
+     *  - redraw
+     *  - interpolator
+     */
+    dependency?: K;
+    /**
+     * Loaded version of plugin dependency
+     */
+    loadedDependency?: P;
+    /**
+     * ID of plugin, that serve as user control, which can be attached to DOM
+     * usually to #plugin-bottom div.
+     *
+     * Contrary to dependencies, userControl is loaded after dependencies, thus NOT
+     * delaying launch of whole layer.
+     *
+     * Any single plugin can serve both as renderer and userControl.
+     *
+     * In this case, make sure, that plugin, that serves as userControl
+     * is duplicated as dependency.
+     *
+     * userControl opening and closing is handles by rndrCtrl
+     */
+    userControl?: keyof BottomTagPlugins;
+    /**
+     * Picker ingerpolation factory
+     */
+    interpolator?: InterpolatorFactory;
+    constructor(params: RendererInitParams);
+    open(params: FullRenderParameters): Promise<void>;
+    /**
+     * Called by rndrCtrl
+     * list of required renderers, so we kno who will replace us
+     */
+    close(_rqrdRenderers: Renderers[]): void;
+    onopen(params: FullRenderParameters): void;
+    onclose(): void;
+    paramsChanged(params: FullRenderParameters): void;
+    redraw(): void;
+}
+export {};

package/types/SatelliteProduct.d.ts

@@ -0,0 +1,19 @@
+import { StaticProduct } from './StaticProduct';
+import type { HttpPayload } from '@windy/http.d';
+import type { SatelliteInfoJson } from '@windy/satellite.d';
+import type { ProductInitParams } from './Product';
+export type SatelliteProductInitParams = Pick<SatelliteProduct, 'urlSuff' | 'urlSuffFlow'> & ProductInitParams;
+export declare class SatelliteProduct extends StaticProduct {
+    urlSuff: string;
+    urlSuffFlow: string;
+    constructor(params: SatelliteProductInitParams);
+    open(): Promise<undefined>;
+    /**
+     * Return info.json loading promise (https://sat.windy.com/satellite/info.json)
+     */
+    loadInfoJson(noCache?: boolean): Promise<HttpPayload<SatelliteInfoJson>>;
+    /**
+     * Handling keyboard shortcuts
+     */
+    moveTs(moveRight: boolean): void;
+}

package/types/Scrollable.d.ts

@@ -0,0 +1,14 @@
+export type ScrollableInitParams = Pick<Scrollable, 'scrollEl'>;
+export declare class Scrollable {
+    scrollTicking: boolean;
+    protected scrollEndTimer: ReturnType<typeof setTimeout> | null;
+    scrollEl: HTMLElement;
+    constructor(params: ScrollableInitParams);
+    onscroll(_ev: Event): void;
+    /**
+     * Forces to scroll table to selected @stop position
+     */
+    scrollTo(stop: number): void;
+    protected onscrollend(): void;
+    private scrollFired;
+}

package/types/StaticProduct.d.ts

@@ -0,0 +1,7 @@
+import { Product } from '@windy/Product';
+import type { ProductInitParams } from '@windy/Product';
+export declare class StaticProduct extends Product {
+    constructor(params: ProductInitParams);
+    refTime(): string;
+    open(): Promise<any>;
+}

package/types/SveltePanePlugin.d.ts

@@ -0,0 +1,18 @@
+import { SveltePlugin } from '@windy/SveltePlugin';
+import type { WindowPluginInitParams } from '@windy/WindowPlugin';
+import type { SveltePanePlugins } from '@windy/plugins.d';
+export type SveltePanePluginInitParams<P extends keyof SveltePanePlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePanePlugin<P>, 'ident' | 'additionalClassName'> & Partial<SveltePanePlugin<P>>;
+/**
+ * Common pane plugin, that appear in LH Pane on desktop, RH pane in tablet
+ * and appears from bottom on mobile devices
+ *
+ * Please note, that `hasKeyboard` nad `weDisplayURL` property is set true by default
+ */
+export declare class SveltePanePlugin<P extends keyof SveltePanePlugins> extends SveltePlugin<P> {
+    ident: P;
+    /**
+     * Additional class name to add to custom Pane Plugin
+     */
+    additionalClassName?: string;
+    constructor(params: SveltePanePluginInitParams<P>);
+}

package/types/SveltePlugin.d.ts

@@ -0,0 +1,40 @@
+import { WindowPlugin } from '@windy/WindowPlugin';
+import type { WindowPluginInitParams } from '@windy/WindowPlugin';
+import type { PluginsOpenParams, PluginsQsParams } from '@windy/plugin-params.d';
+import type { SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
+export declare class SvelteApp<P extends keyof SveltePlugins | keyof SveltePanePlugins> {
+    constructor(_args: {
+        target: HTMLElement;
+        anchor: HTMLElement;
+    });
+    onopen(params?: PluginsOpenParams[P], qs?: PluginsQsParams[P]): void;
+    onclose(): void;
+    $destroy(): void;
+}
+/**
+ * Same as SvelteApp type, but without any information, about required
+ * types for params & qs
+ */
+export declare class ExternalSvelteApp {
+    constructor(_args: {
+        target: HTMLElement;
+        anchor: HTMLElement;
+    });
+    onopen(params?: unknown, qs?: unknown): void;
+    onclose(): void;
+    $destroy(): void;
+}
+/** Allowed params to SveltePlugin constructor (private and protected props are omited by default) */
+export type SveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
+export declare class SveltePlugin<P extends keyof SveltePlugins | keyof SveltePanePlugins> extends WindowPlugin<P> {
+    /**
+     * Holder of SvelteApp
+     */
+    private svelteApp?;
+    ident: P;
+    plugin: WPluginModules[`@plugins/${P}`] & AdditionalSvelteAssets;
+    onopen(params?: PluginsOpenParams[P], _qs?: PluginsQsParams[P]): void;
+    ondestroy(): void;
+    protected mount(): void;
+    protected unmount(): void;
+}

package/types/Swipe.d.ts

@@ -0,0 +1,34 @@
+export type SwipeDirection = null | 'left' | 'right' | 'up' | 'down';
+export type SwipeInitParams = {
+    el: HTMLElement;
+    onswipe(_dir: SwipeDirection, _distance: number, _evt: TouchEvent): void;
+    threshold?: number;
+    onswipestart?(_evt: TouchEvent): void;
+};
+export declare class Swipe {
+    /**
+     * Element to be swiped
+     */
+    private el;
+    /**
+     * Treshold in pixels to consider element to be "swiped"
+     */
+    private threshold;
+    private direction;
+    private isSwipeValid;
+    private x;
+    private y;
+    private xStart;
+    private yStart;
+    private xThrottled;
+    private yThrottled;
+    constructor(params: SwipeInitParams);
+    private touchStart;
+    private touchMove;
+    private touchEnd;
+    private onswipestart;
+    /**
+     * This method will be called during the swipe
+     */
+    private onswipe;
+}

package/types/Switch.d.ts

@@ -0,0 +1,24 @@
+import { ClickHandler } from '@windy/ClickHandler';
+import type { ClickHandlerInitParams } from '@windy/ClickHandler';
+export type SwitchInitParams<T> = ClickHandlerInitParams<T> & {
+    initValue?: T | null;
+    onset?(_value: T): void;
+};
+export declare class Switch<T> extends ClickHandler<T> {
+    /**
+     * Init value
+     */
+    protected initValue: T | null;
+    protected selected: T | null;
+    constructor(params: SwitchInitParams<T>);
+    set(value: T, noEmit?: boolean): void;
+    /**
+     * Returns first element with particular value
+     */
+    protected getEl(value: T): HTMLElement | null;
+    protected click(command: string, value: T, noEmit?: boolean): void;
+    /**
+     * Will be called upon click on something
+     */
+    protected onset(_value: T): void;
+}

package/types/TagPlugin.d.ts

@@ -0,0 +1,6 @@
+import { WindowPlugin } from '@windy/WindowPlugin';
+import type { TagPlugins } from '@windy/plugins.d';
+export declare class TagPlugin<P extends keyof TagPlugins> extends WindowPlugin<P> {
+    ident: P;
+    plugin: WPluginModules[`@plugins/${P}`] & AdditionalPluginAssets;
+}

package/types/TileLayer.d.ts

@@ -0,0 +1,9 @@
+import { Renderer } from '@windy/Renderer';
+import type { FullRenderParameters } from '@windy/Layer.d';
+import type { RendererInitParams } from '@windy/Renderer';
+import type { Renderers } from '@windy/Renderer.d';
+export declare class TileLayer extends Renderer {
+    constructor(params: RendererInitParams);
+    onopen(params?: FullRenderParameters): void;
+    close(rqrdRenderers: Renderers[]): void;
+}

package/types/TileLayerCanvas.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/types/TileLayerMultiPatch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/types/TimestampBar.d.ts

@@ -0,0 +1,8 @@
+import { BindedBar } from '@windy/BindedBar';
+import type { BindedBarInitParams } from '@windy/BindedBar';
+export type TimestampBarInitParams = Omit<BindedBarInitParams, 'bindTimestamp' | 'bindCalendar' | 'bindAnimation'>;
+export declare class TimestampBar extends BindedBar {
+    constructor(params: TimestampBarInitParams);
+    protected createText(el: HTMLElement): string;
+    protected createGhostText(ghostLeft: number): string;
+}

package/types/Webcams.d.ts

@@ -0,0 +1,66 @@
+import { ClickHandler } from '@windy/ClickHandler';
+import type { ClickHandlerInitParams } from '@windy/ClickHandler';
+import type { WebcamDetail, WebcamsLoadingParams, WebcamMetadata } from '@windy/Webcams.d';
+import type { Plugins } from '@windy/plugins.d';
+import type { LatLon } from '@windy/interfaces';
+export type WebcamsInitParams = {
+    useHover?: boolean;
+    maxAmount?: number;
+    singleLine?: boolean;
+    imgRatio?: number;
+    toOpen?: keyof Plugins;
+} & ClickHandlerInitParams<string>;
+export declare class Webcams extends ClickHandler<string> {
+    protected maxAmount: number;
+    protected imgRatio: number;
+    private toOpen;
+    private currentLocation;
+    protected singleLine: boolean;
+    private useHover;
+    private hasListener;
+    protected daylight: boolean;
+    private marker;
+    data: WebcamDetail[];
+    constructor(params: WebcamsInitParams);
+    /**
+     * Based on webcam item returns additional metadata
+     */
+    static getMetadata(loc: LatLon, cam: WebcamDetail, daylight?: boolean): WebcamMetadata;
+    /**
+     * Just adds dayligtListener
+     */
+    addListeners(): this;
+    /**
+     * Remove listener, remove marker
+     */
+    unmount(): void;
+    /**
+     * Loads a webcams near { lat, lon }
+     *
+     * @returns promise with loaded json
+     */
+    load<T extends WebcamsLoadingParams>(params: T): Promise<WebcamDetail[]>;
+    /**
+     * Pulsating marker
+     */
+    addMarker(index: number): void;
+    removeMarker(): void;
+    /**
+     * Calls callback for each webcam
+     */
+    forEach(cb: (el: HTMLDivElement, i: number) => void): void;
+    /**
+     * Renders HTML into page
+     */
+    protected render(): void | string;
+    /**
+     * Sets w,h of image
+     */
+    protected setWH(w: number, h: number): void;
+    /**
+     * Load images into it
+     */
+    protected loadImages(): void;
+    protected click(command: string, index: string): void;
+    private index2location;
+}

package/types/Window.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Defines openable `Window` containing HTML, CSS
+ */
+import type { WindowOpeningOptions, WindowClosingOptions } from '@windy/interfaces.d';
+import type { HTMLString } from '@windy/types.d';
+export type WindowInitParams = Pick<Window, 'ident' | 'html'> & Partial<Omit<Window, 'isOpen' | 'node' | 'refs' | 'close' | 'open' | 'mount'>>;
+export declare class Window {
+    private static iAm;
+    private closingTimer;
+    private timeoutTimer;
+    /**
+     * Binded veriosn of self closing
+     */
+    private bindedClose;
+    /**
+     * Identifier of window
+     */
+    ident: string;
+    domEl: null | HTMLElement;
+    /**
+     * Attachement point, where the window will come if domEl is not specified
+     * Use data-plugin="" attribute to in HTML code, se we can distinguish between
+     * normal tags and attachement points
+     */
+    attachPoint: string;
+    /**
+     * Does the window reguires keyboard input?
+     */
+    keyboard: boolean;
+    /**
+     * Should the item be closed on click somewhere else? True for any click, false ignores everything (default), 'outside' closes Window only when clicking outside the window
+     */
+    closeOnClick: boolean | 'outside';
+    /**
+     * Uses el.style.display = block to hide/display el on page
+     */
+    displayBlock: boolean;
+    /**
+     * How long should closing of the Window last?
+     */
+    timeout: number;
+    /**
+     * is window open right now
+     */
+    isOpen: boolean;
+    /**
+     * Class applied to body
+     */
+    bodyClass: string;
+    /**
+     * HTML element of this Window
+     */
+    node?: HTMLDivElement;
+    /**
+     * Class name applied to Window element
+     */
+    className?: string;
+    /**
+     * Optional HTML ID identifier
+     */
+    htmlID?: `${'plugin' | 'window' | 'windy-plugin'}-${string}`;
+    /**
+     * HTML content of the Window
+     */
+    html?: string;
+    /**
+     * Disable opening & closing animation
+     */
+    noAnimation?: boolean;
+    constructor(params: WindowInitParams);
+    close(opts?: WindowClosingOptions): void;
+    /**
+     * Open and show the window
+     */
+    open(options?: WindowOpeningOptions): Window;
+    /**
+     * Ready to be overloaded: Will be called after open
+     */
+    onopen(): void;
+    /**
+     * Ready to be overloaded: Will be called before close
+     */
+    onclose(_opts?: WindowClosingOptions): void;
+    /**
+     * Ready to be overloaded: Will be called after close
+     */
+    onclosed(): void;
+    /**
+     * Mounting the Window
+     */
+    mount(optionalHtml?: HTMLString): void;
+    /**
+     * Unmounting the Window
+     */
+    unmount(): void;
+    protected initProperties(): void;
+    /**
+     * Creates node with closing X and put inside HTML code
+     */
+    private createNode;
+    private removeHooks;
+    private addHooks;
+    /**
+     * Key catcher should prevent to send commands to body tag, where they work as navigation
+     */
+    private keyCatcher;
+}