@windycom/plugin-devtools 3.0.0 → 3.0.2

package/types/interfaces.d.ts

@@ -1,46 +1,49 @@
 /**
  * Main Windy interfaces
  */
-import { Weekday } from '@windy/Calendar.d';
+import { Weekday } from '@windy/Calendar';
 import { ExtendedTileParams } from '@windy/DataTiler.d';
 import { FavId } from '@windy/favs';
-import { FullRenderParameters } from '@windy/Layer.d';
+import { Layers } from '@windy/Layer';
 import { Particles } from '@windy/Particles';
-import {
-    PluginsOpenParams,
-    type DetailOpenParams,
-    type PluginsQsParams,
-} from '@windy/plugin-params.d';
+import { PluginOpenEventSource, PluginsOpenParams, PluginsQsParams } from '@windy/plugin-params.d';
 import { Plugins } from '@windy/plugins.d';
+import { DataQuality } from '@windy/Product';
 import { Isolines, Levels, Overlays, PointProducts, Products } from '@windy/rootScope.d';
 import {
     BatteryPreferences,
     CapAlertInfo,
     CapAlertSeverity,
     CapAlertType,
+    CustomAppIcon,
     DetailDisplayType,
     DetailRows,
     Directions,
     GoogleServicesPreferences,
     GpsPreferences,
+    Hours,
     ISODateString,
     LocationPreferences,
     MeteogramLayers,
     MeteogramLevels,
+    Minutes,
     NotificationPreferences,
     NumOrNull,
     NumValue,
+    ParticlesIdent,
     Path,
+    PatternType,
     Pixel,
     Platform,
-    StationOrPoiType,
+    RenderChannels,
+    SubTier,
     Timestamp,
+    TransformFunction,
     WidgetNotificationPreferences,
     WidgetType,
     YearMonthDay,
-    type MigrationResult,
-    type SubTier,
 } from '@windy/types.d';
