weatherlayers-gl/dist/weatherlayers-deck.d.ts

WeatherLayers GL - Weather Visualization Layers for deck.gl

import { Color, DefaultProps, LayerProps, CompositeLayer, LayersList, UpdateParameters, CompositeLayerProps, Position } from '@deck.gl/core/typed';
import * as GeoTIFF from 'geotiff';
import { Palette } from 'cpt2js';
import { BitmapLayerProps, BitmapBoundingBox, LineLayerProps } from '@deck.gl/layers/typed';
import { Texture2D } from '@luma.gl/core';
import { License } from 'weatherlayers-license/src/license.js';

declare enum UnitSystem {
    METRIC = "METRIC",
    IMPERIAL = "IMPERIAL",
    NAUTICAL = "NAUTICAL"
}

interface UnitFormat {
    system: UnitSystem;
    unit: string;
    scale?: number;
    offset?: number;
    decimals?: number;
}

type TextFormatFunction = (value: number, unitFormat?: UnitFormat) => string;
declare const DEFAULT_LINE_WIDTH: number;
declare const DEFAULT_LINE_COLOR: Color;
declare const DEFAULT_TEXT_FONT_FAMILY: string;
declare const DEFAULT_TEXT_SIZE: number;
declare const DEFAULT_TEXT_COLOR: Color;
declare const DEFAULT_TEXT_OUTLINE_WIDTH: number;
declare const DEFAULT_TEXT_OUTLINE_COLOR: Color;
declare const DEFAULT_TEXT_FORMAT_FUNCTION: TextFormatFunction;
declare const DEFAULT_ICON_SIZE: number;
declare const DEFAULT_ICON_COLOR: Color;
declare function ensureDefaultProps<PropsT extends {}>(props: PropsT, defaultProps: DefaultProps<PropsT>): PropsT;

interface AnimationConfig {
    onUpdate: () => void;
    fps?: number;
}
declare class Animation {
    #private;
    constructor(config: AnimationConfig);
    getConfig(): AnimationConfig;
    setConfig(config: AnimationConfig): void;
    updateConfig(config: Partial<AnimationConfig>): void;
    get running(): boolean;
    toggle(running?: boolean): void;
    start(): void;
    stop(): void;
    step(): void;
}

type DatetimeISOString = string;
type DatetimeISOStringRange = [start: DatetimeISOString, end: DatetimeISOString];
type DatetimeFormatFunction = (value: DatetimeISOString) => DatetimeISOString;
declare function interpolateDatetime(start: DatetimeISOString, end: DatetimeISOString | null, weight: number): string;
declare function getDatetimeWeight(start: DatetimeISOString, end: DatetimeISOString | null, middle: DatetimeISOString): number;
declare function getClosestStartDatetime(datetimes: DatetimeISOString[], datetime: DatetimeISOString): DatetimeISOString | undefined;
declare function getClosestEndDatetime(datetimes: DatetimeISOString[], datetime: DatetimeISOString): DatetimeISOString | undefined;
declare function offsetDatetime(datetime: DatetimeISOString, hour: number): DatetimeISOString;
declare function offsetDatetimeRange(datetime: DatetimeISOString, start: number, end: number): DatetimeISOStringRange;
declare function formatDatetime(value: DatetimeISOString): string;

declare function formatValue(value: number, unitFormat?: UnitFormat): string;
declare function formatUnit(unitFormat: UnitFormat): string;
declare function formatValueWithUnit(value: number, unitFormat: UnitFormat): string;
declare function formatDirection(direction: number): string;

declare enum ImageInterpolation {
    NEAREST = "NEAREST",
    LINEAR = "LINEAR",
    CUBIC = "CUBIC"
}

declare enum ImageType {
    SCALAR = "SCALAR",
    VECTOR = "VECTOR"
}

