tds-map-methods 0.0.0-stage → 0.1.1

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "tds-map-methods",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Map methods extracted from tds demo.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./types/components/map/methods/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/components/map/methods/index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    }
+  },
+  "peerDependencies": {
+    "ol": "^10.7.0",
+    "@turf/turf": "^7.3.1",
+    "dayjs": "^1.11.19",
+    "d3-contour": "^4.0.2",
+    "lodash-es": "^4.17.22"
+  },
+  "files": [
+    "index.js",
+    "index.cjs",
+    "types",
+    "README.md"
+  ]
+}

package/types/components/map/methods/arrowLayer.d.ts

@@ -0,0 +1,25 @@
+import ImageCanvasSource from "ol/source/ImageCanvas.js";
+import ImageLayer from "ol/layer/Image.js";
+type ExtentLike = [number, number, number, number];
+export declare class ArrowLayer {
+    map: Layer.Map;
+    options: any;
+    contourCache: Map<string, any>;
+    constructor(map: Layer.Map, options: any);
+    add(): Promise<ImageLayer<ImageCanvasSource>>;
+    getArrowParams(): Promise<{
+        grayArr: number[];
+        width: number;
+        height: number;
+    }>;
+    getArrowSource(options: any): ImageCanvasSource;
+    createArrowCanvasSource(data: any, bbox: ExtentLike, options: {
+        pixelStep?: number;
+        fontSize?: number;
+        color?: string;
+    }): ImageCanvasSource;
+    getSourceFromCache(): ImageCanvasSource;
+    delete(): void;
+    toggleVisible(visible: boolean): void;
+}
+export {};

package/types/components/map/methods/common.d.ts

@@ -0,0 +1 @@
+export declare function CommonMethods(): void;

package/types/components/map/methods/config.d.ts

@@ -0,0 +1,32 @@
+export interface MapMethodsConfig {
+    /** Prefix used for WMS requests, for example "/server". */
+    serviceBaseUrl?: string;
+    /** Default Authorization header used for TDS requests. */
+    serviceAuthorization?: string;
+    /** Prefix used for NCSS dataset.xml requests, for example "/ncss/grid". */
+    ncssBaseUrl?: string;
+    /** Request timeout in milliseconds. */
+    requestTimeout?: number;
+    /** Maximum width/height used when requesting source images. */
+    imageSize?: number;
+    /** Prefix used for typhoon JSON requests. Falls back to serviceBaseUrl. */
+    typhoonServiceBaseUrl?: string;
+    /** Default typhoon data directory. */
+    typhoonDataPath?: string;
+    /** Default Authorization header for typhoon requests. */
+    typhoonAuthorization?: string;
+}
+export type ResolvedMapMethodsConfig = {
+    serviceBaseUrl: string;
+    serviceAuthorization: string;
+    ncssBaseUrl: string;
+    requestTimeout: number;
+    imageSize: number;
+    typhoonServiceBaseUrl: string;
+    typhoonDataPath: string;
+    typhoonAuthorization: string;
+};
+/** Configure values that must be supplied by the consuming application. */
+export declare function configureMapMethods(config: MapMethodsConfig): void;
+export declare function getMapMethodsConfig(): Readonly<ResolvedMapMethodsConfig>;
+export declare function resetMapMethodsConfig(): void;

package/types/components/map/methods/createIsoline.d.ts

