@windycom/plugin-devtools 1.0.1

package/types/WindowPlugin.d.ts

@@ -0,0 +1,171 @@
+import { Plugin } from '@windy/Plugin';
+import { Window } from '@windy/Window';
+import type { PluginInitParams } from '@windy/Plugin';
+import type { WindowInitParams } from '@windy/Window';
+import type { PluginOpeningOptions, WindowClosingOptions } from '@windy/interfaces.d';
+import type { InterpolatorFactory } from '@windy/interpolator';
+import type { PluginsOpenParams, PluginsQsParams } from '@windy/plugin-params.d';
+import type { BottomTagPlugins, SveltePanePlugins, SveltePlugins, TagPlugins } from '@windy/plugins.d';
+import type { LoadedTranslations } from '@windy/trans.d';
+import type { ParsedQueryString } from '@windy/queryString';
+import type { ListeningPriority } from '@windy/singleclick.d';
+export interface WindowPlugins extends TagPlugins, SveltePlugins, SveltePanePlugins, BottomTagPlugins {
+}
+/** Allowed params to WindowPlugin constructor (private and protected props are omited by default) */
+export type WindowPluginInitParams<P extends keyof WindowPlugins> = PluginInitParams<P> & Omit<WindowInitParams, 'ident' | 'html'> & Partial<Omit<WindowPlugin<P>, 'open' | 'load' | 'refs' | 'node' | 'domEl'>>;
+export declare abstract class WindowPlugin<P extends keyof WindowPlugins> extends Plugin<P> {
+    /**
+     * Instance of Window, that handles closing button, mounting etc
+     */
+    window?: Window;
+    /**
+     * Is plugin mounted
+     */
+    protected isMounted: boolean;
+    /**
+     * ID of CSS style
+     */
+    protected cssID: `plugin-css-${string}`;
+    /**
+     * Was CSS inserted into the DOM
+     */
+    protected cssInserted: boolean;
+    ident: P;
+    plugin: WPluginModules[`@plugins/${P}`] & AdditionalPluginAssets;
+    /**
+     * URL title to be associated with plugin
+     */
+    title?: keyof LoadedTranslations | string;
+    /**
+     * Attaches mobile bottom slider to the tag
+     */
+    addMobileSlider: boolean;
+    /**
+     * Simple router, that matches URL and opens plugin
+     *
+     * Use either simple expressJs style string or RegExp for more complex matching
+     * with named groups
+     *
+     * @example /path/:lat/:lon
+     * @example /path-with-optional-param/:param?
+     * @example /^(distance|rplanner)/(?<tab>\S+)$/  ... for complex matches
+     */
+    router?: RegExp | `/${string}`;
+    /**
+     * If router is typeof RegExp, we need some string, that will enable us to construct
+     * URL from params, so basically this string (which should have expressJs style syntax)
+     * is for that purpose.
+     *
+     * Of course, if your router is typeof string, you do not need this property at all
+     *
+     * @example /path/:lat/:lon
+     */
+    path?: `/${string}`;
+    /**
+     * Prepends URL with SEO friendly string (e.g. /-Nastveni) in local language
+     * works only with defaultLocationAndTitle
+     */
+    useSEOurl: boolean;
+    /**
+     * Closes plugin when swiping down (works only on mobile
+     * in plugins with BottomSlide)
+     */
+    closeOnSwipeDown: boolean;
+    /**
+     * Closes plugin when swiping to the right
+     */
+    closesOnSwipeRight: boolean;
+    /**
+     * Android stuff: does not close plugin on back button tap
+     */
+    noCloseOnBackButton?: boolean;
+    interpolator?: InterpolatorFactory;
+    /**
+     * 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;
+    /**
+     * Opening of this plugin logs analytical data to GA (if allowed by user)
+     * By default is set to true
+     */
+    logUsage: boolean;
+    /**
+     * Disable opening & closing animation
+     */
+    noAnimation?: boolean;
+    /**
+     * Class name applied to Window element
+     */
+    className?: string;
+    /**
+     * 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;
+    /**
+     * Indicates, that this plugin wants to recieve singleclick map events
+     * when opened and at which priority
+     */
+    singleclickPriority: ListeningPriority | undefined;
+    constructor(params: WindowPluginInitParams<P>);
+    /**
+     * Check if plugin is loaded and decides if load or open. Params are passed to onopen fun
+     */
+    open({ params, disableOpeningAnimation, qs }?: PluginOpeningOptions<P>): Promise<void | boolean>;
+    close(opts?: WindowClosingOptions): void;
+    /**
+     * Displays URL & tile
+     */
+    displayURLAndTitle(params?: PluginsOpenParams[P]): void;
+    /**
+     * Ready to be overloaded: Will be called after open
+     */
+    onopen(params?: PluginsOpenParams[P], _qs?: PluginsQsParams[P]): void;
+    /**
+     * Ready to be overloaded: Will be called before unmounting
+     */
+    ondestroy(opts?: WindowClosingOptions): void;
+    /**
+     * Ready to be overloaded: Will be called before plugin is loaded, sync action called immediatelly after rqstOpen is fired
+     */
+    beforeLoad(..._args: unknown[]): void;
+    /**
+     * Called by router when URL matches plugin's router (feel free to overload it)
+     */
+    onRouteMatch({ groups }: string[] & {
+        groups: PluginsOpenParams[P];
+    }, _qs?: ParsedQueryString): PluginsOpenParams[P] | null;
+    /**
+     * When called with params, it will create valid URL for plugin
+     * as defined in router property.
+     *
+     * This is basically reverse operation of parsing URL in router
+     */
+    getPluginUrl(params?: PluginsOpenParams[P]): string;
+    get node(): HTMLDivElement;
+    createWindow(): Window;
+    getCss(): string | undefined;
+    protected initProperties(): void;
+    protected unmount(): void;
+    /**
+     * Append CSS styles
+     */
+    protected mountCss(): void;
+    /**
+     * Mounting the module
+     */
+    protected mount(): void;
+    /**
+     * After module is being mounted and fully in HTML DOM
+     */
+    protected onmounted(): void;
+}

