@skypath-io/web-sdk 0.4.20 → 0.4.22

package/dist/types/src/core/auth/consts.d.ts

@@ -1,8 +1,3 @@
-export const DEFAULT_API_BASE_URL: "https://api.skypath.io";
-export namespace ALLOWED_PROTOCOLS {
-    let HTTP: string;
-    let HTTPS: string;
-}
 export namespace ALLOWED_HEADERS {
     let AUTH_API_KEY: string;
     let AUTH_TOKEN: string;

package/dist/types/src/core/flow/consts.d.ts

@@ -16,3 +16,15 @@ export namespace DEFAULT_FILTER_VALUES {
     let ALT_FROM: number;
     let ALT_TO: number;
 }
+export const SIZE_TO_RESOLUTION_MAP: {
+    [x: string]: number;
+};
+export namespace POLYGON_TYPE {
+    let SMALL: string;
+    let MEDIUM: string;
+    let LARGE: string;
+    let CORRIDOR: string;
+}
+export const POLYGON_SIZE_TO_ZOOM_THRESHOLD_MAP: {
+    [x: string]: number;
+};

package/dist/types/src/core/geo/geo.d.ts

@@ -6,110 +6,146 @@ export const CORRIDOR_POLYGON_MAX_AREA_NM: 2500000;
 export function validateCorridorArea({ polygon }: {
     polygon: any;
 }): void;
-export namespace POLYGON_TYPE {
-    let SMALL: string;
-    let MEDIUM: string;
-    let LARGE: string;
-    let CORRIDOR: string;
-}
 /**
  * Generates a GeoJSON FeatureCollection from H3 hexagon IDs, adjusting coordinates for antimeridian crossing
  * and ensuring valid longitude and latitude ranges, without mutating the original data.
  *
- * @param {Array<{hexId: string}>} hexagons - Array of objects containing 'hexId' for H3 hexagons.
- * @param {number} [scale=1] - Optional. The scale factor to apply to the hexagons.
+ * @param {Object} params - The function parameter object.
+ * @param {Array<{hexId: string}>} params.hexagons - Array of objects containing 'hexId' for H3 hexagons.
+ * @param {number} [params.scale] - Optional. The scale factor to apply to the hexagons.
  * @returns {Object} A GeoJSON FeatureCollection representing the hexagons.
  */
-export function getHexagonsFeatureCollection(hexagons?: Array<{
-    hexId: string;
-}>, scale?: number): any;
+export function getHexagonsFeatureCollection({ hexagons, scale }: {
+    hexagons: Array<{
+        hexId: string;
+    }>;
+    scale?: number;
+}): any;
 /**
  * Gets H3 hexagon IDs that intersect with the given map bounds at a specified resolution.
  *
- * @param {Array<number>} mapBounds - The bounding box of the map.
- * @param {number} resolution - The H3 resolution to use.
+ * @param {Object} params - The function parameter object.
+ * @param {Array<number>} params.mapBounds - The bounding box of the map.
+ * @param {number} [params.resolution=0] - The H3 resolution to use.
  * @returns {Array<string>} An array of H3 hexagon IDs.
  */
-export function getHexIdsByMapBoundsAndResolution(mapBounds: Array<number>, resolution?: number): Array<string>;
+export function getHexIdsByMapBoundsAndResolution({ mapBounds, resolution }: {
+    mapBounds: Array<number>;
+    resolution?: number;
+}): Array<string>;
 /**
  * Gets viewport H3 hexagon IDs from a Mapbox map instance.
  *
- * @param {object} map - The Mapbox map instance.
- * @param {number} [resolution] - Optional. The H3 resolution to use.
+ * @param {Object} params - The function parameter object.
+ * @param {Object} params.map - The Mapbox map instance.
+ * @param {number} [params.resolution] - Optional, The H3 resolution to use.
  * @returns {Array<string>} An array of H3 hexagon IDs.
  */
-export function getHexIdsFromMapboxMap(map: object, resolution?: number): Array<string>;
+export function getHexIdsFromMapboxMap({ map, resolution }: {
+    map: any;
+    resolution?: number;
+}): Array<string>;
 /**
  * Gets H3 hexagon IDs that intersect with the given polygon at a specified resolution.
  *
- * @param {Array<Array<number>>} polygon
- * @param {number} resolution
- * @param {boolean} shouldInvertLatLng
+ * @param {Object} params - The function parameter object.
+ * @param {Array<Array<number>>} params.polygon - The polygon coordinates.
+ * @param {number} [params.resolution=0] - The H3 resolution to use.
+ * @param {boolean} [params.shouldInvertLatLng=true] - Whether to invert latitude and longitude.
  * @returns {Array<string>} An array of H3 hexagon IDs.
  */
-export function getHexIdsByPolygonAndResolution(polygon: Array<Array<number>>, resolution?: number, shouldInvertLatLng?: boolean): Array<string>;
+export function getHexIdsByPolygonAndResolution({ polygon, resolution, shouldInvertLatLng, }: {
+    polygon: Array<Array<number>>;
+    resolution?: number;
+    shouldInvertLatLng?: boolean;
+}): Array<string>;
 /**
  * Gets viewport polygon from a Mapbox map instance.
  *
- * @param {object} map - The Mapbox map instance.
+ * @param {Object} params - The function parameter object.
+ * @param {Object} params.map - The Mapbox map instance.
  * @returns {number[][]} lat lng polygon.
  */
-export function getMapPolygon(map: object): number[][];
+export function getMapPolygon({ map }: {
+    map: any;
+}): number[][];
 /**
  * Inverts the order of longitude and latitude in a coordinate pair.
  *
- * @param {Array<number>} coordinate - The coordinate pair to invert.
+ * @param {Object} params - The function parameter object.
+ * @param {Array<number>} params.coordinate - The coordinate pair to invert.
  * @returns {Array<number>} The inverted coordinate pair.
  */
-export function invertLatLng([lng, lat]: Array<number>): Array<number>;
+export function invertLatLng({ coordinate }: {
+    coordinate: Array<number>;
+}): Array<number>;
 /**
  * Adjusts the longitude of geographical coordinates in an array to account for antimeridian crossing.
  * The antimeridian is a meridian at 180 degrees longitude, crossing which requires adjusting coordinates
  * for continuity in geographical data representation.
  *
- * @param {Array<Array<number>>} coordinates - An array of coordinates, where each coordinate is a cortege of 2 numbers. The first element in each coordinate array is expected to be the longitude.
- * @returns {Array<Array<number>>} A new array with adjusted coordinates `Array<[number, number]>`.
- */
-export function adjustAntiMeridianCrossing(coordinates: Array<Array<number>>): Array<Array<number>>;
+ * @param {Object} coordinates - An object containing an array of coordinates.
+ * @param {Array<Array<number>>} coordinates.coordinates - An array of coordinates, where each coordinate is a cortege of 2 numbers. The first element in each coordinate array is expected to be the longitude.
+ * */
+export function adjustAntiMeridianCrossing({ coordinates }: {
+    coordinates: Array<Array<number>>;
+}): number[][];
 /**
  * Adjusts the coordinates of a feature to handle antimeridian crossing and ensures
  * that longitude and latitude values are within their valid ranges.
  *
- * @param {Array<Array<number>>} coordinates - The array of coordinates to adjust.
+ * @param {Object} params - The function parameter object.
+ * @param {Array<Array<number>>} params.coordinates - The array of coordinates to adjust.
  * @returns {Array<Array<number>>} The adjusted array of coordinates.
  */
-export function adjustFeatureCoordinates(coordinates: Array<Array<number>>): Array<Array<number>>;
+export function adjustFeatureCoordinates({ coordinates }: {
+    coordinates: Array<Array<number>>;
+}): Array<Array<number>>;
 /**
  * Convert a single H3 hexagon to a `Polygon` GEOJson feature
  *
- * @param  {string} h3Index   Hexagon index
- * @param  {object} [properties] Optional feature properties
- * @return {object}             GeoJSON Feature object
+ * @param {Object} params - The function parameter object.
+ * @param {string} params.h3Index - Hexagon index.
+ * @param {Object} [params.properties] - Optional feature properties.
+ * @returns {Object} GeoJSON Feature object.
  */
-export function h3ToFeature(h3Index: string, properties?: object): object;
+export function h3ToFeature({ h3Index, properties }: {
+    h3Index: string;
+    properties?: any;
+}): any;
 /**
- * Convert a set of H3 hexagons to a GeoJSON `FeatureCollection` with each hexagon
+ * Converts a set of H3 hexagons to a GeoJSON `FeatureCollection` with each hexagon
  * in a separate `Polygon` feature with optional properties.
  *
- * @param  {Array<string>} hexagons Hexagon addresses
- * @param  {Function} [getProperties] Optional function returning properties for a hexagon: f(h3Index) => Object
- * @return {Object} GeoJSON FeatureCollection object
+ * @param {Object} params - The function parameter object.
+ * @param {Array<string>} params.hexagons - Hexagon addresses.
+ * @param {Function} [params.getProperties] - Optional function returning properties for a hexagon: f(h3Index) => Object.
+ * @returns {Object} GeoJSON FeatureCollection object.
  */
-export function h3SetToFeatureCollection(hexagons: Array<string>, getProperties?: Function): any;
+export function h3SetToFeatureCollection({ hexagons, getProperties }: {
+    hexagons: Array<string>;
+    getProperties?: Function;
+}): any;
 /**
  * Normalizes the coordinates of a polygon or line string to account for antimeridian crossing.
  *
- * @param {Array<Array<number>>} array - The array of coordinates to normalize.
+ * @param {Object} props - The function parameter object.
+ * @param {Array<Array<number>>} props.coordinates - The array of coordinates to normalize.
  * @returns {Array<Array<number>>} The normalized array of coordinates.
  */
-export function normalizeAntiMeridian(array: Array<Array<number>>): Array<Array<number>>;
+export function normalizeAntiMeridian({ coordinates }: {
+    coordinates: Array<Array<number>>;
+}): Array<Array<number>>;
 /**
  * Ensures longitude and latitude values are within their valid ranges.
  *
- * @param {Array<number>} coordinate - The [longitude, latitude] pair to adjust.
+ * @param {Object} props - The function parameter object.
+ * @param {Array<number>} props.coordinate - The [longitude, latitude] pair to adjust.
  * @returns {Array<number>} The adjusted [longitude, latitude] pair.
  */
-export function clampCoordinates([lng, lat]: Array<number>): Array<number>;
+export function clampCoordinates({ coordinate }: {
+    coordinate: Array<number>;
+}): Array<number>;
 /**
  * Filters hexagons (observations, ADS-B) data based on provided filters.
  *
@@ -200,21 +236,42 @@ export function getZoomLevel({ polygon, precision }: {
     polygon: Array<Array<number>>;
     precision?: number;
 }): number;
-export function getPolygonSize(polygon: any, mapping?: {
-    [x: string]: number;
+/**
+ * Determines the size of a polygon based on its zoom level.
+ *
+ * @param {Object} params - The function parameter object.
+ * @param {Array<Array<number>>} params.polygon - The polygon coordinates.
+ * @param {Object} [params.mapping] - The mapping of polygon types to zoom level thresholds.
+ * @returns {string} The polygon size type.
+ */
+export function getPolygonSize({ polygon, mapping, }: {
+    polygon: Array<Array<number>>;
+    mapping?: any;
 }): string;
 /**
  * Get mercator center from bbox
  *
- * @param {number[]} bbox - [minLon, minLat, maxLon, maxLat]
+ *  @param {Object} params - The function parameter object.
+ *  @param {number[]} params.bbox - [minLon, minLat, maxLon, maxLat]
  * @returns {number[]} [lat, lon]
  */
-export function getMercatorCenterFromBbox(bbox: number[]): number[];
+export function getMercatorCenterFromBbox({ bbox }: {
+    bbox: number[];
+}): number[];
+/**
+ * Gets the middle area of a polygon by extending it based on the resolution and extension factor.
+ *
+ * @param {Object} params - The function parameter object.
+ * @param {Array<Array<number>>} params.polygon - The polygon coordinates.
+ * @param {number} params.resolution - The resolution to use.
+ * @param {number} params.extensionFactor - The factor by which to extend the polygon.
+ * @returns {Array<Array<number>>} The extended polygon coordinates.
+ */
 export function getMiddleArea({ polygon, resolution, extensionFactor }: {
-    polygon: any;
-    resolution: any;
-    extensionFactor: any;
-}): number[][];
+    polygon: Array<Array<number>>;
+    resolution: number;
+    extensionFactor: number;
+}): Array<Array<number>>;
 /**
  * Groups hexagons by `hexId` and selects the most severe (highest `sev`) for each group.
  *
@@ -225,4 +282,13 @@ export function getMiddleArea({ polygon, resolution, extensionFactor }: {
 export function groupByHexIdAndSelectMostSevere({ hexagons }: {
     hexagons: any[];
 }): any;
-export function squareMetersToNauticalMiles(squareMeters: any): number;
+/**
+ * Converts an area from square meters to nautical miles.
+ *
+ * @param {Object} params - The function parameter object.
+ * @param {number} params.squareMeters - The area in square meters.
+ * @returns {number} The area in nautical miles.
+ */
+export function squareMetersToNauticalMiles({ squareMeters }: {
+    squareMeters: number;
+}): number;

