@momo-kits/calendar 0.0.48-rc.2 → 0.0.48

package/LunarDateConverter.ts

@@ -0,0 +1,214 @@
+function Lunar(this: any) {
+  this.isleap = false;
+  this.lunarDay = 0;
+  this.lunarMonth = 0;
+  this.lunarYear = 0;
+}
+
+function Solar(this: any) {
+  this.solarDay = 0;
+  this.solarMonth = 0;
+  this.solarYear = 0;
+}
+
+function LunarSolarConverter(this: any) {
+  this.lunar_month_days = [
+    1887, 0x1694, 0x16aa, 0x4ad5, 0xab6, 0xc4b7, 0x4ae, 0xa56, 0xb52a, 0x1d2a,
+    0xd54, 0x75aa, 0x156a, 0x1096d, 0x95c, 0x14ae, 0xaa4d, 0x1a4c, 0x1b2a,
+    0x8d55, 0xad4, 0x135a, 0x495d, 0x95c, 0xd49b, 0x149a, 0x1a4a, 0xbaa5,
+    0x16a8, 0x1ad4, 0x52da, 0x12b6, 0xe937, 0x92e, 0x1496, 0xb64b, 0xd4a, 0xda8,
+    0x95b5, 0x56c, 0x12ae, 0x492f, 0x92e, 0xcc96, 0x1a94, 0x1d4a, 0xada9, 0xb5a,
+    0x56c, 0x726e, 0x125c, 0xf92d, 0x192a, 0x1a94, 0xdb4a, 0x16aa, 0xad4,
+    0x955b, 0x4ba, 0x125a, 0x592b, 0x152a, 0xf695, 0xd94, 0x16aa, 0xaab5, 0x9b4,
+    0x14b6, 0x6a57, 0xa56, 0x1152a, 0x1d2a, 0xd54, 0xd5aa, 0x156a, 0x96c,
+    0x94ae, 0x14ae, 0xa4c, 0x7d26, 0x1b2a, 0xeb55, 0xad4, 0x12da, 0xa95d, 0x95a,
+    0x149a, 0x9a4d, 0x1a4a, 0x11aa5, 0x16a8, 0x16d4, 0xd2da, 0x12b6, 0x936,
+    0x9497, 0x1496, 0x1564b, 0xd4a, 0xda8, 0xd5b4, 0x156c, 0x12ae, 0xa92f,
+    0x92e, 0xc96, 0x6d4a, 0x1d4a, 0x10d65, 0xb58, 0x156c, 0xb26d, 0x125c,
+    0x192c, 0x9a95, 0x1a94, 0x1b4a, 0x4b55, 0xad4, 0xf55b, 0x4ba, 0x125a,
+    0xb92b, 0x152a, 0x1694, 0x96aa, 0x15aa, 0x12ab5, 0x974, 0x14b6, 0xca57,
+    0xa56, 0x1526, 0x8e95, 0xd54, 0x15aa, 0x49b5, 0x96c, 0xd4ae, 0x149c, 0x1a4c,
+    0xbd26, 0x1aa6, 0xb54, 0x6d6a, 0x12da, 0x1695d, 0x95a, 0x149a, 0xda4b,
+    0x1a4a, 0x1aa4, 0xbb54, 0x16b4, 0xada, 0x495b, 0x936, 0xf497, 0x1496,
+    0x154a, 0xb6a5, 0xda4, 0x15b4, 0x6ab6, 0x126e, 0x1092f, 0x92e, 0xc96,
+    0xcd4a, 0x1d4a, 0xd64, 0x956c, 0x155c, 0x125c, 0x792e, 0x192c, 0xfa95,
+    0x1a94, 0x1b4a, 0xab55, 0xad4, 0x14da, 0x8a5d, 0xa5a, 0x1152b, 0x152a,
+    0x1694, 0xd6aa, 0x15aa, 0xab4, 0x94ba, 0x14b6, 0xa56, 0x7527, 0xd26, 0xee53,
+    0xd54, 0x15aa, 0xa9b5, 0x96c, 0x14ae, 0x8a4e, 0x1a4c, 0x11d26, 0x1aa4,
+    0x1b54, 0xcd6a, 0xada, 0x95c, 0x949d, 0x149a, 0x1a2a, 0x5b25, 0x1aa4,
+    0xfb52, 0x16b4, 0xaba, 0xa95b, 0x936, 0x1496, 0x9a4b, 0x154a, 0x136a5,
+    0xda4, 0x15ac,
+  ];
+
+  this.solar_1_1 = [
+    1887, 0xec04c, 0xec23f, 0xec435, 0xec649, 0xec83e, 0xeca51, 0xecc46,
+    0xece3a, 0xed04d, 0xed242, 0xed436, 0xed64a, 0xed83f, 0xeda53, 0xedc48,
+    0xede3d, 0xee050, 0xee244, 0xee439, 0xee64d, 0xee842, 0xeea36, 0xeec4a,
+    0xeee3e, 0xef052, 0xef246, 0xef43a, 0xef64e, 0xef843, 0xefa37, 0xefc4b,
+    0xefe41, 0xf0054, 0xf0248, 0xf043c, 0xf0650, 0xf0845, 0xf0a38, 0xf0c4d,
+    0xf0e42, 0xf1037, 0xf124a, 0xf143e, 0xf1651, 0xf1846, 0xf1a3a, 0xf1c4e,
+    0xf1e44, 0xf2038, 0xf224b, 0xf243f, 0xf2653, 0xf2848, 0xf2a3b, 0xf2c4f,
+    0xf2e45, 0xf3039, 0xf324d, 0xf3442, 0xf3636, 0xf384a, 0xf3a3d, 0xf3c51,
+    0xf3e46, 0xf403b, 0xf424e, 0xf4443, 0xf4638, 0xf484c, 0xf4a3f, 0xf4c52,
+    0xf4e48, 0xf503c, 0xf524f, 0xf5445, 0xf5639, 0xf584d, 0xf5a42, 0xf5c35,
+    0xf5e49, 0xf603e, 0xf6251, 0xf6446, 0xf663b, 0xf684f, 0xf6a43, 0xf6c37,
+    0xf6e4b, 0xf703f, 0xf7252, 0xf7447, 0xf763c, 0xf7850, 0xf7a45, 0xf7c39,
+    0xf7e4d, 0xf8042, 0xf8254, 0xf8449, 0xf863d, 0xf8851, 0xf8a46, 0xf8c3b,
+    0xf8e4f, 0xf9044, 0xf9237, 0xf944a, 0xf963f, 0xf9853, 0xf9a47, 0xf9c3c,
+    0xf9e50, 0xfa045, 0xfa238, 0xfa44c, 0xfa641, 0xfa836, 0xfaa49, 0xfac3d,
+    0xfae52, 0xfb047, 0xfb23a, 0xfb44e, 0xfb643, 0xfb837, 0xfba4a, 0xfbc3f,
+    0xfbe53, 0xfc048, 0xfc23c, 0xfc450, 0xfc645, 0xfc839, 0xfca4c, 0xfcc41,
+    0xfce36, 0xfd04a, 0xfd23d, 0xfd451, 0xfd646, 0xfd83a, 0xfda4d, 0xfdc43,
+    0xfde37, 0xfe04b, 0xfe23f, 0xfe453, 0xfe648, 0xfe83c, 0xfea4f, 0xfec44,
+    0xfee38, 0xff04c, 0xff241, 0xff436, 0xff64a, 0xff83e, 0xffa51, 0xffc46,
+    0xffe3a, 0x10004e, 0x100242, 0x100437, 0x10064b, 0x100841, 0x100a53,
+    0x100c48, 0x100e3c, 0x10104f, 0x101244, 0x101438, 0x10164c, 0x101842,
+    0x101a35, 0x101c49, 0x101e3d, 0x102051, 0x102245, 0x10243a, 0x10264e,
+    0x102843, 0x102a37, 0x102c4b, 0x102e3f, 0x103053, 0x103247, 0x10343b,
+    0x10364f, 0x103845, 0x103a38, 0x103c4c, 0x103e42, 0x104036, 0x104249,
+    0x10443d, 0x104651, 0x104846, 0x104a3a, 0x104c4e, 0x104e43, 0x105038,
+    0x10524a, 0x10543e, 0x105652, 0x105847, 0x105a3b, 0x105c4f, 0x105e45,
+    0x106039, 0x10624c, 0x106441, 0x106635, 0x106849, 0x106a3d, 0x106c51,
+    0x106e47, 0x10703c, 0x10724f, 0x107444, 0x107638, 0x10784c, 0x107a3f,
+    0x107c53, 0x107e48,
+  ];
+
+  /**
+   * @return {number}
+   */
+  this.GetBitInt = function (data: number, length: number, shift: number) {
+    return (data & (((1 << length) - 1) << shift)) >> shift;
+  };
+
+  // WARNING: Dates before Oct. 1582 are inaccurate
+  /**
+   * @return {number}
+   */
+  this.SolarToInt = function (y: number, m: number, d: number) {
+    m = (m + 9) % 12;
+    y = parseInt(String(y)) - parseInt(String(m / 10));
+    return (
+      365 * y +
+      parseInt(String(y / 4)) -
+      parseInt(String(y / 100)) +
+      parseInt(String(y / 400)) +
+      parseInt(String((m * 306 + 5) / 10)) +
+      (d - 1)
+    );
+  };
+
+  this.SolarFromInt = function (g: number) {
+    let y = parseInt(String((10000 * g + 14780) / 3652425));
+    let ddd =
+      g -
+      (365 * y +
+        parseInt(String(y / 4)) -
+        parseInt(String(y / 100)) +
+        parseInt(String(y / 400)));
+    if (ddd < 0) {
+      y--;
+      ddd =
+        g -
+        (365 * y +
+          parseInt(String(y / 4)) -
+          parseInt(String(y / 100)) +
+          parseInt(String(y / 400)));
+    }
+    const mi = parseInt(String((100 * ddd + 52) / 3060));
+    const mm = ((mi + 2) % 12) + 1;
+    y += parseInt(String((mi + 2) / 12));
+    const dd = ddd - parseInt(String((mi * 306 + 5) / 10)) + 1;
+    // @ts-ignore
+    const solar = new Solar();
+    solar.solarYear = parseInt(String(y));
+    solar.solarMonth = parseInt(String(mm));
+    solar.solarDay = parseInt(String(dd));
+    return solar;
+  };
+
+  this.LunarToSolar = function (lunar: {
+    lunarYear: number;
+    isleap: any;
+    lunarMonth: number;
+    lunarDay: number;
+  }) {
+    const days =
+      this.lunar_month_days[lunar.lunarYear - this.lunar_month_days[0]];
+    const leap = this.GetBitInt(days, 4, 13);
+    let offset = 0;
+    let loopend = leap;
+    if (!lunar.isleap) {
+      if (lunar.lunarMonth <= leap || leap === 0) {
+        loopend = lunar.lunarMonth - 1;
+      } else {
+        loopend = lunar.lunarMonth;
+      }
+    }
+    for (let i = 0; i < loopend; i++) {
+      offset += this.GetBitInt(days, 1, 12 - i) === 1 ? 30 : 29;
+    }
+    offset += lunar.lunarDay;
+
+    const solar11 = this.solar_1_1[lunar.lunarYear - this.solar_1_1[0]];
+
+    const y = this.GetBitInt(solar11, 12, 9);
+    const m = this.GetBitInt(solar11, 4, 5);
+    const d = this.GetBitInt(solar11, 5, 0);
+
+    return this.SolarFromInt(this.SolarToInt(y, m, d) + offset - 1);
+  };
+
+  this.SolarToLunar = function (solar: {
+    solarYear: number;
+    solarMonth: number;
+    solarDay: number;
+  }) {
+    // @ts-ignore
+    const lunar = new Lunar();
+    let index = solar.solarYear - this.solar_1_1[0];
+    const data =
+      (solar.solarYear << 9) | (solar.solarMonth << 5) | solar.solarDay;
+    if (this.solar_1_1[index] > data) {
+      index--;
+    }
+    const solar11 = this.solar_1_1[index];
+    const y = this.GetBitInt(solar11, 12, 9);
+    const m = this.GetBitInt(solar11, 4, 5);
+    const d = this.GetBitInt(solar11, 5, 0);
+    let offset =
+      this.SolarToInt(solar.solarYear, solar.solarMonth, solar.solarDay) -
+      this.SolarToInt(y, m, d);
+
+    const days = this.lunar_month_days[index];
+    const leap = this.GetBitInt(days, 4, 13);
+
+    const lunarY = index + this.solar_1_1[0];
+    let lunarM = 1;
+    offset += 1;
+
+    for (let i = 0; i < 13; i++) {
+      const dm = this.GetBitInt(days, 1, 12 - i) === 1 ? 30 : 29;
+      if (offset > dm) {
+        lunarM++;
+        offset -= dm;
+      } else {
+        break;
+      }
+    }
+    const lunarD = parseInt(String(offset));
+    lunar.lunarYear = lunarY;
+    lunar.lunarMonth = lunarM;
+    lunar.isleap = false;
+    if (leap !== 0 && lunarM > leap) {
+      lunar.lunarMonth = lunarM - 1;
+      if (lunarM === leap + 1) {
+        lunar.isleap = true;
+      }
+    }
+
+    lunar.lunarDay = lunarD;
+    return lunar;
+  };
+}
+
+export default LunarSolarConverter;