@@ -0,0 +1,76 @@
+import type Map from "ol/Map.js";
+import VectorLayer from "ol/layer/Vector.js";
+type LegendItem = {
+    name?: string;
+    scope?: number[];
+    color: string;
+};
+type IsolineConfig = {
+    legend?: LegendItem[];
+    legendScope?: [number, number] | [];
+    scope?: [number, number];
+    lineWidth?: number;
+    /** 等值线线宽，未配置时兼容使用 lineWidth。 */
+    isolineLineWidth?: number;
+    /** Whether isoline smoothing is enabled. Defaults to true. */
+    isolineSmooth?: boolean;
+    /** Isoline smoothing level: 0 disables smoothing, 1-3 progressively increase it. */
+    isolineSmoothness?: number;
+    isolineColor?: string | boolean;
+    /** 等值面边界线颜色，未配置时沿用当前等值线颜色。 */
+    isolineBorderColor?: string;
+    /** 是否使用等值面按图例分级填色。 */
+    isolineFill?: boolean;
+    /** 是否沿等值线显示数值。 */
+    showIsolineValue?: boolean;
+    showIsolineLabel?: boolean;
+    opacity?: number;
+    zIndex?: number;
+    [key: string]: unknown;
+};
+export type IsolineOptions = {
+    id: string;
+    url: string;
+    time?: unknown;
+    authorization?: string;
+    signal?: AbortSignal;
+    config: IsolineConfig;
+};
+type Coordinate = [number, number];
+type IsolineGeometry = {
+    type: "LineString" | "MultiLineString";
+    coordinates: Coordinate[] | Coordinate[][];
+    value: number;
+};
+type IsolinePolygonGeometry = {
+    type: "Polygon" | "MultiPolygon";
+    coordinates: Coordinate[][] | Coordinate[][][];
+    value: number;
+};
+/** 在地图上添加等值线向量图层。 */
+export declare function addIsolineLayer(options: {
+    map: Map;
+    id: string;
+    isolineGeoJSON: IsolineGeometry[];
+    contourGeoJSON?: IsolinePolygonGeometry[];
+    colorMap: string | Record<number, string>;
+    fillColorMap?: Record<number, string>;
+    fillContours?: boolean;
+    fillOpacity?: number;
+    lineWidth?: number;
+    showLabel?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    /** Reuse parsed OpenLayers features while only the visible legend range changes. */
+    geometryCacheKey?: string;
+    visibleThresholds?: number[];
+}): VectorLayer<any, any>;
+/** 根据灰度格点生成并添加等值线，重复请求会复用生成结果。 */
+export declare function createIsoline(map: Map, options: IsolineOptions): Promise<VectorLayer<any, any>>;
+/** 预加载若干时间点的等值线到缓存。 */
+export declare function preloadIsoline(options: IsolineOptions, timeList: unknown[]): Promise<void>;
+/** 删除等值线图层，并使未完成的同图层请求失效。 */
+export declare function removeIsolineLayer(map: Map, className: string): void;
+/** 切换显示/隐藏。 */
+export declare function toggleIsolineLayer(map: Map, className: string, show: boolean): void;
+export {};

package/types/components/map/methods/createMic.d.ts

@@ -0,0 +1,28 @@
+import type Map from "ol/Map.js";
+import VectorLayer from "ol/layer/Vector.js";
+import VectorSource from "ol/source/Vector.js";
+type LegendItem = {
+    name?: string;
+    scope?: number[];
+    color: string;
+};
+export type MicContourOptions = {
+    className: string;
+    filePath: string;
+    authorization?: string;
+    signal?: AbortSignal;
+    legend?: LegendItem[];
+    legendScope?: [number, number] | [];
+    zIndex?: number;
+    opacity?: number;
+    visible?: boolean;
+    showText?: boolean;
+    showFillcolor?: boolean;
+    showIsoline?: boolean;
+    showPointMarkers?: boolean;
+};
+/** Parse a MICAPS file and atomically replace its related vector layers. */
+export declare function createMicContour(map: Map, options: MicContourOptions): Promise<VectorLayer<VectorSource<any>, any>>;
+/** Remove all layers created for a MICAPS dataset and invalidate pending renders. */
+export declare function removeMicContour(map: Map, className: string): void;
+export {};

package/types/components/map/methods/fcstLayer.d.ts