package/types/baseMap.d.ts

@@ -0,0 +1,10 @@
+export type MapTilesKeys = 'graymap' | 'landmaskmap' | 'simplemap' | 'graymapPatch5' | 'graymapPatch11' | 'simplemapPatch5' | 'simplemapPatch9' | 'sznmap' | 'winter' | 'satLocal' | 'sat';
+/**
+ * Leaflet instance of actually used base layer
+ */
+export declare let baseLayer: L.GridLayer;
+/**
+ * Return just record of different map tilesURLs that we use as basemap
+ */
+export declare const mapTilesRecord: (patchType?: string | null) => Record<MapTilesKeys, string>;
+export declare function updateBasemap(map: L.Map): L.GridLayer;

package/types/broadcast.d.ts

@@ -0,0 +1,14 @@
+/**
+ * # @windy/broadcast
+ *
+ *  Major Windy's event emitter (instance of class {@link Evented.Evented | Evented }), used for announcing the most important events.
+ *
+ * @module broadcast
+ *
+ */
+import type { Broadcast } from './broadcast.d';
+declare const bcast: Broadcast;
+/**
+ * Major broadcast service for sending events to other parts of Windy.
+ */
+export default bcast;

package/types/cityLabels.d.ts

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

package/types/cloudSync.d.ts

@@ -0,0 +1,12 @@
+import '@windy/colors';
+import '@windy/metrics';
+/**
+ * Store all user settings into cloud.
+ *
+ * @returns True if sending data to cloud passed, false otherwise.
+ */
+export declare function storeSettings(): Promise<boolean>;
+/**
+ * Loads settings from a cloud and merge them
+ */
+export declare function loadAndMergeSettingFromCloud(): Promise<void>;

package/types/colors.d.ts

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

package/types/connection.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Connection is lost, user is offline
+ */
+export declare function testNetworkConnection(): void;

package/types/css.d.ts

@@ -0,0 +1,25 @@
+/** Adjust CSS var, optionaly a condition if current value is in selected range */
+export declare const adjustCssValue: (ident: string, adjustPx: number, minValue?: number, maxValue?: number) => void;
+/**
+ * Toglles CSS on element if trigger is truish
+ *
+ * @param el DOM element
+ * @param condition if truish adds class otherwire romeves it
+ * @param cssClass CSS class
+ */
+export declare const toggleClass: <T extends HTMLElement>(el: T, condition: boolean, cssClass: string) => void;
+/**
+ * Finds a particular class in classlist of document body or any DOM el
+ * and replaces it. For example replaces class zoom-6 with zoom-5 in body
+ * if new newClass is zoom-5
+ * Usage: _.replaceClass(/pois-\S+/,'pois-' + requiredPoi)
+ *
+ * @param regExp RegExp
+ * @param newClass New class
+ * @param el HTML element
+ */
+export declare const replaceClass: (regExp: RegExp, newClass: string, el?: HTMLElement) => void;
+/**
+ * The attach point for default plugins.
+ */
+export declare const defaultPluginsAttachPoint = "[data-plugin=\"plugins\"]";

