feat: adding the option to handle polar night and midnight sun cases

.gitignore

@@ -1,2 +1,3 @@
 node_modules/
-coverage/
+coverage/
+.idea

Adhan.d.ts

@@ -16,7 +16,7 @@ export class PrayerTimes {
 }
 
 export class CalculationParameters {
-  constructor(fajrAngle: number, ishaAngle: number, ishaInterval: number, methodName?: string)
+  constructor(methodName: string|undefined|null, fajrAngle: number, ishaAngle: number, ishaInterval: number, maghribAngle: number)
 
   readonly method: string;
   fajrAngle: number;
@@ -84,3 +84,8 @@ export enum HighLatitudeRule {
   TwilightAngle
 }
 
+export enum PolarCircleResolution {
+  aqrabBalad,
+  aqrabYaum,
+  unresolved
+}

src/Adhan.js

@@ -5,19 +5,21 @@ import { Madhab } from './Madhab';
 import HighLatitudeRule from './HighLatitudeRule';
 import CalculationMethod from './CalculationMethod';
 import CalculationParameters from './CalculationParameters';
-import qibla from './Qibla';
+import Qibla from './Qibla';
 import SunnahTimes from './SunnahTimes';
+import { PolarCircleResolution } from './PolarCircleResolution';
 
 const adhan = {
-    Prayer: Prayer,
-    Madhab: Madhab,
-    HighLatitudeRule: HighLatitudeRule,
-    Coordinates: Coordinates,
-    CalculationParameters: CalculationParameters,
-    CalculationMethod: CalculationMethod,
-    PrayerTimes: PrayerTimes,
-    SunnahTimes: SunnahTimes,
-    Qibla: qibla
+    Prayer,
+    Madhab,
+    HighLatitudeRule,
+    Coordinates,
+    CalculationParameters,
+    CalculationMethod,
+    PrayerTimes,
+    SunnahTimes,
+    Qibla,
+    PolarCircleResolution,
 };
 
 export default adhan;

src/CalculationParameters.js

@@ -1,5 +1,6 @@
 import { Madhab } from './Madhab';
 import HighLatitudeRule from './HighLatitudeRule';
+import { PolarCircleResolution } from './PolarCircleResolution';
 
 export default class CalculationParameters {
     constructor(methodName, fajrAngle, ishaAngle, ishaInterval, maghribAngle) {
@@ -12,6 +13,7 @@ export default class CalculationParameters {
         this.highLatitudeRule = HighLatitudeRule.MiddleOfTheNight;
         this.adjustments = { fajr: 0, sunrise: 0, dhuhr: 0, asr: 0, maghrib: 0, isha: 0 };
         this.methodAdjustments = { fajr: 0, sunrise: 0, dhuhr: 0, asr: 0, maghrib: 0, isha: 0 };
+        this.polarCircleResolution = PolarCircleResolution.unresolved;
     }
 
     nightPortions() {

src/DateUtils.js

@@ -36,3 +36,7 @@ export function dayOfYear(date) {
 
     return returnedDayOfYear;
 }
+
+export function isValidDate(date) {
+    return date instanceof Date && !isNaN(date.valueOf());
+}

src/PolarCircleResolution.js

@@ -0,0 +1,78 @@
+import SolarTime from './SolarTime';
+import { dateByAddingDays } from './DateUtils';
+
+export const PolarCircleResolution = {
+  aqrabBalad: 'aqrab-balad',
+  aqrabYaum: 'aqrab-yaum',
+  unresolved: 'unresolved'
+};
+
+const LATITUDE_VARIATION_STEP = 0.5; // Degrees to add/remove at each resolution step
+const UNSAFE_LATITUDE = 65; // Based on https://en.wikipedia.org/wiki/Midnight_sun
+
+const isValidSolarTime = (solarTime) => solarTime && !isNaN(solarTime.sunrise) && !isNaN(solarTime.sunset);
+
+const aqrabYaumResolver = (coordinates, date, daysAdded = 1, direction = 1) => {
+  if (daysAdded > Math.ceil(365 / 2)) {
+    return null;
+  }
+  const testDate = new Date(date.getTime());
+  testDate.setDate(testDate.getDate() + (direction * daysAdded));
+  const tomorrow = dateByAddingDays(testDate, 1);
+  const solarTime = new SolarTime(testDate, coordinates);
+  const tomorrowSolarTime = new SolarTime(tomorrow, coordinates);
+
+  if (!isValidSolarTime(solarTime) || !isValidSolarTime(tomorrowSolarTime)) {
+    return aqrabYaumResolver(coordinates, date, daysAdded + (direction > 0 ? 0 : 1), -direction);
+  }
+
+  return {
+    date,
+    tomorrow,
+    coordinates,
+    solarTime,
+    tomorrowSolarTime,
+  };
+}
+
+const aqrabBaladResolver = (coordinates, date, latitude) => {
+  const solarTime = new SolarTime(date, { ...coordinates, latitude });
+  const tomorrow = dateByAddingDays(date, 1);
+  const tomorrowSolarTime = new SolarTime(tomorrow, { ...coordinates, latitude });
+  if (!isValidSolarTime(solarTime) || !isValidSolarTime(tomorrowSolarTime)) {
+    return (Math.abs(latitude) >= UNSAFE_LATITUDE) ?
+      aqrabBaladResolver(coordinates, date, latitude - Math.sign(latitude) * LATITUDE_VARIATION_STEP)
+      : null;
+  }
+
+  return {
+    date,
+    tomorrow,
+    coordinates: { latitude, longitude: coordinates.longitude },
+    solarTime,
+    tomorrowSolarTime,
+  };
+};
+
+export const polarCircleResolvedValues = (resolver, date, coordinates) => {
+  const defaultReturn = {
+    date,
+    tomorrow: dateByAddingDays(date, 1),
+    coordinates,
+    solarTime: new SolarTime(date, coordinates),
+    tomorrowSolarTime: new SolarTime(dateByAddingDays(date, 1), coordinates),
+  };
+
+  switch (resolver) {
+    case PolarCircleResolution.aqrabYaum: {
+      return aqrabYaumResolver(coordinates, date) || defaultReturn;
+    }
+    case PolarCircleResolution.aqrabBalad: {
+      const { latitude } = coordinates;
+      return aqrabBaladResolver(coordinates, date, latitude - (Math.sign(latitude) * LATITUDE_VARIATION_STEP)) || defaultReturn;
+    }
+    default: {
+      return defaultReturn;
+    }
+  }
+};