@momo-kits/native-kits 0.157.1-beta.9 → 0.157.1-com.1-debug

package/src/libs/Calendar/LunarDateConverter.ts

@@ -0,0 +1,228 @@
+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;
+  }) {
+    // year range check: only support lunar calendar from 1900
+    const minLunarYear = 1900;
+    // using converter data, maximum supported lunar year
+    const maxLunarYear = this.lunar_month_days[0] + this.lunar_month_days.length - 1;
+    if (lunar.lunarYear < minLunarYear || lunar.lunarYear > maxLunarYear) {
+      throw new Error(`LunarToSolar: year ${lunar.lunarYear} out of supported range ${minLunarYear}-${maxLunarYear}`);
+    }
+    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;
+  }) {
+    // year range check: only support solar dates from 1900
+    const minSolarYear = 1900;
+    // using converter data, maximum supported solar year
+    const maxSolarYear = this.solar_1_1[0] + this.solar_1_1.length - 1;
+    if (solar.solarYear < minSolarYear || solar.solarYear > maxSolarYear) {
+      throw new Error(`SolarToLunar: year ${solar.solarYear} out of supported range ${minSolarYear}-${maxSolarYear}`);
+    }
+    // @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/libs/Calendar/LunarService.ts

@@ -0,0 +1,206 @@
+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: 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;
+  if (jd < 2299161) {
+    jd =
+      dd +
+      removeFractionalPart((153 * m + 2) / 5) +
+      365 * y +
+      removeFractionalPart(y / 4) -
+      32083;
+  }
+  return jd;
+};
+
+/* 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: 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);
+  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.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 -
+      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: 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
+  T2 = T * T;
+  dr = Math.PI / 180; // degree to radian
+  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.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)
+  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.
+ * The  returns a number between 0 and 11.
+ * 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: 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: 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: number, timeZone: number) => {
+  let k, off, nm, sunLong;
+  //off = jdFromDate(31, 12, yy) - 2415021.076998695;
+  off = jdFromDate(31, 12, yy) - 2415021;
+  k = removeFractionalPart(off / 29.530588853);
+  nm = getNewMoonDay(k, timeZone);
+  sunLong = getSunLongitude(nm, timeZone); // sun longitude at local midnight
+  if (sunLong >= 9) {
+    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: number, timeZone: number) => {
+  let k, last, arc, i;
+  k = removeFractionalPart((a11 - 2415021.076998695) / 29.530588853 + 0.5);
+  last = 0;
+  i = 1; // We start with the month following lunar month 11
+  arc = getSunLongitude(getNewMoonDay(k + i, timeZone), timeZone);
+  do {
+    last = arc;
+    i++;
+    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: 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);
+  monthStart = getNewMoonDay(k + 1, timeZone);
+  if (monthStart > dayNumber) {
+    monthStart = getNewMoonDay(k, timeZone);
+  }
+  //alert(dayNumber+" -> "+monthStart);
+  a11 = getLunarMonth11(yy, timeZone);
+  b11 = a11;
+  if (a11 >= monthStart) {
+    lunarYear = yy;
+    a11 = getLunarMonth11(yy - 1, timeZone);
+  } else {
+    lunarYear = yy + 1;
+    b11 = getLunarMonth11(yy + 1, timeZone);
+  }
+  lunarDay = dayNumber - monthStart + 1;
+  let diff = removeFractionalPart((monthStart - a11) / 29);
+  lunarLeap = 0;
+  lunarMonth = diff + 10;
+  if (b11 - a11 > 365) {
+    let leapMonthDiff = getLeapMonthOffset(a11, timeZone);
+    if (diff >= leapMonthDiff) {
+      lunarMonth = diff + 10;
+      if (diff === leapMonthDiff) {
+        lunarLeap = 1;
+      }
+    }
+  }
+  if (lunarMonth > 12) {
+    lunarMonth = lunarMonth - 12;
+  }
+  if (lunarMonth >= 11 && diff < 4) {
+    lunarYear -= 1;
+  }
+  return {
+    lunarDay,
+    lunarMonth: lunarMonth,
+    lunarYear,
+    isleap: lunarLeap,
+  };
+};

package/src/libs/Calendar/Month.tsx

@@ -0,0 +1,118 @@
+import React, {useContext, useMemo} from 'react';
+import {View} from 'react-native';
+import moment, {Moment} from 'moment';
+import Day from './Day';
+import {useScaleSize, Spacing} from '@momo-kits/foundation';
+import {MonthProps} from './types';
+import {ContainerContext} from './index';
+
+const Month: React.FC<MonthProps> = ({
+  dateList,
+  holidays,
+  priceListDate,
+  minDate,
+  maxDate,
+  startDate,
+  endDate,
+  isShowLunar,
+  isDoubleDateMode,
+  disabledDays,
+  month,
+  ...props
+}) => {
+  const rows = useMemo(() => {
+    const rowCount = dateList.length / 7;
+    const rowArray = new Array(rowCount).fill('');
+    return rowArray.map((_, i) => dateList.slice(i * 7, i * 7 + 7));
+  }, [dateList]);
+
+  const findHoliday = (date?: Moment) => {
+    if (!date || !holidays || holidays.length === 0) {
+      return null;
+    }
+    const day = date.date();
+    const monthNum = date.month() + 1;
+    return (
+      holidays.find(item => item.day === day && item.month === monthNum) || null
+    );
+  };
+
+  const checkHoliday = (date?: Moment) => {
+    const holiday = findHoliday(date);
+    return {
+      isSolarHoliday: !!(holiday && !holiday.lunar),
+      isLunarHoliday: !!(holiday && holiday.lunar),
+    };
+  };
+
+  const size = useContext(ContainerContext);
+  const scaledHeight = useScaleSize(48);
+
+  // Precompute disabled dates set for fast lookup (format: YYYY-MM-DD)
+  const disabledSet = useMemo(
+    () => new Set((disabledDays || []).map(d => moment(d).format('YYYY-MM-DD'))),
+    [disabledDays]
+  );
+
+  if (!month) {
+    return <View />;
+  }
+
+  return (
+    <View style={{width: size.width}}>
+      <View
+        style={{
+          paddingHorizontal: Spacing.S,
+          width: '100%',
+          alignItems: 'center',
+        }}>
+        {rows.map((dayList, rowIndex) => (
+          <View
+            key={`row${rowIndex}`}
+            style={{
+              flexDirection: 'row',
+              alignItems: 'center',
+              marginBottom: Spacing.XS,
+              height: scaledHeight,
+            }}>
+            {dayList.map((item, i) => {
+              const {isEmpty, date: dateMoment, lunarDate} = item;
+              // compute key for price/disabled only if not empty
+              const keyDay = !isEmpty && dateMoment
+                ? dateMoment.format('YYYY-MM-DD')
+                : '';
+              const priceInfo = keyDay ? priceListDate?.[keyDay] : undefined;
+              const isDisabled = keyDay
+                ? disabledSet.has(keyDay)
+                : false;
+
+              return (
+                <Day
+                  {...props}
+                  minDate={minDate}
+                  maxDate={maxDate}
+                  isShowLunar={isShowLunar}
+                  isDoubleDateMode={isDoubleDateMode}
+                  startDate={startDate}
+                  endDate={endDate}
+                  {...checkHoliday(dateMoment)}
+                  date={dateMoment}
+                  havePriceList={!!priceListDate}
+                  lunarDate={lunarDate}
+                  isEmpty={isEmpty}
+                  key={`day${i}`}
+                  index={i}
+                  price={priceInfo?.priceAsString}
+                  isBestPrice={priceInfo?.isBestPrice}
+                  isDisabled={isDisabled}
+                />
+              );
+            })}
+          </View>
+        ))}
+      </View>
+    </View>
+  );
+};
+
+export default React.memo(Month);