package/{src/LunarService.js → LunarService.ts}

@@ -1,100 +1,102 @@
-const removeFractionalPart = number => parseInt(number);
+const removeFractionalPart = (number: string | number) =>
+  parseInt(String(number));
 
 /* Compute the (integral) Julian day number of day dd/mm/yyyy, i.e., the number
  * of days between 1/1/4713 BC (Julian calendar) and dd/mm/yyyy.
  * Formula from http://www.tondering.dk/claus/calendar.html
  */
-const jdFromDate = (dd, mm, yy) => {
+const jdFromDate = (dd: number, mm: number, yy: number) => {
   let a, y, m, jd;
   a = removeFractionalPart((14 - mm) / 12);
   y = yy + 4800 - a;
   m = mm + 12 * a - 3;
-  jd = dd + removeFractionalPart((153 * m + 2) / 5) + 365 * y + removeFractionalPart(y / 4) - removeFractionalPart(y / 100) +
-    removeFractionalPart(y / 400) - 32045;
+  jd =
+    dd +
+    removeFractionalPart((153 * m + 2) / 5) +
+    365 * y +
+    removeFractionalPart(y / 4) -
+    removeFractionalPart(y / 100) +
+    removeFractionalPart(y / 400) -
+    32045;
   if (jd < 2299161) {
-    jd = dd + removeFractionalPart((153 * m + 2) / 5) + 365 * y + removeFractionalPart(y / 4) - 32083;
+    jd =
+      dd +
+      removeFractionalPart((153 * m + 2) / 5) +
+      365 * y +
+      removeFractionalPart(y / 4) -
+      32083;
   }
   return jd;
-}
-
-/* Convert a Julian day number to day/month/year. Parameter jd is an integer */
-const jdToDate = (jd) => {
-  let a, b, c, d, e, m, day, month, year;
-  if (jd > 2299160) { // After 5/10/1582, Gregorian calendar
-    a = jd + 32044;
-    b = removeFractionalPart((4 * a + 3) / 146097);
-    c = a - removeFractionalPart((b * 146097) / 4);
-  } else {
-    b = 0;
-    c = jd + 32082;
-  }
-  d = removeFractionalPart((4 * c + 3) / 1461);
-  e = c - removeFractionalPart((1461 * d) / 4);
-  m = removeFractionalPart((5 * e + 2) / 153);
-  day = e - removeFractionalPart((153 * m + 2) / 5) + 1;
-  month = m + 3 - 12 * removeFractionalPart(m / 10);
-  year = b * 100 + d - 4800 + removeFractionalPart(m / 10);
-  return [day, month, year];
-}
+};
 
 /* Compute the time of the k-th new moon after the new moon of 1/1/1900 13:52 UCT
  * (measured as the number of days since 1/1/4713 BC noon UCT, e.g., 2451545.125 is 1/1/2000 15:00 UTC).
  * Returns a floating number, e.g., 2415079.9758617813 for k=2 or 2414961.935157746 for k=-2
  * Algorithm from: "Astronomical Algorithms" by Jean Meeus, 1998
  */
