@windycom/plugin-devtools 1.0.1

package/types/Calendar.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Object containing timestamps and methods for given weather product
+ */
+import type { CalendarDay, MinifestObject, Weekday } from '@windy/Calendar.d';
+import type { TimeFormatFunction } from '@windy/format.d';
+import type { Products } from '@windy/rootScope.d';
+import type { ISODateString, Path, Timestamp } from '@windy/types.d';
+export type CalendarInitParams = Pick<Calendar, 'numOfHours' | 'minifestFile'> & {
+    /**
+     * Ident of product that this calendar is for
+     */
+    product: Products;
+    /**
+     * Optional latest timestamp (for use for offline mode for example)
+     */
+    lastTimestamp?: Timestamp;
+};
+export declare class Calendar {
+    /**
+     * Time formatting function
+     */
+    static readonly localeHours: TimeFormatFunction;
+    static readonly weekdays: Weekday[];
+    /**
+     * Number of hours covered by this calendar
+     */
+    numOfHours: number;
+    /**
+     * Type of the calendare
+     */
+    type: 'historical' | 'mixed' | 'forecast';
+    calendarHours: number;
+    /**
+     * Today midnigh in LT of user's computer
+     */
+    midnight: Date;
+    /**
+     * This midnight of other defined start of timeline
+     */
+    startOfTimeline: Date;
+    /**
+     * startOfTimeline in the form of timestamp
+     */
+    start: Timestamp;
+    /**
+     * startOfPremiumTimeline in the form of timestamp; null if it is free in whole range
+     */
+    premiumStart: Timestamp | null;
+    /**
+     * End of calendar timeline
+     */
+    endOfcalendar: Date;
+    /**
+     * endOfcalendar as timestamp
+     */
+    endOfCal: Timestamp;
+    /**
+     * endOfCal or latest timestamp, whiever is smaller
+     */
+    end: Timestamp;
+    /**
+     * Max timestamp value, usually same as end (should be updated later on basis of minifest)
+     */
+    maxTimestamp: Timestamp;
+    /**
+     * Array of calendayr days to be used in UI
+     */
+    days: CalendarDay[];
+    /**
+     * Array of timestamps that contain valid forecast
+     */
+    timestamps: Timestamp[];
+    /**
+     * Array of URL paths that equal to timestamps in a form of "2021/05/27/19"
+     */
+    paths: string[];
+    /**
+     * Minifest that led to construction of this instance
+     */
+    minifestFile: MinifestObject;
+    /**
+     * Is the minifest valid or emergency, created out of the air?
+     */
+    minifestValid: boolean;
+    /**
+     * Minifests's reference time is some non stndard format
+     */
+    refTime: string;
+    /**
+     * Minifests's reference time
+     */
+    refTimeTs: Timestamp;
+    /**
+     * Minifests's reference time
+     */
+    refTimeTxt: ISODateString;
+    /**
+     * Forecast update time
+     */
+    updateTs: Timestamp;
+    /**
+     * Forecast update time
+     */
+    updateTxt: ISODateString;
+    constructor(params: CalendarInitParams);
+    initProperties(): void;
+    /**
+     * Bound ts to be be within limit of calendar
+     */
+    boundTs(ts: Timestamp): Timestamp;
+    /**
+     * Finds closes valid path on the basis of timestamp
+     */
+    ts2path(ts: Timestamp): Path;
+    /**
+     * Creates timestamps out of the air, with 3h interval (fixed)
+     */
+    createTimestamps(): void;
+    prepareTimesFromMinifest(minifest: MinifestObject): boolean;
+    /**
+     * Creates timestamps & paths arrays from minifest
+     */
+    createTimestampsFromMinifest(minifest: MinifestObject): boolean;
+    /**
+     * Return YYYY/MM/DD/HH or YYYYMMDDHH on a basis of provided date
+     * we do not CHECK existence of path in minifest
+     */
+    static date2path(date: Date): Path;
+    /**
+     * Returns JavaScript date object corresponding
+     * to provided path in a form YYYY/MM/DD/HH or YYYYMMDDHH
+     */
+    static path2date(path: string): Date;
+    /**
+     * Returns nice, human readable date string out of ts
+     */
+    static ts2string(ts: string | number): string;
+    /**
+     * Adds hours or days to date
+     *
+     * @example
+     * date = this.add( new Date(), 13, 'days' )
+     */
+    static add(date: Date, x: number, what?: 'days' | 'hours' | undefined): Date;
+    /**
+     * Return nearest midnight
+     */
+    static getMidnight(): Date;
+}