@@ -0,0 +1,81 @@
+import ImageCanvasSource from "ol/source/ImageCanvas.js";
+import ImageLayer from "ol/layer/Image.js";
+type ExtentLike = [number, number, number, number];
+type ScopeLike = [number, number] | [] | undefined;
+type ValueTransformContext = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    source: "raw" | "smooth";
+};
+type ValueTransformFn = (value: number, context: ValueTransformContext) => number | null | undefined;
+type ContourRing = number[][];
+type ContourPolygon = ContourRing[];
+type ContourMultiPolygon = ContourPolygon[];
+type ContourFill = {
+    threshold: number;
+    path: Path2D;
+    color: string;
+};
+type CachedRasterRender = {
+    canvas: HTMLCanvasElement;
+    renderMask: (number | undefined)[][];
+    renderValues: (number | undefined)[][];
+    contourFills?: ContourFill[];
+};
+type CachedContourData = {
+    schemaVersion: number;
+    uniqueThresholds: number[];
+    rawArr2D: (number | undefined)[][];
+    smoothArr2D: (number | undefined)[][];
+    extent: ExtentLike;
+    width: number;
+    height: number;
+};
+export declare class FcstLayer {
+    map: Layer.Map;
+    options: any;
+    contourCache: Map<string, any>;
+    contourLoadingTasks: globalThis.Map<string, Promise<CachedContourData | null>>;
+    rasterRenderCache: globalThis.Map<string, CachedRasterRender>;
+    rasterRenderLoadingTasks: globalThis.Map<string, Promise<CachedRasterRender | null>>;
+    layerData: any;
+    ready: Promise<any>;
+    private sourceRequestVersion;
+    private abortController;
+    constructor(map: Layer.Map, options: any);
+    private beginSourceRequest;
+    private isCurrentRequest;
+    private getRequestOptions;
+    private getContourCacheKey;
+    private setCachedContourData;
+    private getRasterRenderCacheKey;
+    private setCachedRasterRender;
+    add(): Promise<ImageLayer<ImageCanvasSource>>;
+    getSourceFromParams(options?: any): Promise<ImageCanvasSource>;
+    getOrLoadContourData(options?: any): Promise<CachedContourData | null>;
+    getValueByLonLat(lon: number, lat: number, useSmooth?: boolean): Promise<number | null>;
+    getValueByLngLat(lng: number, lat: number, useSmooth?: boolean): Promise<number | null>;
+    getSourceFromCache(options?: any): Promise<ImageCanvasSource>;
+    getFcstRasterSource(options: any, runtimeOptions?: any): Promise<ImageCanvasSource>;
+    getValueTransformFn(options?: any): ValueTransformFn | undefined;
+    applyValueTransformValue(value: number, context: ValueTransformContext, transformFn?: ValueTransformFn): number;
+    applyValueTransform2D(data2D: (number | undefined)[][], source: ValueTransformContext["source"], transformFn?: ValueTransformFn): (number | undefined)[][];
+    isMaskSmoothEnabled(options?: any): boolean;
+    getMaskSmoothIterations(options?: any): number;
+    chaikinSmoothRing(ring: ContourRing, iterations?: number): ContourRing;
+    smoothMaskContourPolygons(polygons: ContourMultiPolygon, iterations: number): ContourMultiPolygon;
+    createVisibleMaskContourPath(rawArr2D: (number | undefined)[][], width: number, height: number, scope?: ScopeLike, smooth?: boolean, runtimeOptions?: any): Path2D;
+    createIsolineContourPath(valueArr2D: (number | undefined)[][], width: number, height: number, scope?: ScopeLike, runtimeOptions?: any): Path2D;
+    createIsolineContourFills(valueArr2D: (number | undefined)[][], width: number, height: number, thresholds: number[], colorsRGBA: [number, number, number, number][], scope?: ScopeLike, runtimeOptions?: any): ContourFill[];
+    createScopeMaskCanvas(valueArr2D: (number | undefined)[][], width: number, height: number, scope?: ScopeLike, maxExclusive?: boolean): HTMLCanvasElement;
+    createLegendEdgeColorCanvas(valueArr2D: (number | undefined)[][], width: number, height: number, firstThreshold: number, lastThreshold: number, firstColor: [number, number, number, number], lastColor: [number, number, number, number]): HTMLCanvasElement;
+    createFcstCanvasSource(rasterCanvas: HTMLCanvasElement, dataExtent: ExtentLike, colorMode?: Layer.LayerMode, rawArr2D?: (number | undefined)[][], scope?: ScopeLike, runtimeOptions?: any, contourFills?: ContourFill[], contourValues?: (number | undefined)[][], selectedEdgeCanvas?: HTMLCanvasElement | null, maxExclusive?: boolean): ImageCanvasSource;
+    /** 预加载图层 */
+    preload(url: string): Promise<void>;
+    delete(): void;
+    toggleVisible(visible: boolean): void;
+    updateParams(newOptions: any): Promise<void>;
+}
+export {};

