@windycom/plugin-devtools 3.0.1 → 3.0.3

package/types/client/Metric.d.ts

@@ -1,7 +1,6 @@
 import type { Color } from './d.ts.files/Color';
-import type { RGBString } from './d.ts.files/Color.d';
-import type { ConvObj, Legend, LegendDescription, LegendLines, MetricIdent, MetricInitParams, MetricItem, MetricKey } from './d.ts.files/Metric.d';
-import type { HTMLString, NumValue, LoadedTranslations } from './d.ts.files/types.d';
+import type { ConvObj, Legend, LegendDescription, LegendLines, MetricIdent, MetricInitParams, MetricItem } from './d.ts.files/Metric.d';
+import type { NumValue, LoadedTranslations, RGBString } from './d.ts.files/types.d';
 export declare const rtrnSelf: (x: NumValue) => NumValue;
 /**
  * # @windy/Metric
@@ -13,26 +12,23 @@ export declare const rtrnSelf: (x: NumValue) => NumValue;
  * Never ever, change users selected metric without their consent.
  */
 export declare abstract class Metric<T extends string | number = string | number> {
-    /**
-     * Identifies metric
-     */
-    ident: MetricIdent;
     /**
      * Store key
      */
-    key: MetricKey;
+    private key;
     /**
-     * Actually selected metric
+     * Keeps cohesion in between multiple metric instances. For example setting `in`
+     * in rain will set `in` in snow also
      */
-    metric: MetricItem;
+    cohesion?: {
+        [ident in MetricIdent]?: {
+            [unit in MetricItem]?: MetricItem;
+        };
+    };
     /**
      * Conversion functions
      */
     conv: ConvObj;
-    /**
-     * Backward conversion functions
-     */
-    backConv?: ConvObj;
     /**
      * number ' ' metric separator
      */
@@ -47,22 +43,25 @@ export declare abstract class Metric<T extends string | number = string | number
      */
     nativeSync: boolean;
     /**
-     * Legend description
+     * Identifies metric
      */
-    description: LegendDescription;
+    ident: MetricIdent;
+    /**
+     * Backward conversion functions
+     */
+    backConv?: ConvObj;
     /**
      * Array defining how the legend will look like
      */
     lines: LegendLines;
     /**
-     * Keeps cohesion in between multiple metric instances. For example setting `in`
-     * in rain will set `in` in snow also
+     * Actually selected metric
      */
-    cohesion?: {
-        [ident in MetricIdent]?: {
-            [unit in MetricItem]?: MetricItem;
-        };
-    };
+    metric: MetricItem;
+    /**
+     * Legend description
+     */
+    description: LegendDescription;
     /**
      * Some metrics have discrete legend.
      * If so, these labels define it, where NumValue is numerical value, to grab color from color table
@@ -81,18 +80,7 @@ export declare abstract class Metric<T extends string | number = string | number
          */
         labels: [keyof LoadedTranslations, RGBString][];
     };
-    /**
-     * Colors used to render discrete legend
-     * @param params
-     */
     constructor(params: MetricInitParams);
-    /**
-     * Returns metric value
-     */
-    getMetric(): MetricItem;
-    onMetricChanged(metric: MetricItem): void;
-    getDefault(): MetricItem;
-    setDefault(): void;
     /**
      * get value + label on a basis of user selected metric
      */
@@ -106,7 +94,7 @@ export declare abstract class Metric<T extends string | number = string | number
      */
     abstract convertNumber(value: NumValue, forcedPrecision?: number, metric?: MetricItem): T;
     /**
-     * List all avail metrics
+     * List all avail units
      */
     listMetrics(): MetricItem[];
     /**
@@ -116,21 +104,18 @@ export declare abstract class Metric<T extends string | number = string | number
     /**
      * Stores required metric into storage
      */
-    setMetric(metric: MetricItem, uiIdent?: string): void;
+    setMetric(metric: MetricItem, ignoreCohesion?: boolean): void;
     /**
      * Cycles throu different metrics (for example after clicking on a legend)
      */