type TextureDataArray = GeoTIFF.TypedArray | Uint8ClampedArray;
interface TextureData {
    data: TextureDataArray;
    width: number;
    height: number;
}
type FloatDataArray = Float32Array;
interface FloatData {
    data: FloatDataArray;
    width: number;
    height: number;
}
type LoadFunction<T> = (url: string) => Promise<T>;
type CachedLoadFunction<T> = (url: string, cache?: Map<string, T | Promise<T>> | false) => T | Promise<T>;
declare const loadTextureData: CachedLoadFunction<TextureData>;
declare const loadJson: CachedLoadFunction<any>;

type ImageUnscale = [min: number, max: number] | null;

interface RasterPointProperties {
    value: number;
    direction?: number;
}
declare function getRasterPoints(image: TextureData, image2: TextureData | null, imageSmoothing: number, imageInterpolation: ImageInterpolation, imageWeight: number, imageType: ImageType, imageUnscale: ImageUnscale, bounds: GeoJSON.BBox, positions: GeoJSON.Position[]): GeoJSON.FeatureCollection<GeoJSON.Point, RasterPointProperties>;
declare function getRasterMagnitudeData(image: TextureData, image2: TextureData | null, imageSmoothing: number, imageInterpolation: ImageInterpolation, imageWeight: number, imageType: ImageType, imageUnscale: ImageUnscale): FloatData;

declare abstract class Control<ControlConfig> {
    addTo(target: HTMLElement): void;
    prependTo(target: HTMLElement): void;
    remove(): void;
    updateConfig(config: Partial<ControlConfig>): void;
    abstract getConfig(): ControlConfig;
    abstract setConfig(config: ControlConfig): void;
    protected abstract onAdd(): HTMLElement;
    protected abstract onRemove(): void;
}

interface LegendControlConfig {
    width: number;
    ticksCount: number;
    title: string;
    unitFormat: UnitFormat;
    palette: Palette;
}
declare class LegendControl extends Control<LegendControlConfig> {
    #private;
    constructor(config?: LegendControlConfig);
    protected onAdd(): HTMLElement;
    protected onRemove(): void;
    getConfig(): LegendControlConfig;
    setConfig(config: LegendControlConfig): void;
}

interface TooltipControlConfig {
    unitFormat: UnitFormat;
}
declare class TooltipControl extends Control<TooltipControlConfig> {
    #private;
    constructor(config?: TooltipControlConfig);
    protected onAdd(): HTMLElement;
    protected onRemove(): void;
    getConfig(): TooltipControlConfig;
    setConfig(config: TooltipControlConfig): void;
    update(rasterPointProperties?: RasterPointProperties): void;
}

interface TimelineControlConfig {
    width: number;
    datetimes: DatetimeISOString[];
    datetime: DatetimeISOString;
    datetimeInterpolate: boolean;
    datetimeFormatFunction?: DatetimeFormatFunction;
    onPreload?: (datetimes: DatetimeISOString[]) => Promise<void>;
    onUpdate?: (datetime: DatetimeISOString) => void;
    fps?: number;
}
declare class TimelineControl extends Control<TimelineControlConfig> {
    #private;
    constructor(config?: TimelineControlConfig);
    protected onAdd(): HTMLElement;
    protected onRemove(): void;
    get loading(): boolean;
    get running(): boolean;
    toggle(running?: boolean): Promise<void>;
    start(): Promise<void>;
    pause(): void;
    stop(): void;
    reset(): void;
    stepBackward(): Promise<void>;
    stepForward(): Promise<void>;
    getConfig(): TimelineControlConfig;
    setConfig(config: TimelineControlConfig): void;
}

interface AttributionControlConfig {
    attribution: string;
}
declare class AttributionControl extends Control<AttributionControlConfig> {
    #private;
    constructor(config?: AttributionControlConfig);
    protected onAdd(): HTMLElement;
    protected onRemove(): void;
    getConfig(): AttributionControlConfig;
    setConfig(config: AttributionControlConfig): void;
}

interface LogoControlConfig {
}
declare class LogoControl extends Control<LogoControlConfig> {
    #private;
    constructor(config?: LogoControlConfig);
    protected onAdd(): HTMLElement;
    protected onRemove(): void;
    getConfig(): LogoControlConfig;
    setConfig(config: LogoControlConfig): void;
}