package/types/dataLoader.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Loader service for new rendering engine
+ */
+import type { TransformFunction } from '@windy/Layer.d';
+import type { TileParams } from '@windy/Renderer.d';
+export declare class DataTile {
+    url: string;
+    status: 'undefined' | 'loaded' | 'loading' | 'failed';
+    data: ImageData['data'] | null;
+    promise?: Promise<this>;
+    headerPars?: number[];
+    x: number;
+    y: number;
+    z: number;
+    decodeR: TransformFunction;
+    decodeG: TransformFunction;
+    decodeB: TransformFunction;
+    transformR: TransformFunction | null;
+    transformG: TransformFunction | null;
+    transformB: TransformFunction | null;
+    constructor(url: string, tile: TileParams);
+    load(): Promise<this>;
+}
+export declare const dataLoader: {
+    loadTile: (tileParams: TileParams) => Promise<DataTile>;
+};

package/types/dataSpecifications.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Defines allowed values for data store. Do not access these values directly,
+ * since format can be changed. Always use method of `store`.
+ *
+ * @module dataSpecifications
+ */
+import type { DataSpecifications } from '@windy/dataSpecifications.d';
+/**
+ * Mother of all settings. All the user setting (except for large data structures) should go here
+ */
+declare const ds: DataSpecifications;
+export default ds;

package/types/detectDevice.d.ts

@@ -0,0 +1,6 @@
+import type { Device, Platform } from '@windy/types.d';
+export declare const platform: Platform;
+/**
+ * The value of current device type (mobile, tablet, desktop)
+ */
+export declare const device: Device;

package/types/device.d.ts

@@ -0,0 +1,19 @@
+import type { DeviceInfo } from '@capacitor/device';
+/**
+ * Returns platform unique persistent id for Android and iOS, or semi-persistent generated random id for desktop
+ *
+ * @returns Platform unique persistent deviceId (iOS, Android) or generated id for desktop (stored in localstorage, so it is semi-persistent)
+ */
+export declare const getDeviceID: () => string;
+/**
+ * Returns generated semi-persistent random id
+ *
+ * @returns Generated random id (stored in localstorage, so it is semi-persistent)
+ */
+export declare const getVirtualDeviceID: () => string;
+/**
+ * Returns device info if any exist
+ *
+ * @returns Device info returned by Capacitor, null for desktop or if anything failed
+ */
+export declare const getDeviceInfo: () => DeviceInfo | null;

package/types/deviceLogging.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deactivates current device from push notif backend
+ *
+ * @returns void
+ */
+export declare const deactivateCurrentDevice: () => Promise<void>;
+/**
+ * Saves info regarding current device to localStorage and to backend
+ *
+ * @param registrationHash Push notification registration hash
+ * @returns
+ */
+export declare const saveCurrentDevice: (registrationHash: string | null) => void;

package/types/fetch.d.ts