package/dist/types/src/core/utils/utils.d.ts

@@ -1,28 +1,41 @@
 /**
  * Debounces a function to prevent it from being called multiple times within a specified delay.
  *
- * @param {Function} fn - The function to debounce.
- * @param {number} delay - The delay in milliseconds.
+ * @param {Object} params - The parameters.
+ * @param {Function} params.fn - The function to debounce.
+ * @param {number} params.delay - The delay in milliseconds.
  * @returns {Function} - The debounced function.
  */
-export function debounce(fn: Function, delay: number): Function;
+export function debounce({ fn, delay }: {
+    fn: Function;
+    delay: number;
+}): Function;
 /**
  * Throttles a function to prevent it from being called multiple times within a specified delay.
  *
- * @param {Function} fn - The function to throttle.
- * @param {number} delay - The delay in milliseconds.
+ * @param {Object} params - The parameters.
+ * @param {Function} params.fn - The function to throttle.
+ * @param {number} params.delay - The delay in milliseconds.
  * @returns {Function} - The throttled function.
  */
-export function throttle(fn: Function, delay: number): Function;
+export function throttle({ fn, delay }: {
+    fn: Function;
+    delay: number;
+}): Function;
 /**
  * Merges two arrays of objects by a specified property.
  *
- * @param {object[]} target - target array of objects
- * @param {object[]} source - source array of objects
- * @param {string} propName - the prop name of the object to marge by
- * @returns {object[]}
+ * @param {Object} params - The parameters.
+ * @param {Object[]} params.target - The target array of objects.
+ * @param {Object[]} params.source - The source array of objects.
+ * @param {string} params.propName - The property name to merge by.
+ * @returns {Object[]} The merged array of objects.
  */
