@momo-kits/calendar 0.0.74-beta → 0.72.1

package/src/LunarService.js

@@ -9,18 +9,30 @@ const jdFromDate = (dd, mm, yy) => {
   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) => {
+const jdToDate = jd => {
   let a, b, c, d, e, m, day, month, year;
-  if (jd > 2299160) { // After 5/10/1582, Gregorian calendar
+  if (jd > 2299160) {
+    // After 5/10/1582, Gregorian calendar
     a = jd + 32044;
     b = removeFractionalPart((4 * a + 3) / 146097);
     c = a - removeFractionalPart((b * 146097) / 4);
@@ -35,66 +47,76 @@ const jdToDate = (jd) => {
   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 => {
   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 => {
   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.
@@ -103,15 +125,17 @@ const SunLongitude = (jdn) =>  {
  * After that, return 1, 2, 3 ...
  */
 const getSunLongitude = (dayNumber, timeZone) => {
-  return removeFractionalPart(SunLongitude(dayNumber - 0.5 - timeZone / 24) / Math.PI * 6);
-}
+  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) => {
   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) => {
@@ -125,7 +149,7 @@ 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) => {
@@ -140,11 +164,18 @@ 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,
+  let k,
+    dayNumber,
+    monthStart,
+    a11,
+    b11,
+    lunarDay,
+    lunarMonth,
+    lunarYear,
     lunarLeap;
   dayNumber = jdFromDate(dd, mm, yy);
   k = removeFractionalPart((dayNumber - 2415021.076998695) / 29.530588853);
@@ -181,5 +212,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/src/Month/index.js

@@ -1,80 +1,89 @@
-import React, { PureComponent } from 'react';
+import React, {PureComponent} from 'react';
 
-import {
-    View
-} from 'react-native';
+import {View, Dimensions} from 'react-native';
 import moment from 'moment';
 import Day from '../Day';
+import {Spacing, ScaleSize} from '@momo-kits/core-v2';
+
+const {width} = Dimensions.get('window');
 
 export default class Month extends PureComponent {
-    constructor(props) {
-        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));
+  constructor(props) {
+    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 => {
+    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;
+  };
 
-    findHoliday = (date) => {
-        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 => {
+    const holiday = this.findHoliday(date);
+    return {
+      isSolarHoliday: !!(holiday && !holiday.lunar),
+      isLunarHoliday: !!(holiday && holiday.lunar),
     };
+  };
 
-    checkHoliday = (date) => {
-        const holiday = this.findHoliday(date);
-        return {
-            isSolarHoliday: !!(holiday && !holiday.lunar),
-            isLunarHoliday: !!(holiday && holiday.lunar)
-        };
-    };
+  renderDayRow = (dayList, index, disabledWeekend) => (
+    <View
+      style={{
+        flexDirection: 'row',
+        justifyContent: 'space-between',
+      }}
+      key={`row${index}`}>
+      {dayList.map((item, i) => {
+        const keyDay = moment(item.date).format('YYYY-MM-DD');
+        const priceInfo = this.props?.priceListDate?.[keyDay];
 
-    renderDayRow = (dayList, index) => (
-        <View
+        return (
+          <Day
+            {...this.props}
+            {...this.checkHoliday(item.date)}
+            disabledWeekend={disabledWeekend}
+            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}
+          />
+        );
+      })}
+    </View>
+  );
+
+  render() {
+    const {month, disabledWeekend} = this.props;
+
+    if (month) {
+      return (
+        <View>
+          <View
             style={{
-                flexDirection: 'row',
-                justifyContent: 'space-between'
-            }}
-            key={`row${index}`}
-        >
-            {dayList.map((item, i) => {
-                const keyDay = moment(item.date).format('YYYY-MM-DD');
-                const priceInfo = this.props?.priceListDate?.[keyDay];
-                return (
-                    <Day
-                        {...this.props}
-                        {...this.checkHoliday(item.date)}
-                        date={item.date}
-                        lunarDate={item.lunarDate}
-                        empty={item.empty}
-                        key={`day${i.toString()}`}
-                        index={i}
-                        price={priceInfo?.priceAsString}
-                        isBestPrice={priceInfo?.isBestPrice}
-                    />
-                );
-            }
+              paddingHorizontal: Spacing.S,
+              paddingVertical: 5,
+              width: width - ScaleSize(24),
+            }}>
+            {this.temp.map((item, i) =>
+              this.renderDayRow(item, i, disabledWeekend),
             )}
+          </View>
         </View>
-    );
-
-    render() {
-        const {
-            month
-        } = this.props;
-        if (month) {
-            return (
-                <View>
-                    <View style={{ paddingHorizontal: 7, paddingVertical: 5 }}>
-                        {this.temp.map((item, i) => this.renderDayRow(item, i)
-                        )}
-                    </View>
-                </View>
-            );
-        }
-        return (<View />);
+      );
     }
+    return <View />;
+  }
 }