@mapvx/web-js 4.0.2 → 4.0.3-dev.2

package/dist/es/utils/nav-functions.js

@@ -1,58 +1,17 @@
 const { asin, atan2, cos, sin, pow, sqrt, PI } = Math;
-/**
- * Return the haversine of a number.
- * Haversine formula is a formula that calculates the distance
- * between two points on a sphere given their longitudes and latitudes.
- * @group Utils
- * @see [Haversine Formula](https://en.wikipedia.org/wiki/Haversine_formula)
- * @param angle A numeric expression that contains an angle measured in radians.
- * @returns
- */
 function hav(angle) {
     return sin(angle / 2) * sin(angle / 2);
 }
-/**
- * Converts an angle from degrees to radians.
- * @group Utils
- * @param degrees - The angle in degrees.
- * @returns The angle converted to radians.
- */
 export function toRadians(degrees) {
     return degrees * (PI / 180);
 }
-/**
- * Converts an angle from radians to degrees.
- * @group Utils
- * @param radians - The angle in radians.
- * @returns The angle converted to degrees.
- */
 export function toDegrees(radians) {
     return radians * (180 / PI);
 }
-/**
- * Compare two geographic points.
- * @group Utils
- * @param location - The first point.
- * @param otherLocation - The second point.
- * @returns True if the points are the same, false otherwise.
- */
 export function compareLatLng(location, otherLocation) {
     return location.lat === otherLocation.lat && location.lng === otherLocation.lng;
 }
-/**
- * NavFunctions is a class that contains static methods to calculate distances and angles between geographic points.
- * @group Utils
- */
 export class NavFunctions {
-    /**
-     * Calculate the distance between two geographic points using the haversine formula.
-     *
-     * @see [Haversine Formula](https://en.wikipedia.org/wiki/Haversine_formula)
-     *
-     * @param pointA A geographic point.
-     * @param pointB Another geographic point.
-     * @returns The distance between the two points.
-     */
     static distance(pointA, pointB) {
         const radLatA = toRadians(pointA.lat);
         const radLatB = toRadians(pointB.lat);
@@ -63,13 +22,6 @@ export class NavFunctions {
         const haversine = hav(deltaLat) + cos(radLatA) * cos(radLatB) * hav(deltaLng);
         return 2 * NavFunctions.EARTH_RADIUS * asin(sqrt(haversine));
     }
-    /**
-     *
-     * @param pointA
-     * @param pointB
-     * @param fraction A number between 0 to 1, 0 and 1 inclusive.
-     * @returns
-     */
     static intermediatePointBetween(pointA, pointB, fraction) {
         const radLatA = toRadians(pointA.lat);
         const radLatB = toRadians(pointB.lat);
@@ -90,45 +42,15 @@ export class NavFunctions {
             lng: lng,
         };
     }
-    /**
-     * Calculate the angle of a line between two points.
-     * Relative to NORTH in positive degrees: 0 N, 90 E, 180 S, 270 O
-     * @param source The initial point
-     * @param destination The final
-     * @returns
-     */
     static bearingInDegBetween(source, destination) {
         const inRad = NavFunctions.bearingInRadBetween(source, destination);
         return toDegrees(inRad);
     }
-    /**
-     * Calculate the bearing between two points in radians.
-     * @param source The initial point.
-     * @param destination The final point.
-     * @returns The bearing in radians.
-     */
     static bearingInRadBetween(source, destination) {
         const x = destination.lng - source.lng;
         const y = destination.lat - source.lat;
         return (PI / 2 - atan2(y, x) + 2 * PI) % (2 * PI);
     }
-    /**
-     * Calculate an intermediate angle between two given angles based on a specific fraction.
-     * The function returns an angle that is a certain fraction of the shortest arc between the initial and final angles.
-     *
-     * @remarks
-     *
-     * If the fraction is 0, the function returns the initial angle.
-     *
-     * If the fraction is 1, it returns the final angle.
-     *
-     * For fractions in between, it returns an angle that is a proportional distance between the two angles along the shortest arc.
-     *
-     * @param initialAngle The starting angle specified in degrees.
-     * @param finalAngle The ending angle specified in degrees.
-     * @param fraction A decimal value ranging from 0 to 1 indicating the fraction of the distance between the initial and final angles.
-     * @returns The calculated intermediate angle in degrees, within the range `[0, 360[`.
-     */
     static intermediateAngleBetween(initialAngle, finalAngle, fraction) {
         let delta = ((finalAngle - initialAngle + 180) % 360) - 180;
         if (delta < -180)
@@ -136,8 +58,4 @@ export class NavFunctions {
         return (initialAngle + 360 + delta * fraction) % 360;
     }
 }
-/**
- * The radius of the Earth in meters.
- */
 NavFunctions.EARTH_RADIUS = 6378000;
-//# sourceMappingURL=nav-functions.js.map

package/dist/es/utils/opening-hours-helper.d.ts

@@ -392,4 +392,3 @@ export declare class OpeningHoursHelper {
  * @returns `true` if the schedule represents 24 hours, `false` otherwise.
  */
 export declare function is24Hours(openingTime: OpeningTime): boolean;
-//# sourceMappingURL=opening-hours-helper.d.ts.map