package/types/components/map/methods/fcstLayer2.d.ts

@@ -0,0 +1,30 @@
+import ImageCanvasSource from "ol/source/ImageCanvas.js";
+import ImageLayer from "ol/layer/Image.js";
+type ExtentLike = [number, number, number, number];
+type ScopeLike = [number, number] | [] | undefined;
+type ContourRing = number[][];
+type ContourPolygon = ContourRing[];
+type ContourMultiPolygon = ContourPolygon[];
+export declare class FcstLayer {
+    map: Layer.Map;
+    options: any;
+    contourCache: Map<string, any>;
+    layerData: any;
+    constructor(map: Layer.Map, options: any);
+    add(): Promise<ImageLayer<ImageCanvasSource>>;
+    getSourceFromParams(): Promise<ImageCanvasSource>;
+    getSourceFromCache(): Promise<ImageCanvasSource>;
+    getFcstRasterSource(options: any): Promise<ImageCanvasSource>;
+    isMaskSmoothEnabled(): boolean;
+    getMaskSmoothIterations(): number;
+    chaikinSmoothRing(ring: ContourRing, iterations?: number): ContourRing;
+    smoothMaskContourPolygons(polygons: ContourMultiPolygon, iterations: number): ContourMultiPolygon;
+    createVisibleMaskContourPath(rawArr2D: (number | undefined)[][], width: number, height: number, scope?: ScopeLike, smooth?: boolean): Path2D;
+    createFcstCanvasSource(rasterCanvas: HTMLCanvasElement, dataExtent: ExtentLike, colorMode?: Layer.LayerMode, rawArr2D?: (number | undefined)[][], scope?: ScopeLike): ImageCanvasSource;
+    /** 预加载图层 */
+    preload(): Promise<void>;
+    delete(): void;
+    toggleVisible(visible: boolean): void;
+    updateParams(newOptions: any): Promise<void>;
+}
+export {};

package/types/components/map/methods/girdLayer.d.ts

@@ -0,0 +1,62 @@
+import ImageCanvasSource from "ol/source/ImageCanvas.js";
+import ImageLayer from "ol/layer/Image.js";
+type ExtentLike = [number, number, number, number];
+type GridValueTransformContext = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    source: "raw";
+};
+type GridValueTransformFn = (value: number, context: GridValueTransformContext) => number | null | undefined;
+type CachedGridData = {
+    schemaVersion: number;
+    rawArr2D: (number | undefined)[][];
+    extent: ExtentLike;
+    width: number;
+    height: number;
+};
+type GridDataInput = {
+    rawArr2D: (number | undefined)[][];
+    extent: ExtentLike;
+    width: number;
+    height: number;
+};
+export declare function setLinkedGridLayer(id: string, layer: GridLayer): void;
+export declare function getLinkedGridLayer(id: string): GridLayer;
+export declare function deleteLinkedGridLayer(id: string): void;
+export declare function forEachLinkedGridLayer(callback: (layer: GridLayer) => void): void;
+export declare function clearLinkedGridLayerMap(): void;
+export declare class GridLayer {
+    map: Layer.Map;
+    options: Layer.Config;
+    contourCache: Map<string, CachedGridData>;
+    externalGridDataProvider?: () => Promise<GridDataInput | null>;
+    constructor(map: Layer.Map, options: Layer.Config, externalGridDataProvider?: () => Promise<GridDataInput | null>);
+    getClassName(): string;
+    getRuntimeConfig(): Layer.Config["config"] & Record<string, any>;
+    add(): Promise<ImageLayer<ImageCanvasSource>>;
+    getCacheKey(): string;
+    getOrLoadGridData(): Promise<CachedGridData | null>;
+    getSourceFromCache(): Promise<ImageCanvasSource>;
+    getSourceFromParams(): Promise<ImageCanvasSource>;
+    getTextDrawOptions(): {
+        pixelStep: number;
+        fontSize: number;
+        decimals: number;
+        fontColor: string;
+        strokeColor: string;
+        strokeWidth: number;
+        fontFamily: string;
+        useDevicePixelRatio: boolean;
+    };
+    isValueInScope(value: number, scope?: [number, number] | []): boolean;
+    interpolateValue(rawArr2D: (number | undefined)[][], width: number, height: number, dataX: number, dataY: number): number;
+    getValueTransformFn(): GridValueTransformFn | undefined;
+    applyValueTransformValue(value: number, context: GridValueTransformContext): number;
+    createGridCanvasSource(data: CachedGridData): ImageCanvasSource;
+    delete(): void;
+    toggleVisible(visible: boolean): void;
+    updateParams(newOptions: Layer.Config): Promise<void>;
+}
+export {};