package/types/ClickHandler.d.ts

@@ -0,0 +1,19 @@
+export type ClickHandlerInitParams<T> = {
+    el: HTMLElement;
+    stopPropagation?: boolean;
+    click?(_command: string, _value?: T, _noEmit?: boolean): void;
+};
+export declare class ClickHandler<T> {
+    protected stopPropagation: boolean;
+    el: HTMLElement;
+    constructor(params: ClickHandlerInitParams<T>);
+    initProperties(): void;
+    /**
+     * Called after default handlers ale rulled out
+     */
+    protected click(_command: string, _value?: T, _noEmit?: boolean): void;
+    /**
+     * Initial click event
+     */
+    private onevent;
+}

package/types/Color.d.ts

@@ -0,0 +1,175 @@
+import type { ColorGradient, ColorIdent, PluginColorIdent, RGBA, RGBString } from '@windy/Color.d';
+import type { StoreOptions } from '@windy/store.d';
+import type { NumValue } from '@windy/types.d';
+export type ColorInitParams = Pick<Color, 'ident'> & Partial<Pick<Color, 'qualitative' | 'save'>> & {
+    steps: number;
+    default?: ColorGradient | null;
+    opaque?: boolean;
+    defaultKey?: string;
+    sync?: boolean;
+    prepare?: boolean;
+};
+export declare class Color {
+    /**
+     * Should be color table prepared in advance without calling getColor()
+     * DO NOT MISUSE THIS PROPERTY. Use only for few colors that are used
+     * for initial rendering and overall app
+     */
+    private prepare?;
+    /**
+     * Sync color to the cloud.  By default is set true
+     */
+    private sync?;
+    /**
+     * set all alpha values to 255.  By default is set true
+     */
+    private opaque?;
+    private maxIndex;
+    private step;
+    /**
+     * Index of neutral gray color
+     */
+    private neutralGrayIndex;
+    /**
+     * Initial gradient
+     */
+    private default?;
+    /**
+     * Ident of color
+     */
+    ident: ColorIdent | PluginColorIdent | 'pressureIsolines' | 'temporary' | 'direction';
+    /**
+     * Store key
+     */
+    key: `color2_${string}`;
+    /**
+     * For color loaded from info,json
+     */
+    defaultKey?: string;
+    /**
+     * globe: use discrete palette (not blending between colors)
+     */
+    qualitative?: boolean;
+    /**
+     * Numebr of steps for colors table
+     */
+    steps: number;
+    /**
+     * Actually used gradient (can be sifferent than default)
+     */
+    gradient: ColorGradient;
+    /**
+     * Big interpolated RGBA Type array color table
+     * If defined mean someone already used the color
+     */
+    colors?: Uint8Array | null;
+    /**
+     * Save color to lcal storage. By default is set true
+     */
+    save?: boolean;
+    /**
+     * Min value
+     */
+    min: NumValue;
+    /**
+     * Max value
+     */
+    max: NumValue;
+    constructor(params: ColorInitParams);
+    /**
+     * Inserts the color to the store & prepares it
+     *
+     * @param defaultColors Default color
+     */
+    defineColor(defaultColors: ColorGradient): void;
+    /**
+     * Saves new color gradient to data store
+     */
+    changeColor(gradient: ColorGradient, storeOpts?: StoreOptions): void;
+    /**
+     * Back to default settings
+     */
+    toDefault(): void;
+    /**
+     * Same as getColor, but forces to generate new col tables
+     */
+    forceGetColor(): this;
+    /**
+     * Returns a color based 'rgb()' string on provided value
+     */
+    color(value: NumValue): RGBString;
+    /**
+     * Returns darkened or lightened cersion of original color. Uses the
+     * most primitive method of darkening/lightening by substracting or
+     * adding vale to RGB components
+     *
+     * @param value Original numerical value
+     * @param amount Amount of darkening or lightening in a range -255 to 255
+     */
+    colorDark(value: NumValue, amount: number): RGBString;
+    /**
+     * Returns RGB array based on value
+     */
+    RGBA(value: NumValue): RGBA;
+    /**
+     * create gradient array usable for both WebGL texture and getColor() function
+     * bOpaque .. set alpha to 255
+     * bPremultiply .. mul RGB by A
+     * valueScale .. optional scale used for WebGL texture data (coef 0.5 means half step - gradient size is doubled)
+     * return .. output Uint8Array with color data
+     */
+    createGradientArray(bOpaque?: boolean, bPremultiply?: boolean, valueScale?: number): Uint8Array;
+    createSteppedArray(sourceSmoothArray: Uint8Array, step: number, firstStep?: number): Uint8Array;
+    /**
+     * Returns color instance and creates color table (if not yet created)
+     */
+    getColor(): this;
+    /**
+     * Returns index to the color table based on value
+     */
+    value2index(value: NumValue): number;
+    getColorTable(): ColorGradient | null | undefined;
+    /**
+     * Checks validity of a gradient that it adheres to type ColorGradient
+     */
+    private checkValidity;
+    /**
+     * Forces to generate new color table
+     */
+    private colorChanged;
+    /**
+     * Sets max, min values
+     */
+    private setMinMax;
+    /**
+     * return array multiplied by mul coef
+     */
+    private getMulArray;
+    /**
+     * linear interpolation between array components, factor = <0.0,1.0>;
+     */
+    private lerpArray;
+    /**
+     * color = [ r01, g01, b01, ? ]; components in interval <0.0; 1.0>
+     */
+    private rgba2yuva;
+    /**
+     * color = [ y, u, v, ? ]; y = <0.0; 1.0>, u, v = <-0.5; 0.5>
+     */
+    private yuva2rgba;
+    /**
+     * preserveSaturation .. (maintain |UV| size)
+     */
+    private gradYuva;
+    private vec2size;
+    /**
+     * interpolation between 2 colors in selected space (type)
+     * type .. color space / interpolation type: 'RGB' - linear in RGB space (default)
+     * col1, col2 .. [r, g, b, a]; factor = <0.0,1.0>;
+     */
+    private getGradientColorYUVA;
+    /**
+     * rgbaArray .. [r, g, b, a]; componnents in interval <0;255>
+     */
+    private makePremultiplied;
+}