-export function mergeByProperty(target: object[], source: object[], propName: string): object[];
+export function mergeByProperty({ target, source, propName }: {
+    target: any[];
+    source: any[];
+    propName: string;
+}): any[];
 /**
  * Builds a data key from components.
  * @param {object} options
@@ -57,18 +70,57 @@ export function mapAircraftIcaoToAircraftType({ icao, mapping }: {
     icao: string;
     mapping: object[];
 }): string;
-export function isUndefined(value: any): boolean;
-export function isFunction(fn: any): boolean;
-export function isObject(value: any): boolean;
-export function isChanged(current: any, next: any): any;
-export function getTimer(time: any): {
-    run: (callback: any) => void;
-    cancel: () => void;
-};
+export function isUndefined({ value }: {
+    value: any;
+}): boolean;
+export function isFunction({ fn }: {
+    fn: any;
+}): boolean;
+export function isObject({ value }: {
+    value: any;
+}): boolean;
+/**
+ * Checks if there are any changes between the current and next values.
+ *
+ * @param {Object} params - The function parameter object.
+ * @param {*} params.current - The current value.
+ * @param {*} params.next - The next value.
+ * @returns {boolean} - Returns true if there are changes, otherwise false.
+ */
+export function isChanged({ current, next }: {
+    current: any;
+    next: any;
+}): boolean;
+/**
+ * Creates a timer with run and cancel methods.
+ *
+ * @param {Object} params - The function parameter object.
+ * @param {number} params.time - The time in milliseconds for the timer.
+ * @returns {Object} - An object with run and cancel methods.
+ */
+export function getTimer({ time }: {
+    time: number;
+}): any;
+/**
+ * Gets the fields that have changed between the current and next objects.
+ *
+ * @param {Object} params - The function parameter object.
+ * @param {Object} params.current - The current object.
+ * @param {Object} params.next - The next object.
+ * @returns {Set<string>} - A set of changed field names.
+ */
 export function getChangedFields({ current, next }: {
     current: any;
     next: any;
-}): Set<any>;
+}): Set<string>;
+/**
+ * Merges two objects, excluding properties with undefined values from the next object.
+ *
+ * @param {Object} params - The function parameter object.
+ * @param {Object} params.current - The current object.
+ * @param {Object} params.next - The next object.
+ * @returns {Object} - The merged object.
+ */
 export function mergeWithoutUndefined({ current, next }: {
     current: any;
     next: any;

package/dist/types/src/features/adsb/consts.d.ts

@@ -1,15 +1,6 @@
 export namespace PATHS {
     let DATA: string;
 }
-export namespace DEFAULT_FILTER_VALUES {
-    let HOURS_AGO: number;
-    let SEVERITY: number;
-    let ALT_FROM: number;
-    let ALT_TO: number;
-}
-export const SIZE_TO_RESOLUTION_MAP: {
-    [x: string]: number;
-};
 export const SIZE_TO_MIN_SEVERITY_MAP: {
     [x: string]: number;
 };

package/dist/types/src/features/adsb/utils.d.ts

@@ -9,6 +9,5 @@ export function mapPolygonToHexIds({ polygon, polygonSize }: {
     hexIds: string[];
     childCells: string[];
 };
-export function mapReportsArrayToReportsObject(reports: any): any;
 export function storeToResult(store: any, selector: any, options?: {}): any;
 export function mapResponseToReportsArray(response: any): any;

package/dist/types/src/features/nowcasting/consts.d.ts

@@ -1,5 +1,4 @@
 export const DEFAULT_INTERVAL_TIME_MS: number;
-export const DEFAULT_RESOLUTION: 0;
 export const DEFAULT_MAP_DISPLAY_RESOLUTION: 5;
 export namespace PATHS {
     let INFO: string;

package/dist/types/src/features/observations/consts.d.ts

@@ -1,15 +1,6 @@
 export namespace PATHS {
     let DATA: string;
 }
-export namespace DEFAULT_FILTER_VALUES {
-    let HOURS_AGO: number;
-    let SEVERITY: number;
-    let ALT_FROM: number;
-    let ALT_TO: number;
-}
-export const SIZE_TO_RESOLUTION_MAP: {
-    [x: string]: number;
-};
 export const SIZE_TO_MIN_SEVERITY_MAP: {
     [x: string]: number;
 };
@@ -56,22 +47,10 @@ export namespace SEVERITY {
 }
 export const MAX_ALT: 52;
 export const MIN_ALT: 5;
-export const UPDATE_INTERVAL_MS: number;
-export const GLOBAL_OBSERVATION_DATA_EXPIRY_SEC: number;
-export const HEXAGON_OBSERVATION_DATA_EXPIRY_MS: number;
 export const DEFAULT_RESOLUTION: 1;
 export const MAP_RESOLUTION: 5;
-export namespace FLOW_OPERATION_MODES {
-    let DEFAULT: string;
-    let CORRIDOR: string;
-}
 export namespace LARGE_POLYGON_HANDLING_BEHAVIOR {
     let IGNORE: string;
     let USE_MIDDLE_AREA: string;
     let EXCLUDE_SMOOTH_SEVERITY: string;
 }
-export const MIDDLE_AREA_EXTENSION_FACTOR: 4;
-export namespace ZOOM_LEVEL_THRESHOLDS {
-    let PREVENT_FETCHING: number;
-    let LARGE_POLYGON_FETCHING: number;
-}

package/dist/types/src/features/observations/utils.d.ts

@@ -14,7 +14,6 @@ export function mapPolygonToHexIds({ polygon, polygonSize }: {
     hexIds: string[];
     childCells: string[];
 };
-export function mapReportsArrayToReportsObject(reports: any): any;
 export function storeToResult(store: any, selector: any, options?: {}): any;
 export function mapResponseToReportsArray(response: any): any;
 export function buildObservationsData(data: any): {

package/dist/types/src/features/oneLayer/consts.d.ts

@@ -1,15 +1,6 @@
 export namespace PATHS {
     let DATA: string;
 }
-export namespace DEFAULT_FILTER_VALUES {
-    let HOURS_AGO: number;
-    let SEVERITY: number;
-    let ALT_FROM: number;
-    let ALT_TO: number;
-}
-export const SIZE_TO_RESOLUTION_MAP: {
-    [x: string]: number;
-};
 export const SIZE_TO_MIN_SEVERITY_MAP: {
     [x: string]: number;
 };
@@ -19,13 +10,12 @@ export const SIZE_TO_EXTENSION_FACTOR_MAP: {
 export const DEBOUNCE_TIME_SEC: number;
 export const REFRESH_TIME_SEC: number;
 export namespace CONFIG_KEYS {
-    export let POLYGON: string;
-    export let IS_CORRIDOR_MODE: string;
-    export let AIRCRAFT_CATEGORY: string;
-    let HOURS_AGO_1: string;
-    export { HOURS_AGO_1 as HOURS_AGO };
-    export let FORECAST_TS: string;
-    export let NOWCASTING_ALT: string;
+    let POLYGON: string;
+    let IS_CORRIDOR_MODE: string;
+    let AIRCRAFT_CATEGORY: string;
+    let HOURS_AGO: string;
+    let FORECAST_TS: string;
+    let NOWCASTING_ALT: string;
 }
 export namespace AIRCRAFT_CATEGORY {
     let C10: string;
@@ -46,31 +36,7 @@ export namespace HISTORY_HOURS {
     let twoHours: string;
     let fourHours: string;
 }
-export namespace SEVERITY {
-    let smooth: number;
-    let light: number;
-    let lightModerate: number;
-    let moderate: number;
-    let moderateSevere: number;
-}
 export const MAX_ALT: 52;
 export const MIN_ALT: 5;
-export const UPDATE_INTERVAL_MS: number;
-export const GLOBAL_OBSERVATION_DATA_EXPIRY_SEC: number;
-export const HEXAGON_OBSERVATION_DATA_EXPIRY_MS: number;
 export const DEFAULT_RESOLUTION: 1;
 export const MAP_RESOLUTION: 5;
-export namespace FLOW_OPERATION_MODES {
-    let DEFAULT: string;
-    let CORRIDOR: string;
-}
-export namespace LARGE_POLYGON_HANDLING_BEHAVIOR {
-    let IGNORE: string;
-    let USE_MIDDLE_AREA: string;
-    let EXCLUDE_SMOOTH_SEVERITY: string;
-}
-export const MIDDLE_AREA_EXTENSION_FACTOR: 4;
-export namespace ZOOM_LEVEL_THRESHOLDS {
-    let PREVENT_FETCHING: number;
-    let LARGE_POLYGON_FETCHING: number;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skypath-io/web-sdk",
-  "version": "0.4.20",
+  "version": "0.4.22",
   "type": "module",
   "main": "dist/bundle.cjs.js",
   "module": "dist/bundle.es.js",
@@ -48,9 +48,9 @@
     "lint-staged": "^15.2.2",
     "nodemon": "^3.1.2",
     "prettier": "^3.2.5",
-    "rollup": "^4.16.4",
+    "rollup": "^4.22.4",
     "typescript": "^5.4.5",
-    "vitest": "^1.5.1"
+    "vitest": "^3.1.1"
   },
   "dependencies": {
     "@datadog/browser-logs": "^6.0.0",