-const NewMoon = (k) => {
+const NewMoon = (k: number) => {
   let T, T2, T3, dr, Jd1, M, Mpr, F, C1, deltat, JdNew;
   T = k / 1236.85; // Time in Julian centuries from 1900 January 0.5
   T2 = T * T;
   T3 = T2 * T;
   dr = Math.PI / 180;
   Jd1 = 2415020.75933 + 29.53058868 * k + 0.0001178 * T2 - 0.000000155 * T3;
-  Jd1 = Jd1 + 0.00033 *
-    Math.sin((166.56 + 132.87 * T - 0.009173 * T2) * dr); // Mean new moon
-  M = 359.2242 + 29.10535608 * k - 0.0000333 * T2 -
-    0.00000347 * T3; // Sun's mean anomaly
-  Mpr = 306.0253 + 385.81691806 * k + 0.0107306 * T2 +
-    0.00001236 * T3; // Moon's mean anomaly
-  F = 21.2964 + 390.67050646 * k - 0.0016528 * T2 -
-    0.00000239 * T3; // Moon's argument of latitude
-  C1 = (0.1734 - 0.000393 * T) * Math.sin(M * dr) + 0.0021 * Math.sin(2 * dr * M);
+  Jd1 = Jd1 + 0.00033 * Math.sin((166.56 + 132.87 * T - 0.009173 * T2) * dr); // Mean new moon
+  M = 359.2242 + 29.10535608 * k - 0.0000333 * T2 - 0.00000347 * T3; // Sun's mean anomaly
+  Mpr = 306.0253 + 385.81691806 * k + 0.0107306 * T2 + 0.00001236 * T3; // Moon's mean anomaly
+  F = 21.2964 + 390.67050646 * k - 0.0016528 * T2 - 0.00000239 * T3; // Moon's argument of latitude
+  C1 =
+    (0.1734 - 0.000393 * T) * Math.sin(M * dr) + 0.0021 * Math.sin(2 * dr * M);
   C1 = C1 - 0.4068 * Math.sin(Mpr * dr) + 0.0161 * Math.sin(dr * 2 * Mpr);
   C1 = C1 - 0.0004 * Math.sin(dr * 3 * Mpr);
   C1 = C1 + 0.0104 * Math.sin(dr * 2 * F) - 0.0051 * Math.sin(dr * (M + Mpr));
-  C1 = C1 - 0.0074 * Math.sin(dr * (M - Mpr)) + 0.0004 * Math.sin(dr * (2 * F + M));
-  C1 = C1 - 0.0004 * Math.sin(dr * (2 * F - M)) - 0.0006 * Math.sin(dr * (2 * F + Mpr));
-  C1 = C1 + 0.0010 * Math.sin(dr * (2 * F - Mpr)) + 0.0005 * Math.sin(dr * (2 * Mpr + M));
+  C1 =
+    C1 -
+    0.0074 * Math.sin(dr * (M - Mpr)) +
+    0.0004 * Math.sin(dr * (2 * F + M));
+  C1 =
+    C1 -
+    0.0004 * Math.sin(dr * (2 * F - M)) -
+    0.0006 * Math.sin(dr * (2 * F + Mpr));
+  C1 =
+    C1 +
+    0.001 * Math.sin(dr * (2 * F - Mpr)) +
+    0.0005 * Math.sin(dr * (2 * Mpr + M));
   if (T < -11) {
-    deltat = 0.001 + 0.000839 * T + 0.0002261 * T2 - 0.00000845 * T3 -
+    deltat =
+      0.001 +
+      0.000839 * T +
+      0.0002261 * T2 -
+      0.00000845 * T3 -
       0.000000081 * T * T3;
   } else {
     deltat = -0.000278 + 0.000265 * T + 0.000262 * T2;
   }
   JdNew = Jd1 + C1 - deltat;
   return JdNew;
-}
+};
 
 /* Compute the longitude of the sun at any time.
  * Parameter: floating number jdn, the number of days since 1/1/4713 BC noon
  * Algorithm from: "Astronomical Algorithms" by Jean Meeus, 1998
  */