-    cycleMetric(uiIdent?: string): void;
-    static getGradientLegend: (col: Color | undefined, legend: Legend, metric: MetricItem) => {
-        background: string;
-        content: HTMLString;
-    } | null;
+    cycleMetric(): void;
     /** color object is required for classic gradient metrics, discrete ones do not need it as colors are hardcoded for them */
     renderLegend(col: Color | undefined, el: HTMLDivElement, legend: Legend): void;
-    renderDiscreteLegend(): {
-        background: '';
-        content: HTMLString;
-    };
     protected initProperties(): void;
-    private _createKey;
+    private onMetricChanged;
+    private getDefault;
+    private setDefault;
+    private getGradientLegend;
+    private renderDiscreteLegend;
+    private createKey;
 }

package/types/client/MetricClasses.d.ts

@@ -31,7 +31,7 @@ export declare class SatelliteMetric extends NumberedMetric {
      * Dynamic update from minifest/info.json
      * @param pars various pars depending on concrete instance
      */
-    updateLines(pars: [number, number], radarEnabled?: boolean): void;
+    updateLines(pars: [number, number], _radarEnabled?: boolean): void;
 }
 export declare class PrecipMetric extends NumberedMetric {
     initProperties(): void;

package/types/client/Overlay.d.ts

@@ -1,13 +1,11 @@
-import type { Layer } from '@windy/Layer';
-import type { LayerMetricType, Layers } from '@windy/Layer.d';
+import type { LayerMetricType, Layers, Layer } from '@windy/Layer';
 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/interpolatorTypes';
-import type { LoadedTranslations, HTMLString } from '@windy/types';
-import type { RGBAString } from '@windy/Color.d';
-export type UsedOverlays = Overlays | 'swell' | 'satelliteIRBT';
+import type { LoadedTranslations, HTMLString, RGBString } from '@windy/types';
+export type UsedOverlays = Overlays | 'swell';
 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;
@@ -112,7 +110,7 @@ export declare class Overlay<I extends Overlays = Overlays, M extends I extends
      * Optional promo badge to be displayed in GUI
      */
     promoBadge?: string;
-    promoBadgeColor?: RGBAString;
+    promoBadgeColor?: RGBString;
     /**
      * Optional menu image thumbnail
      */
@@ -146,11 +144,6 @@ export declare class Overlay<I extends Overlays = Overlays, M extends I extends
      * 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
@@ -159,7 +152,7 @@ export declare class Overlay<I extends Overlays = Overlays, M extends I extends
     /**
      * Just proxy to the Metric's metric property
      */
-    get metric(): import("./Metric").MetricItem | "";
+    get metric(): "" | import("./Metric").MetricItem;
     protected initProperties(): void;
 }
 export {};

package/types/client/OverlayClasses.d.ts

@@ -31,3 +31,11 @@ export declare class CloudsOverlay<I extends Overlays = Overlays> extends Overla
     hidePickerElevation: boolean;
     createPickerHTML(values: RGBNumValues): string;
 }
+export declare class AqiOverlay<I extends Overlays = Overlays> extends Overlay<I> {
+    hidePickerElevation: boolean;
+    labels: {
+        [value: number]: keyof LoadedTranslations;
+    };
+    getAirQLabel(aqi: number): string;
+    createPickerHTML(values: RGBNumValues): string;
+}

package/types/client/Particles.d.ts

@@ -1,4 +1,4 @@
-import type { RGBAString, RGBA } from '@windy/Color.d';
+import type { RGBAString, RGBA } from '@windy/types.d';
 import type { Levels } from '@windy/rootScope.d';
 import type { ExtendedRenderParams } from '@windy/interfaces.d';
 import type { CustomParticles } from '@windy/dataSpecifications.d';

package/types/client/Product.d.ts

@@ -1,50 +1,26 @@
 import { Calendar } from '@windy/Calendar';