package/types/DataTiler.d.ts

@@ -0,0 +1,41 @@
+import { dataLoader } from '@windy/dataLoader';
+import type { FullRenderParameters } from '@windy/Layer.d';
+import type { DataTile } from '@windy/dataLoader';
+import type { ExtendedTileParams } from './DataTiler.d';
+export interface TilePoint {
+    x: number;
+    y: number;
+    z: number;
+}
+export type DataTilerInitParams = Partial<Pick<DataTiler, 'loader'>>;
+export declare class DataTiler {
+    /**
+     * Incrementing counter, that keeps getTiles and tilesReady in sync
+     */
+    protected syncCounter: number;
+    /**
+     * Major coeficients (defined after tilesReady)
+     */
+    protected trans: number;
+    protected shift: number;
+    protected lShift: number;
+    protected offsetX: number;
+    protected offsetY: number;
+    protected offset: number;
+    protected width: number;
+    protected height: number;
+    protected w: Uint16Array | null;
+    /**
+     * Just shortcut do datLoader
+     */
+    loader: typeof dataLoader;
+    constructor(params?: DataTilerInitParams);
+    /**
+     * This method will be called when tiles are loaded and ready to be processed
+     */
+    protected tilesReady(_dataTiles: DataTile[][], _mapParams: ExtendedTileParams, _params: FullRenderParameters): void;
+    protected getTiles(params: FullRenderParameters): void;
+    private processTile;
+    private postProcess;
+    private sortTiles;
+}