-const SunLongitude = (jdn) =>  {
+const SunLongitude = (jdn: number) => {
   let T, T2, dr, M, L0, DL, L;
-  T = (jdn - 2451545.0) /
-    36525; // Time in Julian centuries from 2000-01-01 12:00:00 GMT
+  T = (jdn - 2451545.0) / 36525; // Time in Julian centuries from 2000-01-01 12:00:00 GMT
   T2 = T * T;
   dr = Math.PI / 180; // degree to radian
-  M = 357.52910 + 35999.05030 * T - 0.0001559 * T2 -
-    0.00000048 * T * T2; // mean anomaly, degree
+  M = 357.5291 + 35999.0503 * T - 0.0001559 * T2 - 0.00000048 * T * T2; // mean anomaly, degree
   L0 = 280.46645 + 36000.76983 * T + 0.0003032 * T2; // mean longitude, degree
-  DL = (1.914600 - 0.004817 * T - 0.000014 * T2) * Math.sin(dr * M);
-  DL = DL + (0.019993 - 0.000101 * T) * Math.sin(dr * 2 * M) +
-    0.000290 * Math.sin(dr * 3 * M);
+  DL = (1.9146 - 0.004817 * T - 0.000014 * T2) * Math.sin(dr * M);
+  DL =
+    DL +
+    (0.019993 - 0.000101 * T) * Math.sin(dr * 2 * M) +
+    0.00029 * Math.sin(dr * 3 * M);
   L = L0 + DL; // true longitude, degree
   L = L * dr;
-  L = L - Math.PI * 2 * (Math.sin(L / (Math.PI * 2))); // Normalize to (0, 2*PI)
+  L = L - Math.PI * 2 * Math.sin(L / (Math.PI * 2)); // Normalize to (0, 2*PI)
   return L;
-}
+};
 
 /* Compute sun position at midnight of the day with the given Julian day number.
  * The time zone if the time difference between local time and UTC: 7.0 for UTC+7:00.
@@ -102,19 +104,21 @@ const SunLongitude = (jdn) =>  {
  * From the day after March equinox and the 1st major term after March equinox, 0 is returned.
  * After that, return 1, 2, 3 ...
  */