type _RasterBitmapLayerProps = BitmapLayerProps & {
    imageTexture: Texture2D | null;
    imageTexture2: Texture2D | null;
    imageSmoothing: number;
    imageInterpolation: ImageInterpolation;
    imageWeight: number;
    imageType: ImageType;
    imageUnscale: ImageUnscale;
    bounds: BitmapBoundingBox;
    palette: Palette | null;
};
type RasterBitmapLayerProps = _RasterBitmapLayerProps & LayerProps;

type _RasterLayerProps = RasterBitmapLayerProps & {
    image: TextureData | null;
    image2: TextureData | null;
};
type RasterLayerProps = _RasterLayerProps & LayerProps;
declare class RasterLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_RasterLayerProps>> {
    static layerName: string;
    static defaultProps: DefaultProps<RasterLayerProps>;
    renderLayers(): LayersList;
    updateState(params: UpdateParameters<this>): void;
}

type _ContourBitmapLayerProps = BitmapLayerProps & {
    imageTexture: Texture2D | null;
    imageTexture2: Texture2D | null;
    imageSmoothing: number;
    imageInterpolation: ImageInterpolation;
    imageWeight: number;
    imageType: ImageType;
    imageUnscale: ImageUnscale;
    bounds: BitmapBoundingBox;
    interval: number;
    width: number;
    color: Color;
};
type ContourBitmapLayerProps = _ContourBitmapLayerProps & LayerProps;

type _ContourLayerProps = ContourBitmapLayerProps & {
    image: TextureData | null;
    image2: TextureData | null;
};
type ContourLayerProps = _ContourLayerProps & LayerProps;
declare class ContourLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_ContourLayerProps>> {
    static layerName: string;
    static defaultProps: DefaultProps<ContourLayerProps>;
    renderLayers(): LayersList;
    updateState(params: UpdateParameters<this>): void;
}

type _HighLowCompositeLayerProps = CompositeLayerProps & {
    image: TextureData | null;
    image2: TextureData | null;
    imageSmoothing: number;
    imageInterpolation: ImageInterpolation;
    imageWeight: number;
    imageType: ImageType;
    imageUnscale: ImageUnscale;
    bounds: BitmapBoundingBox;
    radius: number;
    unitFormat: UnitFormat | null;
    textFormatFunction: TextFormatFunction;
    textFontFamily: string;
    textSize: number;
    textColor: Color;
    textOutlineWidth: number;
    textOutlineColor: Color;
};
type HighLowCompositeLayerProps = _HighLowCompositeLayerProps & LayerProps;

type _HighLowLayerProps = HighLowCompositeLayerProps;
type HighLowLayerProps = _HighLowLayerProps & LayerProps;
declare class HighLowLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_HighLowLayerProps>> {
    static layerName: string;
    static defaultProps: DefaultProps<HighLowLayerProps>;
    renderLayers(): LayersList;
    updateState(params: UpdateParameters<this>): void;
}

declare enum FrontType {
    COLD = "COLD",
    WARM = "WARM",
    OCCLUDED = "OCCLUDED",
    STATIONARY = "STATIONARY"
}

type _FrontCompositeLayerProps<DataT> = CompositeLayerProps & {
    data: DataT[];
    getType: ((d: DataT) => FrontType) | null;
    getPath: ((d: DataT) => Position[]) | null;
    width: number;
    coldColor: Color;
    warmColor: Color;
    occludedColor: Color;
    iconSize: number;
    _debug: boolean;
};
type FrontCompositeLayerProps<DataT> = _FrontCompositeLayerProps<DataT> & LayerProps;

type _FrontLayerProps<DataT> = FrontCompositeLayerProps<DataT>;
type FrontLayerProps<DataT> = _FrontLayerProps<DataT> & LayerProps;
declare class FrontLayer<DataT = any, ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_FrontLayerProps<DataT>>> {
    static layerName: string;
    static defaultProps: DefaultProps<FrontLayerProps<any>>;
    renderLayers(): LayersList;
}