package/types/components/map/methods/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference path="../../../typings/layer.d.ts" />
+export * from "./common";
+export * from "./config";
+export * from "./request";
+export * from "./tdsRequest";
+export * from "./layerRequest";
+export * from "./layer";
+export * from "./utils";
+export * from "./fcstLayer";
+export * from "./girdLayer";
+export * from "./arrowLayer";
+export * from "./micLayer";
+export * from "./createMic";
+export * from "./createIsoline";
+export * from "./isolineLayer";
+export * from "./webgpuRaster";
+export * from "./windLayer";
+export * from "./windShaft";
+export * from "./wmsLayer";
+export * from "./typhoonLayer";
+export * from "./typhoonRequest";

package/types/components/map/methods/isolineLayer.d.ts

@@ -0,0 +1,18 @@
+import type Map from "ol/Map.js";
+import { type IsolineOptions } from "./createIsoline";
+type ManagedIsolineOptions = Omit<IsolineOptions, "url"> & {
+    url?: string;
+    type: string | string[];
+};
+export declare class IsolineLayer {
+    map: Map;
+    options: ManagedIsolineOptions;
+    ready: Promise<void>;
+    private abortController;
+    constructor(map: Map, options: ManagedIsolineOptions);
+    private render;
+    delete(): void;
+    toggleVisible(visible: boolean): void;
+    updateParams(newOptions: ManagedIsolineOptions): Promise<void>;
+}
+export {};

package/types/components/map/methods/layer.d.ts

@@ -0,0 +1,41 @@
+import { Map } from "ol";
+import { type MapMethodsConfig } from "./config";
+type WmsLayerColorOptions = {
+    styles?: string;
+    colorScaleRange?: string | [number, number];
+    numColorBands?: string | number;
+    aboveMaxColor?: string;
+    belowMinColor?: string;
+    bgColor?: string;
+    logScale?: boolean | string;
+};
+export type MapInitConfig = {
+    center?: [number, number];
+    zoom?: number;
+    layers?: any[];
+    mapMethodsConfig?: MapMethodsConfig;
+};
+export declare function initMap(target: string | HTMLElement, config?: MapInitConfig): Promise<Map>;
+/**
+ * 根据classname获取对应图层
+ * @param className 图层的className
+ */
+export declare function getLayerByClassName(map: Map, className: string): import("ol/layer/Base").default;
+/**
+ * 移除图层
+ * @param className 图层的className
+ */
+export declare function removeLayer(map: Map, className: string): void;
+export declare function addTile(map: Map, layer: any): void;
+export declare function removeTile(map: Map, layerId: string): void;
+export declare function toggleLayerShowHide(map: Map | undefined, layerId: string, visible: boolean): void;
+export declare function loadLayer(map: Map | undefined, options: Layer.Config): void;
+export declare function removeLayerById(layerId: string): void;
+export declare function clearAllLayers(): void;
+export declare function toggleVisibleById(layerId: string, visible: boolean): void;
+export declare function updateLayer(options: Layer.Config): void;
+export declare function updateWmsLayerColor(layerId: string, colorOptions: WmsLayerColorOptions): void;
+export declare function getLoadedLayers(): any[];
+export declare function getLoadedLayerOptions(): Layer.Config[];
+export declare function getValueByLonLat(map: Map | undefined, layerId: string, lon: number, lat: number, useSmooth?: boolean): Promise<number | null>;
+export {};