+import type { PaddingOptions, RequireAtLeastOne } from '@windycom/maplibre-gl';
 
 export interface ExportedObj {
     default?: unknown;
@@ -254,12 +257,11 @@ export interface AlertProps {
 }
 
 export interface WeatherParameters {
-    acRange: Timestamp;
+    acRange: Hours;
     overlay: Overlays;
     level: Levels;
     isolinesType: Isolines;
     isolinesOn: boolean;
-    path: Path;
     product: Products;
 }
 
@@ -325,7 +327,7 @@ export interface Celestial {
     /**
      * TZ offset in hours
      */
-    TZoffset: number;
+    TZoffset: Hours;
 
     /**
      * TZ offset nicely formatted
@@ -335,7 +337,7 @@ export interface Celestial {
     /**
      * TZ offset in minutes
      */
-    TZoffsetMin: number;
+    TZoffsetMin: Minutes;
 
     /**
      * Type of TZ type t..terrestrial, n..nautical
@@ -344,6 +346,7 @@ export interface Celestial {
 
     /**
      * Determines probability if the location is at sea or not as number from 1..0
+     * Unfortunately the number is inverted, so 1 means land, and 0 means sea
      */
     atSea: number;
 
@@ -490,7 +493,6 @@ export interface IsDay {
 /**
  * Weather data object as received from backend (full version)
  */
-
 export interface DataHash extends SummaryDataHash, IsDay {
     /**
      * Day identifier
@@ -510,7 +512,7 @@ export interface DataHash extends SummaryDataHash, IsDay {
     /**
      * Local Time hour for given place in 24h format
      */
-    hour: number[];
+    hour: Hours[];
 
     /**
      * Weather icon identifier
@@ -642,11 +644,85 @@ export type PickDataHashPropsByType<U, Strict = true> = Pick<
                     : never
                 : never
             : U extends DataHash[P]
-            ? P
-            : never;
+              ? P
+              : never;
     }[keyof DataHash]
 >;
 
+export interface AirQDataHash extends IsDay {
+    /**
+     * Timestamp of beginning of segment
+     */
+    ts: Timestamp[];
+
+    /**
+     * Day identifier
+     */
+    day: YearMonthDay[];
+
+    /**
+     * Local Time hour for given place in 24h format
+     */
+    hour: Hours[];
+
+    /**
+     * CAMS airq properties
+     */
+    aqiUs: NumValue[];
+    /**
+     * Concentration of carbon monoxide (CO) in the air.
+     */
+    chemsCosc: NumValue[];
+    /**
+     * Concentration of dust particles (coarse particulate matter) in the air.
+     */
+    chemsDustsm: NumValue[];
+    /**
+     * Concentration of sulfur dioxide (SO2) in the air.
+     */
+    chemsSo2sm: NumValue[];
+    /**
+     * Ground-level ozone (O3) concentration.
+     */
+    go3: NumValue[];
+    /**
+     * Nitrogen dioxide (NO2) concentration.
+     */
+    no2: NumValue[];
+    /**
+     * Particulate matter with a diameter of 10 micrometers or less.
+     */
+    pm10: NumValue[];
+    /**
+     * Particulate matter with a diameter of 2.5 micrometers or less.
+     */
+    pm2p5: NumValue[];
+    /**
+     * Concentration of Alder pollen.
+     */
+    pollenAlder?: NumValue[];
+    /**
+     * Concentration of Birch pollen.
+     */
+    pollenBirch?: NumValue[];
+    /**
+     * Concentration of Grass pollen.
+     */
+    pollenGrass?: NumValue[];
+    /**
+     * Concentration of Mugwort pollen.
+     */
+    pollenMugwort?: NumValue[];
+    /**
+     * Concentration of Olive pollen.
+     */
+    pollenOlive?: NumValue[];
+    /**
+     * Concentration of Ragweed pollen.
+     */
+    pollenRagweed?: NumValue[];
+}
+
 /**
  * node-forecast header object
  */
@@ -774,7 +850,9 @@ export interface WeatherDataNow {
 /**
  * Weather data or Summary Weather data JSON as received from node-forecast
  */
-export interface WeatherDataPayload<T extends DataHash | SummaryDataHash> {
+export interface WeatherDataPayload<
+    T extends DataHash | SummaryDataHash | AirQDataHash = DataHash,
+> {
     header: NodeForecastHeader;
     celestial: Celestial;
     summary: Record<YearMonthDay, SummaryDay>;
@@ -782,90 +860,83 @@ export interface WeatherDataPayload<T extends DataHash | SummaryDataHash> {
     now?: T extends SummaryDataHash ? WeatherDataNow : never;
 }
 
-/**
- * Minimal required options for RendererWeatherTable
- */
-export interface WeatherTableRenderingOptions {
+export interface DetailExtendedLatLon extends LatLon {
     /**
-     * How to display detail
+     * Optional name of the location
      */
-    display: DetailDisplayType;
+    name?: string;
 
     /**
-     * Which rows to render
+     * id of city label that was was clicked on (if any)
      */
-    rows: DetailRows[];
+    cityLabelId?: string;
 
     /**
-     * 1h or 3h step
+     * id of surf spot that was clicked on (if any)
      */
-    step: 1 | 3;
+    surfSpotId?: string;
 
     /**
-     * Width of each table cell (in pixels)
+     * id of pg spot that was clicked on (if any)
      */
-    tdWidth: Pixel;
+    pgSpotId?: string;
 
     /**
-     * How many days to display
+     * id if tide station that was clicked on (if any)
      */
-    days: number;
+    tideStationId?: string;
 
     /**
-     * Size of weather icons
+     * Source, which led to opening the detail
      */
-    iconSize: Pixel;
+    source?: PluginOpenEventSource;
 
     /**
-     * Array of times, when Alert was triggered
+     * Indicates, that the detail was just opened
      */
-    timestamps?: null | Timestamp[];
+    externalOpen?: boolean;
 
     /**
-     * Should we display detail with Z times?
+     * Array of timestamps, that arrived from Alert notification, that should be shown
      */
-    zuluMode?: boolean;
+    timestamps?: Timestamp[] | null;
 
     /**
-     * Shoud we display 12 or 24h format
+     * Timestamp to which we should scroll detail
      */
-    is12hFormat?: boolean;
-
-    /**
-     * Content to put in header of legend
-     */
-    legendHeaderContent?: string;
+    scrollToTimestamp?: Timestamp;
+}
 
+export type WeatherTableRenderingOptions = {
     /**
-     * Surface sea temperature if available
+     * Width of table element
      */
-    sst?: number;
+    tdWidth: number;
 
     /**
-     * Should backend interpolate values for 1h step
+     * Should we use 12h format for time?
      */
-    interpolate?: boolean;
-}
+    is12hFormat?: boolean;
+} & Pick<DetailParams, 'display' | 'step' | 'days'>;
 
 /**
  * Parameters used for displaying detail (point forecast)
  */
-export interface DetailParams extends DetailOpenParams, WeatherTableRenderingOptions {
-    display: DetailDisplayType;
+export interface DetailParams extends DetailExtendedLatLon {
     /**
-     * Which kind of action led to displaying the detail
+     * Optional name of the spot
      */
-    emitter?: 'externalOpen' | 'locationChange';
+    name?: string;
 
     /**
-     * Should we display extended 10hours forecast?
+     * Type of display
      */
-    extended: boolean;
+    display: DetailDisplayType;
 
     /**
-     * Height of background canvas
+     * Should we display extended 10hours forecast?
      */
-    height?: Pixel;
+    extended: boolean;
 
     /**
      * Required point product
@@ -874,37 +945,34 @@ export interface DetailParams extends DetailOpenParams, WeatherTableRenderingOpt
 
     /**
      * Required multiple point products
-     * TODO - split to more interfaces, for multimodel and others
      */
     models?: Products[];
 
-    //source: PluginOpenEventSource;
-
     /**
-     * Type of POI that was clicked to open detail or was contained in URL on page load
+     * Always incrementing synchronization number, that enables
+     * to cancel async tasks, if we will have new version of params
+     * available
      */
-    poiType?: StationOrPoiType;
+    syncCounter: number;
 
     /**
-     * POI id that was clicked to open detail or was contained in URL on page load
+     * Which rows to render
      */
-    id?: string;
+    rows: DetailRows[];
 
     /**
-     * height of temperature background canvas
+     * 1h or 3h step
      */
-    tempBgH?: Pixel;
+    step: 1 | 3;
 
     /**
-     * Always incrementing synchronization number, that enables
-     * to cancel async tasks, if we will have new version of params
-     * available
+     * How many days to display
      */
-    syncCounter: number;
+    days: number;
 }
 
 /**
- * Multimple weather models loaded by multiLoad.ts
+ * Multiple weather models loaded by multiLoad.ts
  */
 export interface MultiLoadPayload {
     model: PointProducts;
@@ -1020,23 +1088,32 @@ export interface BillingPlugin {
 export interface TimeLocal {
     weekday: Weekday;
     day: string;
-    month: string;
-    year: string;
+    month?: string;
+    year?: string;
     /** '09' */
     hour: string;
 }
 
 export interface CapAlertHeadline {
+    id: string;
     start: Timestamp;
     end: Timestamp;
     type: CapAlertType;
     severity: CapAlertSeverity;
-    headline: string;
+    headline?: string;
     event: string;
     startLocal: TimeLocal;
     endLocal: TimeLocal;
 }
 
+export interface ExtendedCapLine extends CapAlertHeadline {
+    id: string;
+    startDay: string;
+    endDay: string;
+    shortenedEvent: string;
+    color: string;
+}
+
 export interface CapAlertData extends CapAlertHeadline {
     id: string;
     ident: string;
@@ -1150,12 +1227,16 @@ export interface WindyServicePlugin {
     getGoogleServicesAvailability: () => Promise<GoogleServicesPreferences>;
     getWidgetNotificationPermissions: () => Promise<WidgetNotificationPreferences>;
     openWidgetNotificationSettings: () => Promise<void>;
-    getBackgroundLocationPermission: () => Promise<GpsPreferences>;
+    getBackgroundLocationPermission: () => Promise<BatteryPreferences>;
+    getBatteryStatus: () => Promise<BatteryPreferences>;
     openBackgroundLocationSettings: () => Promise<void>;
     logError: (arg: { moduleName: string; msg: string; error?: string }) => Promise<void>;
     getId: () => Promise<{ identifier: string }>;
     getAppsflyerCredentials: () => Promise<{ devKey: string | undefined; appId: string }>;
     addWidget: (arg: WidgetType) => Promise<void>;
+    isGarminAppInstalled: () => Promise<{ value: boolean }>;
+    setAppIcon(arg: { iconName: CustomAppIcon }): Promise<void>;
+    getAppIcon(): Promise<{ iconName: CustomAppIcon | null }>;
 }
 
 export interface NotificationLocationInfo {
@@ -1173,6 +1254,29 @@ export interface WindyNotificationLocationPlugin {
     useCustomLocation: (arg: LatLon) => Promise<void>;
 }
 
+export interface WindyLocalNotificationPlugin {
+    schedule: (arg: {
+        title: string;
+        subtitle: string | null;
+        body: string;
+        timeInterval: number; // in seconds
+    }) => Promise<{ id: string }>; // id of the scheduled notification
+    cancel: (arg: { id: string }) => Promise<void>;
+    cancelAll: () => Promise<void>;
+    getPending: () => Promise<{ pending: string[] }>; // array of ids of pending notifications
+    registerRetentionNotification: (arg: {
+        title: string;
+        subtitle: string | null;
+        body: string;
+        marketingId: string | null; // is used for analytics
+        deepLink: string | null; // deepLink to open when the notification is clicked
+        showAfter: number; // in seconds
+        showUntil: number; // in seconds
+    }) => Promise<{ status: 'notStarted' | 'scheduled' | 'delivered' | 'opened' | 'expired' }>; // status of the registration
+    sendTestRetentionNotification: () => Promise<{ id: string }>;
+    resetRetentionNotification: () => Promise<void>;
+}
+
 /**
  * A migration tool for transferring old Web View local storage to a new location.
  * This migration is necessary when the hostname is changed in the native Capacitor configuration.
@@ -1215,10 +1319,6 @@ export interface WindyMigrationPlugin {
      * Marks migration as completed and restart WebView from origin
      */
     markMigrationCompleted: (opts: { reload: boolean }) => Promise<void>;
-    /**
-     * Returns migration status flag - either migrationNotPerformed or migratingData
-     */
-    getMigrationStatus: () => Promise<MigrationResult>;
     /**
      * Sends migration data to native layer
      */
@@ -1630,3 +1730,161 @@ interface ClientPatch {
 export interface ActiveStormCountPayload {
     activeStormCount: number;
 }
+
+/**
+ * These properties are passed directly to renderer by enhancing returned params
+ */
+interface RenderParams {
+    /**
+     * Which channels contain tile rendering data
+     */
+    renderFrom?: RenderChannels;
+
+    /**
+     * Not confirmed: Display map as a sea, meaning the sea layers are below surface layers
+     */
+    sea?: boolean;
+
+    /**
+     * Display map as a land, meaning the sea area is hidden with mask
+     */
+    landOnly?: boolean;
+
+    /**
+     * Identifier of particle type
+     */
+    particlesIdent?: ParticlesIdent;
+
+    /**
+     * Uses two instances of Color for rendering
+     */
+    isMultiColor?: boolean;
+
+    /**
+     * Should green channel be interpolated to nearest discreet value
+     */
+    interpolateNearestG?: boolean;
+
+    /**
+     * Name of interpolator method
+     */
+    interpolate?: 'interpolateOverlay' | 'interpolateWaves';
+
+    /**
+     * Used patternator
+     */
+    pattern?: PatternType;
+}
+
+/**
+ * Set of params required to render the layer
+ */
+interface FullRenderParameters extends WeatherParameters, RenderParams {
+    layer: Layers;
+    JPGtransparency?: boolean;
+    PNGtransparency?: boolean;
+    transformR?: TransformFunction;
+    transformG?: TransformFunction;
+    transformB?: TransformFunction;
+    directory: string;
+
+    /**
+     * Specify zoom of mercator data tiles in dependence of map zoom
+     */
+    dataQuality?: DataQuality;
+    maxTileZoom?: {
+        free: number;
+        premium: number;
+    };
+
+    /**
+     * bump data quality by 1 level for particular overlay/layer
+     */
+    upgradeDataQuality?: boolean;
+
+    /**
+     * Force to select particular zoom of data tiles
+     */
+    dataTilesZoom?: number;
+
+    level: Levels;
+    refTime: Path;
+    fullPath: string;
+    path: Path;
+
+    /**
+     * Optional accumulation range in hours
+     */
+    acRangeInHours?: number;
+
+    fileSuffix?: 'png' | 'jpg' | 'json';
+}
+
+/*
+ * Cap alert was slided from left to right on startup screen
+ */
+export interface CapAlertSlided {
+    id: string;
+    expire: Timestamp;
+}
+
+/**
+ * Handy payload or reusable data that helps to render Forecast Table
+ */
+export interface WeatherTableRenderingData<T extends DataHash | AirQDataHash = DataHash> {
+    /**
+     * Day identifiers, that were used in data object (above)
+     */
+    usedDays: YearMonthDay[];
+
+    /**
+     * Loaded data.data (modified later by splicing data arrays)
+     */
+    data: T;
+
+    /**
+     * Type of the data above
+     */
+    dataType: 'forecast' | 'airq';
+
+    /**
+     * Length of used forecast as a umber of TD segments
+     */
+    dataLength: number;
+
+    /**
+     * Start of timeline
+     */
+    start: Timestamp;
+    end: Timestamp;
+
+    tsWidth: Timestamp;
+    pxWidth: Pixel;
+    px2ts: number;
+    tdWidth: Pixel;
+
+    /**
+     * UTC offset in hours
+     */
+    utcOffset: Hours;
+
+    /**
+     * UTC offset in minutes
+     */
+    utcOffsetMinutes: Minutes;
+
+    /**
+     * Indicates that data payload has waves
+     */
+    hasWaves: boolean;
+
+    /**
+     * Summary of days used
+     */
+    summary: Record<YearMonthDay, SummaryDay>;
+}
+
+export interface SimplifiedGetBoundsOptions {
+    animate?: boolean;
+    padding?: RequireAtLeastOne<PaddingOptions>;
+}