package/types/Drag.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Drag: Basic draggable Class
+ *
+ * @module Drag
+ */
+export type DragInitParams = Pick<Drag, 'el'> & {
+    supportTouch?: boolean;
+    preventDefault?: boolean;
+    passiveListener?: boolean;
+    ondrag?(x: number, y: number, e: MouseEvent | TouchEvent): void;
+    ondragstart?(startXY: [number, number]): void;
+    ondragend?(e: MouseEvent | TouchEvent): void;
+    bindedDrag?: (e: MouseEvent | TouchEvent) => void;
+    bindedEndDrag?: (ev: MouseEvent | TouchEvent) => void;
+    bindedStart?: (e: MouseEvent | TouchEvent) => void;
+    startDrag?(e: MouseEvent | TouchEvent): void;
+    endDrag?(ev: MouseEvent | TouchEvent): void;
+};
+export declare class Drag {
+    protected supportTouch: boolean;
+    protected preventDefault: boolean;
+    /**
+     * Use false to disable passive listener for 'touchmove'
+     */
+    protected passiveListener: boolean;
+    private startXY;
+    private bindedDrag;
+    private bindedEndDrag;
+    private bindedStart;
+    offsetX: number;
+    offsetY: number;
+    dragging: boolean;
+    el: HTMLElement;
+    constructor(params: DragInitParams);
+    ondragend?(e: MouseEvent | TouchEvent): void;
+    destroy(): void;
+    ondragstart?(startXY: [number, number]): void;
+    ondrag?(x: number, y: number, e: MouseEvent | TouchEvent): void;
+    startDrag(e: MouseEvent | TouchEvent): void;
+    protected endDrag(ev: MouseEvent | TouchEvent): void;
+    private getXY;
+    private _drag;
+}

package/types/DraggableDiv.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Enables Scrollable DIV to be dragged left/right with mouse on non touch devices
+ */
+export type DraggableDivInitParams = {
+    scrollEl: HTMLElement;
+};
+export declare class DraggableDiv {
+    /**
+     * Major element
+     */
+    private scrollEl;
+    private inertiaAnim;
+    constructor(params: DraggableDivInitParams);
+    private getX;
+    /**
+     * Scrolling the table on a basis of dragging with a mouse (non-touch devices)
+     * -- touch should be supported naturally by scrolling the DIV
+     * https://ariya.io/2013/11/javascript-kinetic-scrolling-part-2
+     */
+    private startDrag;
+}

package/types/DropDown.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module DropDown
+ * @example
+ *
+ * ```
+ *    <div ref="ddMenu" class="drop-down-menu noselect">
+ *        <ul class="animation">
+ *            <li data-do="set,one">First item</li>
+ *            <li data-do="set,two">Second item</li>
+ *            <li data-do="set,three">Third item</li>
+ *            <li data-do="set,four">Fourht item</li>
+ *            <li data-do="set,five">Last item</li>
+ *        </ul>
+ *    </div>
+ *
+ *    new DropDown({
+ *        el: refs.ddMenu,
+ *        initValue: 'three'
+ *    })
+ * ```
+ */
+import { Switch } from '@windy/Switch';
+import type { SwitchInitParams } from '@windy/Switch';
+export type DropDownInitParams<T> = SwitchInitParams<T> & {
+    fill?(): void;
+};
+export declare class DropDown<T> extends Switch<T> {
+    private opened;
+    private switch;
+    protected bindedClose: () => void;
+    constructor(params: DropDownInitParams<T>);
+    set(value: T, noEmit?: boolean): void;
+    fill(): void;
+    protected toggle(): void;
+    protected open(): void;
+    protected close(): void;
+}

package/types/EcmwfAnalysisProduct.d.ts

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

package/types/EcmwfProduct.d.ts

@@ -0,0 +1,29 @@
+import { Calendar } from '@windy/Calendar';
+import { Product } from '@windy/Product';
+import type { ProductInitParams } from '@windy/Product';
+/**
+ * Common product params for ECMWF products.
+ */
+export declare const EcmwfProductParams: {
+    modelName: string;
+    modelResolution: number;
+    provider: string;
+    interval: number;
+    intervalPremium: number;
+    maxTileZoom: {
+        free: number;
+        premium: number;
+    };
+    dataQuality: "normal";
+};
+export declare class EcmwfProduct extends Product {
+    calendar: Calendar;
+    constructor(params: Partial<ProductInitParams>);
+    /**
+     * Create fake minifest file for ECMWF product to use it during rendering of
+     * UI before real minifest is loaded.
+     *
+     * DO NOT TRY TO USE THIS CALENDAR FOR FETCHING DATA FROM SERVER!!!!
+     */
+    static createVirtualCalendar(this: EcmwfProduct): Calendar;
+}