-import * as http from '@windy/http';
-import type { MinifestObject } from '@windy/Calendar.d';
-import type { Layers } from '@windy/Layer.d';
+import { type LeafletGlMap } from '@leafletGl';
+import type { MinifestObject } from '@windy/Calendar';
+import type { Layers } from '@windy/Layer';
 import type { LatLon } from '@windy/interfaces';
 import type { Isolines, Levels, Overlays, Products } from '@windy/rootScope.d';
-import type { ISODateString, ProductCategory, ProductIdent, Timestamp, YYYYMMDDHH } from '@windy/types';
+import type { ISODateString, ProductCategory, ProductIdent, Timestamp, TimeRangeMs, Path, Minutes } from '@windy/types';
 export type DataQuality = 'normal' | 'high' | 'low' | 'ultra' | 'extreme';
 export type FileSuffix = 'png' | 'jpg' | 'webp';
-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' | 'preferredProduct' | 'pathGenerator' | 'isolines' | 'directory' | 'category' | 'modelIdent' | 'intervalPremium' | 'server' | 'metadataServer' | 'modelResolution' | 'levels' | 'levelsOverride' | 'logo' | 'preferredWaveProduct' | 'preferredAirProduct' | 'hasAccumulations' | 'freeProduct' | 'hideProductSwitch'>> & {
+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' | 'preferredProduct' | 'isolines' | 'directory' | 'category' | 'modelIdent' | 'intervalPremium' | 'server' | 'modelResolution' | 'levels' | 'levelsOverride' | 'logo' | 'preferredWaveProduct' | 'preferredAirProduct' | 'hasAccumulations' | 'hasMinifest' | 'freeProduct' | 'hideProductSwitch' | 'modelDescription' | 'supportsMeteogram'>> & {
     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?;
+    protected minifestExpirationTime: TimeRangeMs;
     /**
-     * Has binded listeners
-     */
-    private hasListeners;
-    private bindedCheckNewMinifest;
-    /**
-     * When the product will expire (in ms)
-     */
-    private productExpires;
-    /**
-     * Noneffective, but simple refTime solutions for data that are updated once a day
+     * Minifest loading promise
      */
-    protected dailyCache?: string;
+    protected loadingPromise?: null | Promise<Calendar | undefined | void>;
     /**
      * Must contain ident of self
      */