-const getSunLongitude = (dayNumber, timeZone) => {
-  return removeFractionalPart(SunLongitude(dayNumber - 0.5 - timeZone / 24) / Math.PI * 6);
-}
+const getSunLongitude = (dayNumber: number, timeZone: number) => {
+  return removeFractionalPart(
+    (SunLongitude(dayNumber - 0.5 - timeZone / 24) / Math.PI) * 6
+  );
+};
 
 /* Compute the day of the k-th new moon in the given time zone.
  * The time zone if the time difference between local time and UTC: 7.0 for UTC+7:00
  */
-const getNewMoonDay = (k, timeZone) => {
+const getNewMoonDay = (k: number, timeZone: number) => {
   return removeFractionalPart(NewMoon(k) + 0.5 + timeZone / 24);
-}
+};
 
 /* Find the day that starts the luner month 11 of the given year for the given time zone */
-const getLunarMonth11 = (yy, timeZone) => {
+const getLunarMonth11 = (yy: number, timeZone: number) => {
   let k, off, nm, sunLong;
   //off = jdFromDate(31, 12, yy) - 2415021.076998695;
   off = jdFromDate(31, 12, yy) - 2415021;
@@ -125,10 +129,10 @@ const getLunarMonth11 = (yy, timeZone) => {
     nm = getNewMoonDay(k - 1, timeZone);
   }
   return nm;
-}
+};
 
 /* Find the index of the leap month after the month starting on the day a11. */