package/types/Evented.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @ignore
+ */
+export type EventedInitParams = {
+    ident: string;
+};
+/**
+ * # @windy/Evented
+ *
+ * Major Windy.com even emitter class. Used in @windy/broadcast, @windy/store and other parts of Windy.com
+ * where publish / subscribe pattern is used.
+ *
+ * Enjoy, widely known methods like `on`, `off`, `once` and `emit`
+ * (if you are used to, you can also use `trigger` or `fire`).
+ */
+export declare class Evented<T> {
+    /**
+     * Unique ID of each event subscription (incremental)
+     */
+    private latestId;
+    /**
+     * Store of all active subscriptions. It holds all needed data for trigger listeners for any event.
+     */
+    private _eventedCache;
+    /**
+     * For purpose of developer mode
+     */
+    private listenAllMethod?;
+    /**
+     * Only for DEBUG purposes. Color for console.log printing
+     */
+    private terminalColor?;
+    /**
+     * Identificator of event instance
+     */
+    private ident;
+    /**
+     * Same as `emit` method, just someone, who likes to use it.
+     */
+    trigger?: (typeof this)['emit'];
+    /**
+     * Same as `emit` method, just someone, who likes to use it.
+     */
+    fire?: (typeof this)['emit'];
+    constructor(params: EventedInitParams);
+    /**
+     * Emits a message accompanied from one to four arguments.
+     *
+     * @param topic Topic to emit
+     * @param data Optional data
+     */
+    emit<K extends keyof T, Q extends T[K]>(topic: keyof T, ...data: TrimUndefinedFromRight<Arrayify<Q>>): void;
+    /**
+     * Hooks a callback, that will be triggerd on specified message.
+     *
+     * @param topic Topic to subscribe
+     * @param callback Callback called when topic is emitted
+     * @param context Optional context to change this binding
+     * @param once Optional if callback should be fired only once or at every time
+     * @returns Unsubscribe id
+     */
+    on<K extends keyof T, Q extends T[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>, once?: boolean): number;
+    /**
+     * Hooks a callback, that will be triggerd just once on specified message.
+     *
+     * @param topic Topic to subscribe
+     * @param callback Callback called when topic is emitted
+     * @param context Optional context to change this binding
+     * @returns Unsubscribe id
+     */
+    once<K extends keyof T, Q extends T[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>): number;
+    off(id: number): void;
+    off<K extends keyof T, Q extends T[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>): void;
+    /**
+     * @ignore
+     */
+    listenAll(callback: (topic: keyof T, ...args: unknown[]) => void): void;
+}

package/types/ExternalSveltePlugin.d.ts

@@ -0,0 +1,29 @@
+import { SveltePlugin, type ExternalSvelteApp } from '@windy/SveltePlugin';
+import type { WindowPluginInitParams } from '@windy/WindowPlugin';
+import type { SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
+import type { CompiledExternalPluginConfig, ExternalPluginConfig, InstalledExternalPluginConfig } from '@windy/interfaces';
+import type { PluginPane } from './Plugin';
+/** Allowed params to SveltePlugin constructor (private and protected props are omitted by default) */
+export type ExternalSveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
+export type LoadeExternalSveltePlugin = {
+    default: ExternalSvelteApp;
+} & AdditionalSvelteAssets & {
+    __pluginConfig: CompiledExternalPluginConfig;
+};
+type Config2config = {
+    className: string;
+    attachPoint?: string;
+    pane?: PluginPane;
+};
+export declare class ExternalSveltePlugin extends SveltePlugin<'windy-external-plugin'> {
+    ident: 'windy-external-plugin';
+    plugin: WPluginModules[`@plugins/windy-external-plugin`] & AdditionalSvelteAssets;
+    mobileConfig: Record<InstalledExternalPluginConfig['mobileUI'], Config2config>;
+    desktopConfig: Record<InstalledExternalPluginConfig['desktopUI'], Config2config>;
+    widthOfRhPane: number;
+    listenToSingleclick: ExternalPluginConfig['listenToSingleclick'];
+    addToContextmenu: ExternalPluginConfig['addToContextmenu'];
+    constructor(params: WindowPluginInitParams<'windy-external-plugin'>, { desktopUI, title, mobileUI, desktopWidth, routerPath, listenToSingleclick, addToContextmenu, url, }: InstalledExternalPluginConfig);
+    getCss(): string;
+}
+export {};