@@ -101,14 +77,18 @@ export declare class Product {
     /**
      * Description of product for purpose of UI
      */
-    modelName: string;
+    modelName: string | '';
     modelResolution?: number;
     provider?: string;
+    /**
+     * Optional model description
+     */
+    modelDescription?: string;
     /**
      * Update interval (in minutes)
      */
-    interval: number;
-    intervalPremium?: number;
+    interval: Minutes;
+    intervalPremium?: Minutes;
     /**
      * Usual length of forecast in hours (used upon creation of backup minifest)
      */
@@ -164,21 +144,16 @@ export declare class Product {
      * Holder of the latest minifest
      */
     minifest?: MinifestObject | null;
-    /**
-     * How the data image path should be constructed
-     */
-    pathGenerator: string;
     /**
      * Alternative servers, where the data are loaded from
      */
     server?: string;
-    metadataServer?: string;
     /**
-     * Some product (f.ex. StaticProduct) doesn't have meaningful
+     * Some product 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;
+    hasMinifest: boolean;
     /**
      * This product supper accumulations
      */
@@ -191,36 +166,32 @@ export declare class Product {
      * Hide product switch in GUI, when this product is selected
      */
     hideProductSwitch?: boolean;
+    /**
+     * Time when minifest was last updated
+     */
+    minifestLastUpdate?: Timestamp;
+    /**
+     * Point fcst backend for this product supports airgram/meteogram
+     */
+    supportsMeteogram?: boolean;
     constructor(params: ProductInitParams);
-    refTime(): YYYYMMDDHH | undefined;
-    getUpdateTimes(): {
-        refTime: ISODateString;
-        minUpdate: Timestamp;
-    } | null;
-    moveTs(moveRight: boolean, isAccu?: boolean): boolean;
-    getMinifestUrl(): string;
-    loadMinifest(): Promise<http.HttpPayload<MinifestObject>>;
-    loadAndGetReftime(): Promise<ISODateString | undefined>;
-    open(): Promise<void | Calendar>;
-    close(): void;
+    getRefTimeISOFormat(): Promise<ISODateString | undefined>;
+    getRefTime(): Promise<Path | undefined>;
+    /**
+     * Loads & returns a minifest. Since our @windy/http module has its own cache, we don't need to
+     * cache ongoing requests promise and simplify the code as much as possible
+     */
+    loadMinifest(): Promise<MinifestObject>;
     /**
      * Checks if lat,lon is within bounds
      */
     pointIsInBounds<T extends LatLon>(this: this, paramsMap: T): boolean;
-    boundsAreInViewport(map: L.Map): boolean;
-    printLogo(): void;
-    getCalendar(): Promise<Calendar>;
-    protected expire(): void;
-    protected setExpireTime(): void;
-    /**
-     * Major reason for this error is user's bad connection, which is handled
-     * by standard no connection red message
-     *
-     * We delay 0.3 sec to test properly connection
+    /**
+     * Detects if the the bounds are in viewport
      */
-    protected showErrorMessage(err: string): void;
-    protected loadAndProcessMinifest(forced?: boolean): Promise<void>;
-    private checkNewMinifest;
+    boundsAreInViewport(map: LeafletGlMap): boolean;
+    close(): void;
+    open(): void;
+    getCalendar(): Promise<Calendar | undefined>;
     private isPointInsidePolygon;
-    private removeLogo;
 }

package/types/client/ProductClasses.d.ts

@@ -0,0 +1,51 @@
+import { Calendar } from '@windy/Calendar';
+import { Product } from '@windy/Product';
+import type { ProductInitParams } from '@windy/Product';
+import type { MinifestObject } from '@windy/Calendar';
+import type { Overlays } from '@windy/rootScope.d';
+export declare class EcmwfProduct extends Product {
+    calendar: Calendar;
+    constructor(params: Partial<ProductInitParams>);
+}
+export declare class EcmwfForecastProduct extends EcmwfProduct {
+    /**
+     * Main goal for custom loadMInifest method is to speed up loading of default minifest little bit.
+     * Default minifests are loaded ASAP in inlined JS code inside (index|mobile).html so they are
+     * available faster, then when loaded after parsing all the rest of JS code.
+     *
+     * After any change in the code, check in DevTools, that this mechanism actually works.
+     */
+    loadMinifest(): Promise<MinifestObject>;
+}
+export declare class HrrrProducts extends Product {
+    constructor(params: Partial<ProductInitParams>);
+}
+export declare const iconOverlays: Overlays[];
+export declare class IconProducts extends Product {
+    constructor(params: Pick<ProductInitParams, 'modelName'> & Partial<ProductInitParams>);
+}
+export type SatelliteProductInitParams = Pick<SatAndRadarPlusProduct, 'urlSuff' | 'urlSuffFlow'> & ProductInitParams;
+export declare class SatAndRadarPlusProduct extends Product {
+    urlSuff: string;
+    urlSuffFlow: string;
+    constructor(params: SatelliteProductInitParams);
+}
+/**
+ * Auxiliary product with fake calendar required for rendering of isolines on top of overlays, that do not have calendar nor load minifest
+ *  - provides timestamp array with single timestamp pair equal to the current time
+ */
+export declare class FakeCalendarProduct extends Product {
+    loadMinifest(): Promise<MinifestObject>;
+}
+export declare class NamProducts extends Product {
+    constructor(params: Partial<ProductInitParams>);
+}
+export declare class AccessProduct extends Product {
+    constructor(params: Partial<ProductInitParams>);
+}
+export declare class AccessCProduct extends AccessProduct {
+    constructor(params: Partial<ProductInitParams>);
+}
+export declare class AromeProduct extends Product {
+    constructor(params: Partial<ProductInitParams>);
+}

package/types/client/RadarPlusProduct.d.ts

@@ -15,5 +15,5 @@ export declare class RadarPlusProduct extends StaticProduct {
     /**
      * Handling keyboard shortcuts
      */
-    moveTs(moveRight: boolean): boolean;
+    moveTs(moveRight: boolean): boolean | void;
 }

package/types/client/Renderer.d.ts

@@ -1,11 +1,38 @@
-import type { FullRenderParameters } from './d.ts.files/Layer.d';
-import type { Renderers, AllowedUserControls, AllowedRenderPlugins, RendererInitParams } from './d.ts.files/Renderer.d';
-import type { InterpolatorFactory } from './d.ts.files/interpolator';
+import type { FullRenderParameters, WeatherParameters, TilePoint } from '@windy/interfaces';
+import type { Timestamp, TransformFunction } from '@windy/types';
+import type { Layers } from '@windy/Layer';
+import type { InterpolatorFactory } from '@windy/interpolator';
+import type { BottomSveltePlugins, Plugins, SveltePlugins } from '@windy/plugins.d';
+export type AllowedRenderPlugins = Pick<Plugins, 'radar' | 'radar-plus' | 'cap-alerts' | 'isolines' | 'gl-particles'>;
+interface DependencyModuleMap {
+    radar: WPluginModules['@plugins/radar'];
+    'radar-plus': WPluginModules['@plugins/radar-plus'];
+    'cap-alerts': WPluginModules['@plugins/cap-alerts'];
+    isolines: WPluginModules['@plugins/isolines'];
+    'gl-particles': WPluginModules['@plugins/gl-particles'];
+}
+export type Renderers = 'tileLayer' | 'radar' | 'radarPlus' | 'capAlerts' | 'isolines' | 'particles' | 'accumulations' | 'daySwitcher' | 'noUserControl' | 'topoMap';
+export interface TileParams extends TilePoint {
+    url: string;
+    intX: number;
+    intY: number;
+    trans: number;
+    transformR: TransformFunction | null;
+    transformG: TransformFunction | null;
+    transformB: TransformFunction | null;
+}
+export type AllowedUserControls = keyof BottomSveltePlugins | keyof SveltePlugins | 'none';
+export interface RendererInitParams {
+    ident: Renderers;
+    dependency?: keyof AllowedRenderPlugins;
+    userControl?: AllowedUserControls;
+    requiresFullRenderParams?: boolean;
+}
 /**
- * Renderer class act as a proxy between renderController and code, which is responsible to
- * render particullar layer.
+ * Renderer class acts as a proxy between renderController and code, which is responsible for
+ * rendering a particular 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> {
+export declare class Renderer {
     isOpen: boolean;
     /**
      * Ident of renderer. Not used in runtime, but essential for debugging.
@@ -15,7 +42,7 @@ export declare class Renderer<K extends keyof AllowedRenderPlugins | undefined =
     /**
      * Dependency plugin that wil be loaded before renderer is launched
      *
-     * Dependency plugin can optinally export these methods:
+     * Dependency plugin can optionally export these methods:
      *
      *  - onRenderStart
      *  - onRenderEnd
@@ -23,11 +50,11 @@ export declare class Renderer<K extends keyof AllowedRenderPlugins | undefined =
      *  - redraw
      *  - interpolator
      */
-    dependency?: K;
+    dependency?: keyof AllowedRenderPlugins;
     /**
      * Loaded version of plugin dependency
      */
-    loadedDependency?: P;
+    loadedDependency?: DependencyModuleMap[keyof DependencyModuleMap];
     /**
      * ID of plugin, that serve as user control, which can be attached to DOM
      * usually to #plugin-bottom div.
@@ -43,19 +70,17 @@ export declare class Renderer<K extends keyof AllowedRenderPlugins | undefined =
      * userControl opening and closing is handles by rndrCtrl
      */
     userControl?: AllowedUserControls;
-    /**
-     * Picker ingerpolation factory
-     */
+    /** Picker interpolation factory */
     interpolator?: InterpolatorFactory;
+    /** Requires FullRenderParameters */
+    requiresFullRenderParams: boolean;
     constructor(params: RendererInitParams);
-    open(params: FullRenderParameters): Promise<void>;
-    /**
-     * Called by rndrCtrl
-     * list of required renderers, so we kno who will replace us
-     */
+    private static hasProp;
+    open(layerIdent: Layers, weatherParams: WeatherParameters, timestamp: Timestamp): Promise<void>;
     close(_rqrdRenderers: Renderers[]): void;
-    onopen(params: FullRenderParameters): void;
+    onopen(params?: FullRenderParameters): void;
     onclose(): void;
-    paramsChanged(params: FullRenderParameters): void;
+    paramsChanged(layerIdent: Layers, weatherParams: WeatherParameters, timestamp: Timestamp): Promise<void>;
     redraw(): void;
 }
+export {};

package/types/client/SatelliteProduct.d.ts

@@ -15,5 +15,5 @@ export declare class SatelliteProduct extends StaticProduct {
     /**
      * Handling keyboard shortcuts
      */
-    moveTs(moveRight: boolean): boolean;
+    moveTs(moveRight: boolean): void;
 }

package/types/client/ShaderStorage.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @class Shader source storage for different WebGL contexts
+ *  - we aim for using WebGL1 shaders where possible to minimize duplicate code, unless we need some WebGL2-specific features
+ *  - therefore we use WebGL1 sources also in case of WebGL2 context, but it can be overridden in case it is necessary
+ */
+export declare class ShaderStorage {
+    static WGL2: {
+        vTileTextureBlit: string;
+        vScreenQuad: string;
+        fTileTextureBlit: string;
+        fTextureDebug: string;
+        fTextureBlit: string;
+        fTileLayerPreprocess: string;
+        fTileLayerPtypePreprocess: string;
+    };
+    static WGL1: {
+        vTileTextureBlit: string;
+        vScreenQuad: string;
+        fTileTextureBlit: string;
+        fTextureDebug: string;
+        fTextureBlit: string;
+        fTileLayerPreprocess: string;
+        fTileLayerPtypePreprocess: string;
+    };
+}

package/types/client/StartupElementPlugin.d.ts

@@ -0,0 +1,8 @@
+import { SveltePlugin } from '@windy/SveltePlugin';
+import type { SveltePluginInitParams } from '@windy/SveltePlugin';
+import type { StartupElementPlugins } from '@windy/plugins.d';
+export type StartupElementPluginInitParams<P extends keyof StartupElementPlugins> = Omit<SveltePluginInitParams<P>, 'ident'> & Pick<StartupElementPlugin<P>, 'ident'>;
+export declare class StartupElementPlugin<P extends keyof StartupElementPlugins> extends SveltePlugin<P> {
+    ident: P;
+    constructor(params: StartupElementPluginInitParams<P>);
+}

package/types/client/SveltePlugin.d.ts

@@ -1,10 +1,10 @@
 import { WindowPlugin } from '@windy/WindowPlugin';
 import type { WindowPluginInitParams } from '@windy/WindowPlugin';
 import type { PluginsOpenParams, PluginsQsParams } from '@windy/plugin-params.d';
-import type { BottomSveltePlugins, SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
+import type { BottomSveltePlugins, StartupElementPlugins, SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
 import type { InterpolatorFactory } from '@windy/interpolator';
-import type { FullRenderParameters } from '@windy/Layer.d';
-export declare class SvelteApp<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins> {
+import type { FullRenderParameters } from '@windy/interfaces';
+export declare class SvelteApp<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins | keyof StartupElementPlugins> {
     interpolator?: InterpolatorFactory;
     constructor(_args: {
         target: HTMLElement;
@@ -30,8 +30,8 @@ export declare class ExternalSvelteApp {
     $destroy(): void;
 }
 /** Allowed params to SveltePlugin constructor (private and protected props are omited by default) */
-export type SveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
-export declare class SveltePlugin<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins> extends WindowPlugin<P> {
+export type SveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins | keyof StartupElementPlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
+export declare class SveltePlugin<P extends keyof SveltePlugins | keyof SveltePanePlugins | keyof BottomSveltePlugins | keyof StartupElementPlugins> extends WindowPlugin<P> {
     /**
      * Holder of SvelteApp
      */