package/types/components/map/methods/layerRequest.d.ts

@@ -0,0 +1,7 @@
+export interface LayerResolveRequestOptions {
+    serviceBaseUrl?: string;
+    ncssBaseUrl?: string;
+    authorization?: string;
+    signal?: AbortSignal;
+}
+export declare function resolveLayerLoadOptions(menu: Layer.Config, options?: LayerResolveRequestOptions): Promise<Layer.Config | null>;

package/types/components/map/methods/micLayer.d.ts

@@ -0,0 +1,28 @@
+type MicOptions = Layer.Config & Record<string, any>;
+export declare class MicLayer {
+    map: Layer.Map;
+    options: MicOptions;
+    ready: Promise<any>;
+    private sourceRequestVersion;
+    private abortController;
+    constructor(map: Layer.Map, options: MicOptions);
+    private beginSourceRequest;
+    getMicContourOptions(filePath: string): {
+        className: string;
+        filePath: string;
+        authorization: string;
+        legend: any;
+        legendScope: any;
+        zIndex: number;
+        opacity: number;
+        showText: any;
+        showFillcolor: any;
+        showIsoline: any;
+        showPointMarkers: any;
+    };
+    add(): Promise<void>;
+    delete(): void;
+    toggleVisible(visible: boolean): void;
+    updateParams(newOptions: Layer.Config & Record<string, any>): Promise<void>;
+}
+export {};

package/types/components/map/methods/request.d.ts

@@ -0,0 +1,21 @@
+export type TdsResponseType = "json" | "text" | "blob" | "arrayBuffer" | "arraybuffer" | "response";
+export interface TdsRequestOptions {
+    baseUrl?: string;
+    authorization?: string;
+    signal?: AbortSignal;
+    timeout?: number;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+}
+export interface TdsGetOptions extends TdsRequestOptions {
+    responseType?: TdsResponseType;
+}
+export declare function createTdsRequestUrl(url: string, baseUrl?: string): string;
+export declare function fetchTdsResponse(url: string, options?: TdsRequestOptions): Promise<Response>;
+export declare function fetchTdsGet<T = unknown>(url: string, params?: Record<string, unknown>, authorization?: string, options?: TdsGetOptions): Promise<T>;
+export declare function fetchXmlData(url: string, authorization?: string, options?: TdsRequestOptions): Promise<string>;
+export declare function fetchXMLFromUrl(url: string, authorization?: string, options?: TdsRequestOptions): Promise<string>;
+export declare function fetchTxtOrJson(url: string, params?: Record<string, unknown>, authorization?: string, options?: TdsRequestOptions): Promise<string>;
+export declare function fetchExcel(url: string, authorization?: string, options?: TdsRequestOptions): Promise<ArrayBuffer>;
+export declare function fetchImageBase64(url: string, paramsOrAuthorization?: Record<string, unknown> | string, authorization?: string, options?: TdsRequestOptions): Promise<string>;
+export declare function fetchTdsImageBase64(url: string, params?: Record<string, unknown>): Promise<string>;

package/types/components/map/methods/tdsRequest.d.ts

