All files / src/impl conversions.js

91.76% Statements 78/85
83.33% Branches 35/42
100% Functions 13/13
91.67% Lines 77/84
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152    32x 32x     102x 102x         97x         97x 97x 97x       95x       31x 31x 31x 31x                 78x 78x 78x   78x     78x 1x 1x 77x 2x 2x   75x     78x       24x 24x 24x 24x     24x 2x 2x 22x 1x 1x   21x     24x   24x       17x 17x   17x       7x 7x   7x       19x 19x 19x   19x   19x 1x 18x 1x 17x       6x 6x   6x   6x   6x       372x 372x 372x   372x   372x 2x 370x 1x 369x       392x 392x 392x 392x   392x 1x 391x   391x   391x   391x      
import { Util } from './util';
 
const nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
  leapLadder = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
 
function dayOfWeek(year, month, day) {
  const js = new Date(Date.UTC(year, month - 1, day)).getUTCDay();
  return js === 0 ? 7 : js;
}
 
function lastWeekNumber(weekYear) {
  const p1 =
      (weekYear +
        Math.floor(weekYear / 4) -
        Math.floor(weekYear / 100) +
        Math.floor(weekYear / 400)) %
      7,
    last = weekYear - 1,
    p2 = (last + Math.floor(last / 4) - Math.floor(last / 100) + Math.floor(last / 400)) % 7;
  return p1 === 4 || p2 === 3 ? 53 : 52;
}
 
function computeOrdinal(year, month, day) {
  return day + (Util.isLeapYear(year) ? leapLadder : nonLeapLadder)[month - 1];
}
 
function uncomputeOrdinal(year, ordinal) {
  const table = Util.isLeapYear(year) ? leapLadder : nonLeapLadder,
    month0 = table.findIndex(i => i < ordinal),
    day = ordinal - table[month0];
  return { month: month0 + 1, day };
}
 
/**
 * @private
 */
 
export class Conversions {
  static gregorianToWeek(gregObj) {
    const { year, month, day } = gregObj,
      ordinal = computeOrdinal(year, month, day),
      weekday = dayOfWeek(year, month, day);
 
    let weekNumber = Math.floor((ordinal - weekday + 10) / 7),
      weekYear;
 
    if (weekNumber < 1) {
      weekYear = year - 1;
      weekNumber = lastWeekNumber(weekYear);
    } else if (weekNumber > lastWeekNumber(year)) {
      weekYear = year + 1;
      weekNumber = 1;
    } else {
      weekYear = year;
    }
 
    return Object.assign({ weekYear, weekNumber, weekday }, Util.timeObject(gregObj));
  }
 
  static weekToGregorian(weekData) {
    const { weekYear, weekNumber, weekday } = weekData,
      weekdayOfJan4 = dayOfWeek(weekYear, 1, 4),
      daysInYear = Util.daysInYear(weekYear);
    let ordinal = weekNumber * 7 + weekday - weekdayOfJan4 - 3,
      year;
 
    if (ordinal < 1) {
      year = weekYear - 1;
      ordinal += Util.daysInYear(year);
    } else if (ordinal > daysInYear) {
      year = weekYear + 1;
      ordinal -= Util.daysInYear(year);
    } else {
      year = weekYear;
    }
 
    const { month, day } = uncomputeOrdinal(year, ordinal);
 
    return Object.assign({ year, month, day }, Util.timeObject(weekData));
  }
 
  static gregorianToOrdinal(gregData) {
    const { year, month, day } = gregData,
      ordinal = computeOrdinal(year, month, day);
 
    return Object.assign({ year, ordinal }, Util.timeObject(gregData));
  }
 
  static ordinalToGregorian(ordinalData) {
    const { year, ordinal } = ordinalData,
      { month, day } = uncomputeOrdinal(year, ordinal);
 
    return Object.assign({ year, month, day }, Util.timeObject(ordinalData));
  }
 
  static hasInvalidWeekData(obj) {
    const validYear = Util.isNumber(obj.weekYear),
      validWeek = Util.numberBetween(obj.weekNumber, 1, lastWeekNumber(obj.weekYear)),
      validWeekday = Util.numberBetween(obj.weekday, 1, 7);
 
    Iif (!validYear) {
      return 'weekYear out of range';
    } else if (!validWeek) {
      return 'week out of range';
    } else if (!validWeekday) {
      return 'weekday out of range';
    } else return false;
  }
 
  static hasInvalidOrdinalData(obj) {
    const validYear = Util.isNumber(obj.year),
      validOrdinal = Util.numberBetween(obj.ordinal, 1, Util.daysInYear(obj.year));
 
    Iif (!validYear) {
      return 'year out of range';
    } else Iif (!validOrdinal) {
      return 'ordinal out of range';
    } else return false;
  }
 
  static hasInvalidGregorianData(obj) {
    const validYear = Util.isNumber(obj.year),
      validMonth = Util.numberBetween(obj.month, 1, 12),
      validDay = Util.numberBetween(obj.day, 1, Util.daysInMonth(obj.year, obj.month));
 
    Iif (!validYear) {
      return 'year out of range';
    } else if (!validMonth) {
      return 'month out of range';
    } else if (!validDay) {
      return 'day out of range';
    } else return false;
  }
 
  static hasInvalidTimeData(obj) {
    const validHour = Util.numberBetween(obj.hour, 0, 23),
      validMinute = Util.numberBetween(obj.minute, 0, 59),
      validSecond = Util.numberBetween(obj.second, 0, 59),
      validMillisecond = Util.numberBetween(obj.millisecond, 0, 999);
 
    if (!validHour) {
      return 'hour out of range';
    } else Iif (!validMinute) {
      return 'minute out of range';
    } else Iif (!validSecond) {
      return 'second out of range';
    } else Iif (!validMillisecond) {
      return 'millisecond out of range';
    } else return false;
  }
}