@@ -0,0 +1,88 @@
+import type { CityForecastData } from '@windy/LabelsLayer.d';
+import type { DataHash, LatLon, MeteogramDataPayload, WeatherDataPayload } from '@windy/interfaces.d';
+import type { Pois, Products } from '@windy/rootScope.d';
+import type { ExtendedStationType } from '@windy/types';
+import type { HttpOptions, HttpPayload } from './http.d';
+interface LatLonStep extends LatLon {
+    step?: number;
+    interpolate?: boolean;
+}
+export declare const getReftimeIso: (model: Products) => any;
+/**
+ * Returns URL for webcam detail by id
+ *
+ * @param id Webcam id
+ * @returns URL for getting the webcam
+ */
+export declare const getWebcamDetailUrl: (id: string | number) => string;
+/**
+ * Returns URL for webcam list nearby lat and lon
+ *
+ * @param latLon Object with `lat` and `lon` properties
+ * @returns URL for getting list of webcams nearby lat and lon
+ */
+export declare const getWebcamsListUrl: <T extends LatLon & {
+    limit?: number;
+}>({ lat, lon, limit, }: T) => string;
+/**
+ * Returns URL for webcam archive by id
+ *
+ * @param id Webcam id
+ * @returns URL for getting webcam archive
+ */
+export declare const getWebcamArchiveUrl: (id: string | number, hourly?: boolean) => string;
+/**
+ * Returns URL for searching webcam views using Google maps places
+ *
+ * @param {string} textQuery search query
+ * @param {LatLon} [latLon] circle center coordinates
+ * @returns {string} URL for searching webcam views
+ */
+export declare const getSearchWebcamViewsUrl: (textQuery: string, latLon?: LatLon) => string;
+/**
+ * Returns URL for webcam metric. It increases counter for the ID on backend.
+ *
+ * @param id Webcam id
+ * @returns URL for ping webcam metrics
+ */
+export declare const getWebcamMetricsUrl: (id: string | number) => string;
+/**
+ * Returns URL for getting point forecast
+ */
+export declare const getPointForecastData: <T extends LatLonStep>(model: Products, { lat, lon, step, interpolate }: T, source: string, qs?: string, options?: HttpOptions) => Promise<HttpPayload<WeatherDataPayload<DataHash>>>;
+/**
+ * Returns URL for getting meteogram forecast
+ */
+export declare const getMeteogramForecastData: <T extends LatLonStep>(model: Products, { lat, lon, step }: T, options?: HttpOptions) => Promise<HttpPayload<MeteogramDataPayload>>;
+/**
+ * Returns URL for getting archive forecast
+ */
+export declare const getArchiveForecastData: <T extends LatLon>(model: Products, { lat, lon }: T, source: string, qs?: string, options?: HttpOptions) => Promise<HttpPayload<WeatherDataPayload<DataHash>>>;
+/**
+ * Returns URL for getting citytile forecast
+ *
+ * @param model Forecast model
+ * @param frag Mercator frag in {z}/{x}/{y} format
+ * @param options HTTP options
+ * @returns URL for getting citytile forecast
+ */
+export declare const getCitytileData: (model: Products, frag: string, options?: HttpOptions) => Promise<HttpPayload<CityForecastData> | null>;
+/**
+ * Returns URL for nearest POI items (stations, airQ, ...)
+ * @param param0
+ * @returns
+ */
+export declare const getNearestPoiItemsUrl: (type: Pois | 'stations', { lat, lon }: LatLon) => string;
+/**
+ * Returns URL for tide forecast
+ */
+export declare const getTideForecastUrl: <T extends LatLonStep>({ lat, lon }: T) => string;
+/**
+ * Returns URL for tide POI
+ */
+export declare const getTidePoiUrl: (id: string) => string;
+/**
+ * Get observations URL
+ */
+export declare const getObservationsUrl: (type: ExtendedStationType, id: string, daysFrom: number, daysTo?: number) => string;
+export {};