@@ -0,0 +1,49 @@
+export interface VariableMinMaxResult {
+    min: number;
+    max: number;
+}
+export interface TdsCatalogItem {
+    label: string;
+    key: string;
+    url: string;
+    type: "menu" | "file";
+    isLeaf: boolean;
+    fileType?: string;
+}
+export interface TdsDatasetRequestOptions {
+    filePath: string;
+    url?: string;
+    authorization?: string;
+    serviceBaseUrl?: string;
+    ncssBaseUrl?: string;
+    signal?: AbortSignal;
+}
+export declare function parseXML(xml: string, target?: string): any;
+export declare function getNCXmlData(xml: string): {
+    latLonBox: any;
+    timeSpan: any;
+    axis: any;
+    grid: any;
+};
+export declare function getNodeData(options: {
+    xmlJson: any[];
+    type: "menu" | "file";
+}): TdsCatalogItem[];
+export declare function getVariableMinMax(filePath: string, variable: string, latLonBox: {
+    north: number;
+    south: number;
+    east: number;
+    west: number;
+}, time?: string, authorization?: string, serviceBaseUrl?: string, signal?: AbortSignal): Promise<VariableMinMaxResult>;
+export declare function getMenuList(url: string, authorization?: string, options?: Pick<TdsDatasetRequestOptions, "serviceBaseUrl" | "signal">): Promise<{
+    type: "" | "menu" | "file";
+    data: TdsCatalogItem[];
+}>;
+export declare function getXmlData(options: TdsDatasetRequestOptions): Promise<{
+    type: "file";
+    latLonBox: any;
+    timeList: string[];
+    fileList: TdsCatalogItem[];
+    url: string;
+    authorization: string;
+}>;

package/types/components/map/methods/typhoonLayer.d.ts

@@ -0,0 +1,57 @@
+import type { FeatureLike } from "ol/Feature.js";
+import VectorSource from "ol/source/Vector.js";
+import { Style } from "ol/style.js";
+import { type TyphoonDetail, type TyphoonListItem, type TyphoonPoint } from "./typhoonRequest";
+type TrackKind = "obs" | "fcst";
+type TyphoonLayerOptions = Layer.Config & {
+    config: Layer.Config["config"] & {
+        typhoonConfig?: {
+            serviceBaseUrl?: string;
+            dataPath?: string;
+            typhoonNums?: string[];
+            sourcePriority?: string[];
+            showForecast?: boolean;
+            fitToExtent?: boolean;
+        };
+    };
+};
+export declare class TyphoonLayer {
+    map: Layer.Map;
+    options: TyphoonLayerOptions;
+    abortController: AbortController | null;
+    styleCache: globalThis.Map<string, Style>;
+    constructor(map: Layer.Map, options: TyphoonLayerOptions);
+    getClassName(): string;
+    getConfig(): {
+        serviceBaseUrl?: string;
+        dataPath?: string;
+        typhoonNums?: string[];
+        sourcePriority?: string[];
+        showForecast?: boolean;
+        fitToExtent?: boolean;
+    } & {
+        serviceBaseUrl?: string;
+        dataPath?: string;
+        typhoonNums?: string[];
+        sourcePriority?: string[];
+        showForecast?: boolean;
+        fitToExtent?: boolean;
+    };
+    add(): Promise<void>;
+    getSelectedTyphoonNums(list: TyphoonListItem[]): string[];
+    getPrimarySource(detail: TyphoonDetail, kind: TrackKind): string;
+    getLastPoint(points: TyphoonPoint[]): TyphoonPoint;
+    findForecastBasePoint(obsPoints: TyphoonPoint[], forecastPoint: TyphoonPoint | undefined): TyphoonPoint;
+    getForecastAnchorPoint(detail: TyphoonDetail, sourceName: string, forecastPoints: TyphoonPoint[], primaryObsSource: string | undefined): TyphoonPoint;
+    render(list: TyphoonListItem[], details: TyphoonDetail[]): void;
+    appendTyphoonFeatures(source: VectorSource, detail: TyphoonDetail, meta: TyphoonListItem | undefined, color: string): void;
+    addLineFeature(source: VectorSource, points: TyphoonPoint[], properties: Record<string, unknown>): void;
+    addPointFeatures(source: VectorSource, points: TyphoonPoint[], properties: Record<string, unknown>): void;
+    addForecastLabelFeature(source: VectorSource, point: TyphoonPoint, properties: Record<string, unknown>): void;
+    createStyle(feature: FeatureLike): Style;
+    getGradeColor(grade: string, fallback: string): string;
+    delete(): void;
+    toggleVisible(visible: boolean): void;
+    updateParams(newOptions: TyphoonLayerOptions): void;
+}
+export {};