-const getLeapMonthOffset = (a11, timeZone) => {
+const getLeapMonthOffset = (a11: number, timeZone: number) => {
   let k, last, arc, i;
   k = removeFractionalPart((a11 - 2415021.076998695) / 29.530588853 + 0.5);
   last = 0;
@@ -140,11 +144,23 @@ const getLeapMonthOffset = (a11, timeZone) => {
     arc = getSunLongitude(getNewMoonDay(k + i, timeZone), timeZone);
   } while (arc !== last && i < 14);
   return i - 1;
-}
+};
 
 /* Comvert solar date dd/mm/yyyy to the corresponding lunar date */
-export const convertSolar2Lunar = (dd, mm, yy, timeZone) => {
-  let k, dayNumber, monthStart, a11, b11, lunarDay, lunarMonth, lunarYear,
+export const convertSolar2Lunar = (
+  dd: number,
+  mm: number,
+  yy: number,
+  timeZone: number
+) => {
+  let k,
+    dayNumber,
+    monthStart,
+    a11,
+    b11,
+    lunarDay,
+    lunarMonth,
+    lunarYear,
     lunarLeap;
   dayNumber = jdFromDate(dd, mm, yy);
   k = removeFractionalPart((dayNumber - 2415021.076998695) / 29.530588853);
@@ -181,5 +197,10 @@ export const convertSolar2Lunar = (dd, mm, yy, timeZone) => {
   if (lunarMonth >= 11 && diff < 4) {
     lunarYear -= 1;
   }
-  return { lunarDay, lunarMonth: lunarMonth, lunarYear, isleap: lunarLeap};
-}
+  return {
+    lunarDay,
+    lunarMonth: lunarMonth,
+    lunarYear,
+    isleap: lunarLeap,
+  };
+};

package/Month.tsx

@@ -0,0 +1,114 @@
+import React, {PureComponent} from 'react';
+
+import {View} from 'react-native';
+import moment from 'moment';
+import Moment from 'moment';
+import Day from './Day';
+import {scaleSize, Spacing} from '@momo-kits/foundation';
+import {MonthProps} from './types';
+import {ContainerContext} from './index';
+
+export default class Month extends PureComponent<MonthProps> {
+  rowArray;
+  temp;
+  constructor(props: MonthProps) {
+    super(props);
+    const {dateList} = props;
+    this.rowArray = new Array(dateList.length / 7).fill('');
+    this.temp = this.rowArray.map((item, i) =>
+      dateList.slice(i * 7, i * 7 + 7),
+    );
+  }
+
+  findHoliday = (date: Moment.Moment) => {
+    const {holidays} = this.props;
+    if (date && holidays && holidays.length > 0) {
+      const day = date.date();
+      const month = date.month() + 1;
+      return holidays.find(item => item.day === day && item.month === month);
+    }
+    return null;
+  };
+
+  checkHoliday = (date: moment.Moment) => {
+    const holiday = this.findHoliday(date);
+    return {
+      isSolarHoliday: !!(holiday && !holiday.lunar),
+      isLunarHoliday: !!(holiday && holiday.lunar),
+    };
+  };
+
+  renderDayRow = (dayList: any[], index: number) => (
+    <View
+      style={{
+        flexDirection: 'row',
+        alignItems: 'center',
+        marginBottom: Spacing.XS,
+        height: scaleSize(48),
+      }}
+      key={`row${index}`}>
+      {dayList.map((item, i) => {
+        const keyDay = moment(item.date).format('YYYY-MM-DD');
+        const priceInfo = this.props?.priceListDate?.[keyDay];
+        const {
+          minDate,
+          maxDate,
+          startDate,
+          endDate,
+          isShowLunar,
+          isDoubleDateMode,
+          disabledDays,
+        } = this.props;
+
+        const dateItem = new Date(item.date);
+        const mappedDisabledArray = disabledDays?.map(item => String(item));
+        const isDisabled = mappedDisabledArray?.includes(String(dateItem));
+
+        return (
+          <Day
+            {...this.props}
+            minDate={minDate}
+            maxDate={maxDate}
+            isShowLunar={isShowLunar}
+            isDoubleDateMode={isDoubleDateMode}
+            startDate={startDate}
+            endDate={endDate}
+            {...this.checkHoliday(item.date)}
+            date={item.date}
+            havePriceList={!!this.props.priceListDate}
+            lunarDate={item.lunarDate}
+            empty={item.empty}
+            key={`day${i.toString()}`}
+            index={i}
+            price={priceInfo?.priceAsString}
+            isBestPrice={priceInfo?.isBestPrice}
+            isDisabled={isDisabled}
+          />
+        );
+      })}
+    </View>
+  );
+
+  render() {
+    const {month} = this.props;
+    if (month) {
+      return (
+        <ContainerContext.Consumer>
+          {size => (
+            <View style={{width: size.width}}>
+              <View
+                style={{
+                  paddingHorizontal: Spacing.S,
+                  width: '100%',
+                  alignItems: 'center',
+                }}>
+                {this.temp.map((item, i) => this.renderDayRow(item, i))}
+              </View>
+            </View>
+          )}
+        </ContainerContext.Consumer>
+      );
+    }
+    return <View />;
+  }
+}