declare enum GridStyle {
    VALUE = "VALUE",
    ARROW = "ARROW",
    WIND_BARB = "WIND_BARB"
}

type _GridCompositeLayerProps = CompositeLayerProps & {
    image: TextureData | null;
    image2: TextureData | null;
    imageSmoothing: number;
    imageInterpolation: ImageInterpolation;
    imageWeight: number;
    imageType: ImageType;
    imageUnscale: ImageUnscale;
    bounds: BitmapBoundingBox;
    style: GridStyle;
    unitFormat: UnitFormat | null;
    textFormatFunction: TextFormatFunction;
    textFontFamily: string;
    textSize: number;
    textColor: Color;
    textOutlineWidth: number;
    textOutlineColor: Color;
    iconBounds: [number, number] | null;
    iconSize: number;
    iconColor: Color;
};
type GridCompositeLayerProps = _GridCompositeLayerProps & LayerProps;

type _GridLayerProps = GridCompositeLayerProps;
type GridLayerProps = _GridLayerProps & LayerProps;
declare class GridLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_GridLayerProps>> {
    static layerName: string;
    static defaultProps: DefaultProps<GridLayerProps>;
    renderLayers(): LayersList;
    updateState(params: UpdateParameters<this>): void;
}

type _ParticleLineLayerProps = LineLayerProps<{}> & {
    imageTexture: Texture2D | null;
    imageTexture2: Texture2D | null;
    imageSmoothing: number;
    imageInterpolation: ImageInterpolation;
    imageWeight: number;
    imageType: ImageType;
    imageUnscale: ImageUnscale;
    bounds: BitmapBoundingBox;
    numParticles: number;
    maxAge: number;
    speedFactor: number;
    width: number;
    color: Color;
    animate: boolean;
};
type ParticleLineLayerProps = _ParticleLineLayerProps & LayerProps;

type _ParticleLayerProps = ParticleLineLayerProps & {
    image: TextureData | null;
    image2: TextureData | null;
};
type ParticleLayerProps = _ParticleLayerProps & LayerProps;
declare class ParticleLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_ParticleLayerProps>> {
    static layerName: string;
    static defaultProps: DefaultProps<ParticleLayerProps>;
    renderLayers(): LayersList;
    updateState(params: UpdateParameters<this>): void;
}

declare function setLicense(currentLicense: License): void;

export { Animation, type AnimationConfig, AttributionControl, type AttributionControlConfig, type CachedLoadFunction, ContourLayer, type ContourLayerProps, DEFAULT_ICON_COLOR, DEFAULT_ICON_SIZE, DEFAULT_LINE_COLOR, DEFAULT_LINE_WIDTH, DEFAULT_TEXT_COLOR, DEFAULT_TEXT_FONT_FAMILY, DEFAULT_TEXT_FORMAT_FUNCTION, DEFAULT_TEXT_OUTLINE_COLOR, DEFAULT_TEXT_OUTLINE_WIDTH, DEFAULT_TEXT_SIZE, type DatetimeFormatFunction, type DatetimeISOString, type DatetimeISOStringRange, type FloatData, type FloatDataArray, FrontLayer, type FrontLayerProps, FrontType, GridLayer, type GridLayerProps, GridStyle, HighLowLayer, type HighLowLayerProps, ImageInterpolation, ImageType, LegendControl, type LegendControlConfig, type LoadFunction, LogoControl, type LogoControlConfig, ParticleLayer, type ParticleLayerProps, RasterLayer, type RasterLayerProps, type RasterPointProperties, type TextFormatFunction, type TextureData, type TextureDataArray, TimelineControl, type TimelineControlConfig, TooltipControl, type TooltipControlConfig, UnitSystem, ensureDefaultProps, formatDatetime, formatDirection, formatUnit, formatValue, formatValueWithUnit, getClosestEndDatetime, getClosestStartDatetime, getDatetimeWeight, getRasterMagnitudeData, getRasterPoints, interpolateDatetime, loadJson, loadTextureData, offsetDatetime, offsetDatetimeRange, setLicense };