package/types/format.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @module format
+ *
+ * Various formatting utils based on user language and settings
+ */
+import type { DirectionFunction, HowOldOptions, TimeFormatFunction } from '@windy/format.d';
+import type { Timestamp } from '@windy/types';
+/**
+ * Returns function for displaying hours (either 12,24h format) on a basis of locale store of a browser
+ * US, UK, PH, CA, AU, NZ, IN, EG, SA, CO, PK, MY - AM,PM format
+ *
+ * @returns Time format function
+ */
+export declare const getHoursFunction: () => TimeFormatFunction;
+/**
+ * Returns UTC formated hours, e.g. '09:00Z' or '18:00Z'
+ *
+ * @param ts Timestamp
+ * @returns Formated UTC hours in a format '09:00Z' or '18:00Z'
+ */
+export declare const hourUTC: (ts: number) => string;
+/**
+ * Returns UTC formated hours and minutes, e.g. '09:22Z' or '18:57Z'
+ *
+ * @param ts Timestamp
+ * @returns Formated UTC hours and minutes in a format '09:22Z' or '18:57Z'
+ */
+export declare const hourMinuteUTC: (ts: number) => string;
+/**
+ * => Format numbers with thousands delimiters, e.g. '10 000'
+ *
+ * @param amount Number to format
+ * @returns Formated number with thousands delimiter, e.g. '10 000'. Empty string if nothing is passed.
+ */
+export declare const thousands: (amount?: string | number | null) => string;
+/**
+ * Returns direction formatting function based on user's settings. E.g. 'N', 'NE', ... or '123°'
+ *
+ * @returns Format function to convert number into 'N', 'NE', ... strings or '123°' strings
+ */
+export declare const getDirFunction: () => DirectionFunction;
+/**
+ * Returns CSS class name based on how obsolete data are
+ *
+ * @param updatedSecAgo Last update in seconds ago
+ * @param limitInMins Limit in minutes to consider update obsolete (default: 30)
+ * @returns fresh, normal (30% - 100% of limit) or obsolete for > limit
+ */
+export declare const obsoleteClass: (updatedSecAgo: number, limitInMins?: number) => 'fresh' | 'normal' | 'obsolete';
+/**
+ * Returns string declaring when some event happened in the past, e.g. '5 days', '5 days ago', '4 hours 15 minutes' etc...
+ *
+ * @param options Options for output
+ * @returns '5 days', '5 days ago', '4 hours 15 minutes' etc... Empty string if any error occurs
+ */
+export declare const howOld: (options: HowOldOptions) => string;
+export declare const countdown: (ts: Timestamp, options?: {
+    showSeconds?: boolean;
+}) => string;
+/**
+ * Converts lat,lon numbers to human friendly Degrees, Minutes and Seconds format, e.g. N49°9'21", E14°7'30"
+ *
+ * @param lat Latitude
+ * @param lon Longitude
+ * @returns DMS format of lat,lon, e.g. N49°9'21", E14°7'30"
+ */
+export declare const DD2DMS: (lat: number, lon: number) => string;
+/**
+ * Get standard UTC offset string from number, e.g. -02:00, +08:00 etc.
+ *
+ * @param offsetInHours Offset of hours (could be negative as well)
+ * @returns UTC offset string, e.g. "-02:00", "+08:00" etc.
+ */
+export declare const utcOffsetStr: (offsetInHours: number) => string;
+/**
+ * Format URL for purpose of SEO (slashes / are preserved)
+ *
+ * @param str String to format
+ * @returns Cleaned-up string from whitespaces and special chars (slashes / are preserved)
+ */
+export declare const seoUrlString: (str: string) => string;
+/**
+ * Format string for purpose of SEO
+ *
+ * @param str String to format
+ * @returns Cleaned-up string from whitespaces and special chars
+ */
+export declare const seoString: (str: string) => string;
+/**
+ * Get lang prefix for URL SEO purposes. English is default without any prefix
+ *
+ * @param lang Language
+ * @returns URL prefix with lang, e.g. `cs/` or `es/`. Empty string is returned for default lang (English)
+ */
+export declare const seoLang: (lang: string) => string;
+/**
+ * Animates increasing numbers into HTML element
+ *
+ * @param viewcount Number to show at animation end
+ * @param el HTML element where animate counting and show the final number
+ */
+export declare const animateViews: (viewcount: number, el: HTMLElement) => void;

package/types/ga.d.ts

@@ -0,0 +1 @@
+export declare const pageview: (page: string) => void;

package/types/geolocation.d.ts

@@ -0,0 +1,30 @@
+import '@windy/router';
+import type { GeolocationInfo, HomeLocation } from '@windy/interfaces.d';
+import type { PositionOptions } from '@capacitor/geolocation';
+/**
+ * Returns either GPS or IP location whichever is newer
+ *
+ * @returns Location got from GPS or IP, the newer is prefered
+ */
+export declare const getMyLatestPos: () => GeolocationInfo;
+/**
+ * Returns promise on GPS based location with GeoIP location as a fallback
+ *
+ * @param options Optionally custom options passed to Capacitor geolocation plugin
+ * @returns Geolocation info from GPS, GeoIP as a fallback
+ */
+export declare const getGPSlocation: (options?: PositionOptions) => Promise<GeolocationInfo>;
+/**
+ * Returns fallback name created from lat,lon if nothing else can be used
+ *
+ * @param lat Latitude
+ * @param lon Longitude
+ * @returns Fallback location name in a format "49.15, 14.18"
+ */
+export declare const getFallbackName: (lat: number | string, lon: number | string) => string;
+/**
+ * Gets accurate home location. Cannot be used in map initialization beacause it is async.
+ *
+ * @param cb Callback function to call when location is get. Location info object is passed as a callback argument
+ */
+export declare const getHomeLocation: (cb: (loc: GeolocationInfo | HomeLocation) => void) => void;