npm - dayjskh - Versions diffs - 0.1.0 - Mend

dayjskh 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/.editorconfig ADDED Viewed

@@ -0,0 +1,20 @@
+root = true
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+[*.{json,vue,js,jsx,ts,tsx,css,scss,html}]
+indent_size = 2
+[*.md]
+trim_trailing_whitespace = false
+[*.{yml,yaml}]
+indent_size = 2
+[docker-compose.yml]
+indent_size = 4

package/.prettierrc.json ADDED Viewed

	@@ -0,0 +1 @@
1	+ {}

package/README.md ADDED Viewed

@@ -0,0 +1,37 @@
+# Khmer Lunar Date plugin for [Day.js](https://day.js.org/)
+Convert Date to Khmer Lunar Date [see more...](https://web.archive.org/web/20190714153528/http://www.cam-cc.org/calendar/).
+## Installation
+```bash
+npm install dayjs
+npm install dayjskh
+```
+## Usage
+```js
+import dayjs from "dayjs";
+import toKhDate from "dayjskh";
+dayjs.extend(toKhDate);
+const date = dayjs();
+console.log(date.toKhDate(format?)); // ថ្ងៃច័ន្ទ ១២កើត ខែស្រាពណ៍ ឆ្នាំថោះ បញ្ចស័ក ពុទ្ធសករាជ ២៥៦៧
+// find khmer new year dateTime
+console.log(date.khNewYear());
+// type
+// {
+//     date: Dayjs;
+//     days: number;
+//     dates: {
+//         date: Dayjs;
+//         dayName: string;
+//     }[]
+// }
+```
+# Author
+This library is Ported from [momentkh](https://github.com/ThyrithSor/momentkh) by [Thyrith Sor](https://github.com/ThyrithSor) in to [Day.js Plugin](https://day.js.org/).

package/index.html ADDED Viewed

@@ -0,0 +1,62 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DayjsKh</title>
+  </head>
+  <body>
+    <div id="app">
+      <h1></h1>
+      <h2></h2>
+      <h3></h3>
+      <pre></pre>
+      <div
+        style="
+          display: flex;
+          flex-direction: row;
+          /* justify-content: space-between; */
+        "
+      >
+        <ul></ul>
+        <ul id="ul2"></ul>
+      </div>
+    </div>
+    <script type="module">
+      import dayjs from "dayjs";
+      import toKhDate from "./src/main.ts";
+      dayjs.extend(toKhDate);
+      const date = dayjs();
+      console.log(date.khNewYear());
+      document.querySelector("h1").innerHTML = date.toKhDate();
+      // document.querySelector("h2").innerHTML = date.format("DD/MM/YYYY HH:mm");
+      document.querySelector("pre").innerHTML = JSON.stringify(
+        date.year(2024).khNewYear(),
+      );
+      // .format("DD/MM/YYYY HH:mm");
+      // console.log(date.khNewYear(2024).format("DD/MM/YYYY HH:mm"));
+      // loop 5 days
+      const ul = document.querySelector("ul");
+      for (let i = 0; i < 30; i++) {
+        const li = document.createElement("li");
+        li.innerHTML = `${date
+          .add(i, "day")
+          .toKhDate("ថ្ងៃ W DN ខែ m")} - ${date
+          .add(i, "day")
+          .format("DD/MM/YYYY")}`;
+        ul.appendChild(li);
+      }
+      const date2 = dayjs("2050-01-01T00:00:00+07:00");
+      const ul2 = document.querySelector("#ul2");
+      for (let i = 0; i < 30; i++) {
+        const li = document.createElement("li");
+        li.innerHTML = `${date2
+          .add(i, "day")
+          .toKhDate("ថ្ងៃ W DN ខែ m")} - ${date2
+          .add(i, "day")
+          .format("DD/MM/YYYY")}`;
+        ul2.appendChild(li);
+      }
+    </script>
+  </body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,26 @@
+{
+  "name": "dayjskh",
+  "version": "0.1.0",
+  "description": "Khmer Lunar date Plugin for Day.js",
+  "main": "./src/main.ts",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ChanthornAcademy/dayjskh.git"
+  },
+  "author": "chanthorn",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.5.7",
+    "prettier": "3.0.2",
+    "typescript": "^5.2.2",
+    "vite": "^4.4.9"
+  },
+  "dependencies": {
+    "dayjs": "^1.11.9"
+  }
+}

package/src/constant.ts ADDED Viewed

@@ -0,0 +1,104 @@
+const lunarMonths = {};
+"មិគសិរ_បុស្ស_មាឃ_ផល្គុន_ចេត្រ_ពិសាខ_ជេស្ឋ_អាសាឍ_ស្រាពណ៍_ភទ្របទ_អស្សុជ_កក្ដិក_បឋមាសាឍ_ទុតិយាសាឍ"
+  .split("_")
+  .forEach((month, index) => {
+    lunarMonths[month] = index;
+  });
+const solarMonths: { [key: string]: number } = {};
+"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ"
+  .split("_")
+  .forEach((month, index) => (solarMonths[month] = index));
+const animalYears: { [key: string]: number } = {};
+"ជូត_ឆ្លូវ_ខាល_ថោះ_រោង_ម្សាញ់_មមីរ_មមែ_វក_រកា_ច_កុរ"
+  .split("_")
+  .forEach((year, index) => (animalYears[year] = index));
+const eraYears: { [key: string]: number } = {};
+"សំរឹទ្ធិស័ក_ឯកស័ក_ទោស័ក_ត្រីស័ក_ចត្វាស័ក_បញ្ចស័ក_ឆស័ក_សប្តស័ក_អដ្ឋស័ក_នព្វស័ក"
+  .split("_")
+  .forEach((year, index) => (eraYears[year] = index));
+const moonStatus: { [key: string]: number } = {};
+"កើត_រោច".split("_").forEach((status, index) => (moonStatus[status] = index));
+const khNewYear: { [key: string]: string } = {
+  "1879": "12-04-1879 11:36",
+  "1897": "13-04-1897 02:00",
+  "2011": "14-04-2011 13:12",
+  "2012": "14-04-2012 19:11",
+  "2013": "14-04-2013 02:12",
+  "2014": "14-04-2014 08:07",
+  "2015": "14-04-2015 14:02",
+};
+const kh = () => {
+  let symbolMap = {
+      1: "១",
+      2: "២",
+      3: "៣",
+      4: "៤",
+      5: "៥",
+      6: "៦",
+      7: "៧",
+      8: "៨",
+      9: "៩",
+      0: "០",
+    },
+    numberMap = {
+      "១": 1,
+      "២": 2,
+      "៣": 3,
+      "៤": 4,
+      "៥": 5,
+      "៦": 6,
+      "៧": 7,
+      "៨": 8,
+      "៩": 9,
+      "០": 0,
+    };
+  return {
+    months:
+      "មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split(
+        "_",
+      ),
+    monthsShort:
+      "មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split(
+        "_",
+      ),
+    moonDays:
+      "᧡_᧢_᧣_᧤_᧥_᧦_᧧_᧨_᧩_᧪_᧫_᧬_᧭_᧮_᧯_᧱_᧲_᧳_᧴_᧵_᧶_᧷_᧸_᧹_᧺_᧻_᧼_᧽_᧾_᧿".split("_"),
+    moonStatus: "កើត_រោច".split("_"),
+    moonStatusShort: "ក_រ".split("_"),
+    weekdays: "អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍".split("_"),
+    weekdaysShort: "អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),
+    weekdaysMin: "អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),
+    lunarMonths:
+      "មិគសិរ_បុស្ស_មាឃ_ផល្គុន_ចេត្រ_ពិសាខ_ជេស្ឋ_អាសាឍ_ស្រាពណ៍_ភទ្របទ_អស្សុជ_កក្ដិក_បឋមាសាឍ_ទុតិយាសាឍ".split(
+        "_",
+      ),
+    animalYear: "ជូត_ឆ្លូវ_ខាល_ថោះ_រោង_ម្សាញ់_មមីរ_មមែ_វក_រកា_ច_កុរ".split("_"),
+    eraYear:
+      "សំរឹទ្ធិស័ក_ឯកស័ក_ទោស័ក_ត្រីស័ក_ចត្វាស័ក_បញ្ចស័ក_ឆស័ក_សប្តស័ក_អដ្ឋស័ក_នព្វស័ក".split(
+        "_",
+      ),
+    preparse: function (number: any) {
+      return number.toString().replace(/[០១២៣៤៥៦៧៨៩]/g, (m) => numberMap[m]);
+    },
+    postformat: function (number: any) {
+      return number.toString().replace(/\d/g, (m) => symbolMap[m]);
+    },
+  };
+};
+export const constant = {
+  lunarMonths,
+  solarMonths,
+  animalYears,
+  eraYears,
+  moonStatus,
+  khNewYear,
+  kh: kh(),
+};

package/src/dayjskh.ts ADDED Viewed

@@ -0,0 +1,522 @@
+// Khmer Chhankitek Calendar
+// Ref.: https://khmer-calendar.tovnah.com/calendar/toc.php
+import { constant } from "./constant";
+import learnSak from "./lerngSak";
+import dayjs from "dayjs/esm/index.js";
+import duration from "dayjs/esm/plugin/duration";
+import customParseFormat from "dayjs/esm/plugin/customParseFormat";
+import badMutable from "dayjs/esm/plugin/badMutable";
+dayjs.extend(customParseFormat);
+dayjs.extend(duration);
+const { lunarMonths } = constant;
+export default function dayjskh(date?: dayjs.Dayjs | string) {
+  // check if date is valid
+  const globalDate = dayjs(date); // if date is undefined, it will return current date
+  if (!globalDate.isValid()) {
+    throw new Error("Invalid Date");
+  }
+  const { floor } = Math;
+  // Aharkun: អាហារគុណ ឬ ហារគុណ
+  // Aharkun is used for Avoman and Bodithey calculation below. Given adYear as a target year in Buddhist Era
+  function getAharkun(beYear: number): number {
+    let t = beYear * 292207 + 499;
+    return floor(t / 800) + 4;
+  }
+  function getAharkunMod(beYear: number): number {
+    let t = beYear * 292207 + 499;
+    return t % 800;
+  }
+  // Bodithey: បូតិថី
+  // Bodithey determines if a given beYear is a leap-month year. Given year target year in Buddhist Era
+  function getBodithey(beYear: number): number {
+    const { avml, aharkun } = {
+      avml: floor((11 * getAharkun(beYear) + 25) / 692),
+      aharkun: getAharkun(beYear),
+    };
+    return (avml + aharkun + 29) % 30;
+  }
+  // Avoman: អាវមាន
+  // Avoman determines if a given year is a leap-day year. Given a year in Buddhist Era as denoted as adYear
+  function getAvoman(beYear: number): number {
+    const aharkun = getAharkun(beYear);
+    return (11 * aharkun + 25) % 692;
+  }
+  // Kromathupul
+  function khromathupul(beYear: number): number {
+    const aharkunMod = getAharkunMod(beYear);
+    return 800 - aharkunMod;
+  }
+  // isKhmerSolarLeap
+  function isKhmerSolarLeap(beYear: number): boolean {
+    return khromathupul(beYear) <= 207;
+  }
+  // Regular if year has 30 day
+  // leap month if year has 13 months
+  // leap day if Jesth month of the year has 1 extra day
+  // leap day and month: both of them
+  function getBoditheyLeap(beYear: number): number {
+    let result = 0;
+    const avoman = getAvoman(beYear);
+    const bodithey = getBodithey(beYear);
+    let boditheyLeap = 0;
+    if (bodithey >= 25 || bodithey <= 5) {
+      boditheyLeap = 1;
+    }
+    // check for avoman leap-day based on gregorian leap
+    let avomanLeap = 0;
+    if (isKhmerSolarLeap(beYear)) {
+      if (avoman <= 126) avomanLeap = 1;
+    } else {
+      if (avoman <= 137) {
+        // check for avoman case 137/0, 137 must be normal year (p.26)
+        if (getAvoman(beYear + 1) === 0) {
+          avomanLeap = 0;
+        } else {
+          avomanLeap = 1;
+        }
+      }
+    }
+    // case of 25/5 consecutively
+    // only bodithey 5 can be leap-month, so set bodithey 25 to none
+    if (bodithey === 25) {
+      let nextBodithey = getBodithey(beYear + 1);
+      if (nextBodithey === 5) {
+        boditheyLeap = 0;
+      }
+    }
+    // case of 24/6 consecutively, 24 must be leap-month
+    if (bodithey == 24) {
+      let nextBodithey = getBodithey(beYear + 1);
+      if (nextBodithey == 6) {
+        boditheyLeap = 1;
+      }
+    }
+    // format leap result (0:regular, 1:month, 2:day, 3:both)
+    if (boditheyLeap === 1 && avomanLeap === 1) {
+      result = 3;
+    } else if (boditheyLeap === 1) {
+      result = 1;
+    } else if (avomanLeap === 1) {
+      result = 2;
+    } else {
+      result = 0;
+    }
+    return result;
+  }
+  // bodithey leap can be both leap-day and leap-month but following the khmer calendar rule, they can't be together on the same year, so leap day must be delayed to next year
+  function getProtetinLeap(beYear: number): number {
+    const b = getBoditheyLeap(beYear);
+    if (b === 3) {
+      return 1;
+    }
+    if (b === 2 || b === 1) {
+      return b;
+    }
+    // case of previous year is 3
+    if (getBoditheyLeap(beYear - 1) === 3) {
+      return 2;
+    }
+    return 0;
+  }
+  // A year with an extra day is called Chhantrea Thimeas (ចន្ទ្រាធិមាស) or Adhikavereak (អធិកវារៈ). This year has 355 days.
+  function isKhmerLunarLeapDay(beYear: number): boolean {
+    return getProtetinLeap(beYear) === 2;
+  }
+  // A year with an extra month is called Adhikameas (អធិកមាស). This year has 384 days.
+  function isKhmerLeapMonth(beYear: number): boolean {
+    return getProtetinLeap(beYear) === 1;
+  }
+  // is Gregorian Leap Year
+  // function isGregorianLeapYear(beYear: number): boolean {
+  //   return (beYear % 4 === 0 && beYear % 100 !== 0) || beYear % 400 === 0;
+  // }
+  // get Max day of Khmer month
+  function getMaxDayOfKhmerMonth(beMonth: number, beYear: number): number {
+    // 'ជេស្ឋ': 6,
+    if (beMonth === 6 && isKhmerLunarLeapDay(beYear)) {
+      return 30;
+    }
+    if (
+      //  'បឋមាសាឍ': 12, 'ទុតិយាសាឍ': 13
+      beMonth === 12 ||
+      beMonth === 13
+    ) {
+      return 30;
+    }
+    return beMonth % 2 === 0 ? 29 : 30;
+  }
+  // Get number of day in Khmer year
+  function getNumDayOfKhmerYear(beYear: number): number {
+    if (isKhmerLeapMonth(beYear)) {
+      return 384;
+    } else if (isKhmerLunarLeapDay(beYear)) {
+      return 355;
+    } else {
+      return 354;
+    }
+  }
+  // Buddhist Era
+  // ថ្ងៃឆ្លងឆ្នាំ គឺ ១ រោច ខែពិសាខ
+  // @ref http://news.sabay.com.kh/article/1039620
+  // @summary: ឯកឧត្តម សេង សុមុនី អ្នកនាំពាក្យក្រសួងធម្មការ និងសាសនាឲ្យSabay ដឹងថានៅប្រទេសកម្ពុជាការឆ្លងចូលពុទ្ធសករាជថ្មីគឺកំណត់យកនៅថ្ងៃព្រះពុទ្ធយាងចូលនិព្វាន ពោលគឺនៅថ្ងៃ១រោច ខែពិសាខ។
+  // @param dayjs
+  function getBEYear(date: dayjs.Dayjs): number {
+    if (date.diff(getVisakBochea(date.year())) > 0) {
+      return date.year() + 544;
+    } else {
+      return date.year() + 543;
+    }
+  }
+  function getMaybeBEYear(date: dayjs.Dayjs): number {
+    if (date.month() <= 4) {
+      return date.year() + 543;
+    } else {
+      return date.year() + 544;
+    }
+  }
+  // Next month of Khmer month
+  function nextMonthOf(khmerMonth: number, beYear: number): number {
+    switch (khmerMonth) {
+      case lunarMonths["មិគសិរ"]:
+        return lunarMonths["បុស្ស"];
+      case lunarMonths["បុស្ស"]:
+        return lunarMonths["មាឃ"];
+      case lunarMonths["មាឃ"]:
+        return lunarMonths["ផល្គុន"];
+      case lunarMonths["ផល្គុន"]:
+        return lunarMonths["ចេត្រ"];
+      case lunarMonths["ចេត្រ"]:
+        return lunarMonths["ពិសាខ"];
+      case lunarMonths["ពិសាខ"]:
+        return lunarMonths["ជេស្ឋ"];
+      case lunarMonths["ជេស្ឋ"]: {
+        if (isKhmerLeapMonth(beYear)) {
+          return lunarMonths["បឋមាសាឍ"];
+        } else {
+          return lunarMonths["អាសាឍ"];
+        }
+      }
+      case lunarMonths["អាសាឍ"]:
+        return lunarMonths["ស្រាពណ៍"];
+      case lunarMonths["ស្រាពណ៍"]:
+        return lunarMonths["ភទ្របទ"];
+      case lunarMonths["ភទ្របទ"]:
+        return lunarMonths["អស្សុជ"];
+      case lunarMonths["អស្សុជ"]:
+        return lunarMonths["កក្ដិក"];
+      case lunarMonths["កក្ដិក"]:
+        return lunarMonths["មិគសិរ"];
+      case lunarMonths["បឋមាសាឍ"]:
+        return lunarMonths["ទុតិយាសាឍ"];
+      case lunarMonths["ទុតិយាសាឍ"]:
+        return lunarMonths["ស្រាពណ៍"];
+      default:
+        throw Error("Plugin is facing wrong calculation (Invalid month)");
+    }
+  }
+  // calculate date from dayjs to Khmer date
+  function getLunarDate(targetDate: dayjs.Dayjs): {
+    day: number;
+    month: number;
+    epochMoved: dayjs.Dayjs;
+  } {
+    dayjs.extend(badMutable);
+    // Epoch Date: January 1, 1900
+    let epochDayjs = dayjs("1900-01-01");
+    let khmerMonth = 1;
+    let khmerDay = 0; // 0 - 29 ១កើត ... ១៥កើត ១រោច ...១៤រោច (១៥រោច)
+    // Find nearest year epoch
+    if (targetDate.diff(epochDayjs) > 0) {
+      while (
+        dayjs.duration(targetDate.diff(epochDayjs), "milliseconds").asDays() > // ok
+        getNumDayOfKhmerYear(getMaybeBEYear(epochDayjs.clone().add(1, "year")))
+      ) {
+        epochDayjs.add(
+          getNumDayOfKhmerYear(
+            getMaybeBEYear(epochDayjs.clone().add(1, "year")),
+          ),
+          "day",
+        );
+      }
+    } else {
+      do {
+        epochDayjs.subtract(
+          getNumDayOfKhmerYear(getMaybeBEYear(epochDayjs)),
+          "day",
+        );
+      } while (
+        dayjs.duration(epochDayjs.diff(targetDate), "milliseconds").asDays() > 0
+      );
+    }
+    // Move epoch month
+    while (
+      dayjs.duration(targetDate.diff(epochDayjs), "milliseconds").asDays() >
+      getMaxDayOfKhmerMonth(khmerMonth, getMaybeBEYear(epochDayjs))
+    ) {
+      epochDayjs.add(
+        getMaxDayOfKhmerMonth(khmerMonth, getMaybeBEYear(epochDayjs)),
+        "day",
+      );
+      khmerMonth = nextMonthOf(khmerMonth, getMaybeBEYear(epochDayjs));
+    }
+    khmerDay += floor(
+      dayjs.duration(targetDate.diff(epochDayjs), "milliseconds").asDays(),
+    );
+    // fix result display 15 រោច ខែ ជេស្ឋ នៅថ្ងៃ ១ កើតខែបឋមាសាធ
+    // ករណី ខែជេស្ឋមានតែ ២៩ ថ្ងៃ តែលទ្ធផលបង្ហាញ ១៥រោច ខែជេស្ឋ
+    const totalDaysOfTheMonth = getMaxDayOfKhmerMonth(
+      khmerMonth,
+      getMaybeBEYear(targetDate),
+    );
+    if (totalDaysOfTheMonth <= khmerDay) {
+      khmerDay = khmerDay % totalDaysOfTheMonth;
+      khmerMonth = nextMonthOf(khmerMonth, getMaybeBEYear(epochDayjs));
+    }
+    epochDayjs.add(
+      dayjs.duration(targetDate.diff(epochDayjs), "milliseconds").asDays(),
+      "day",
+    );
+    return {
+      day: khmerDay,
+      month: khmerMonth,
+      epochMoved: epochDayjs,
+    };
+  }
+  // រកថ្ងៃវិសាខបូជា
+  // ថ្ងៃដាច់ឆ្នាំពុទ្ធសករាជ
+  function getVisakBochea(
+    gregorianYear: number,
+  ): string | number | dayjs.Dayjs | Date | null | undefined | any {
+    const date = dayjs(`${gregorianYear}-01-01`);
+    for (var i = 0; i < 365; i++) {
+      const lunarDate = getLunarDate(date);
+      if (lunarDate.month === lunarMonths["ពិសាខ"] && lunarDate.day === 14) {
+        return date;
+      }
+      date.add(1, "day");
+    }
+  }
+  function datesOfKhmerNewYear(
+    startDate: dayjs.Dayjs,
+    numberOfNewYearDays: number,
+  ) {
+    let dates = [];
+    for (let i = 0; i < numberOfNewYearDays; i++) {
+      dates.push(startDate.clone().add(i, "day"));
+    }
+    return dates.map((date, index) => {
+      // find first day
+      let dayName = "Moha Sangkranta"; // មហាសង្រ្កាន្ត
+      if (index === 0) {
+        dayName = "Moha Sangkranta"; // មហាសង្រ្កាន្ត
+      } // last day
+      else if (index === numberOfNewYearDays - 1) {
+        dayName = "Veareak Laeung Sak"; // ថ្ងៃឡើងស័ក
+      } else {
+        dayName = "Veareak Vanabat"; // វារៈវ័នបត
+      }
+      return {
+        date,
+        dayName,
+      };
+    });
+  }
+  // get khmer new year day
+  function getKhmerNewYear(gregorianYear: number): {
+    date: dayjs.Dayjs;
+    days: number;
+    dates: { date: dayjs.Dayjs; dayName: string }[];
+  } {
+    // ពីគ្រិស្ដសករាជ ទៅ ចុល្លសករាជ
+    let jsYear = gregorianYear + 544 - 1182;
+    let info = learnSak(jsYear);
+    let numberOfNewYearDay;
+    if (info.newYearsDaySotins[0].angsar === 0) {
+      numberOfNewYearDay = 4;
+    } else {
+      numberOfNewYearDay = 3;
+    }
+    let epochLerngSak = dayjs(
+      `${gregorianYear}-04-17 ${info.timeOfNewYear.hour}:${info.timeOfNewYear.minute}`,
+      "YYYY-MM-DD H:m",
+    );
+    let KhEpoch = getLunarDate(epochLerngSak);
+    let diffFromEpoch =
+      (KhEpoch.month - 4) * 30 +
+      KhEpoch.day -
+      ((info.lunarDateLerngSak.month - 4) * 30 + info.lunarDateLerngSak.day);
+    const result = epochLerngSak.subtract(
+      diffFromEpoch + numberOfNewYearDay - 1,
+      "day",
+    );
+    return {
+      date: result,
+      days: numberOfNewYearDay,
+      dates: datesOfKhmerNewYear(result, numberOfNewYearDay),
+    };
+  }
+  // find animal year
+  function getAnimalYear(date: dayjs.Dayjs): number {
+    const year = date.year();
+    const KhmerNewYear = getKhmerNewYear(year).date;
+    if (date.diff(KhmerNewYear) < 0) {
+      return (year + 543 + 4) % 12;
+    } else {
+      return (year + 544 + 4) % 12;
+    }
+  }
+  // Jolak Sakaraj
+  function getJolakSakarajYear(date: dayjs.Dayjs) {
+    const year = date.year();
+    const KhmerNewYear = getKhmerNewYear(year).date;
+    if (date.diff(KhmerNewYear) < 0) {
+      return year + 543 - 1182;
+    } else {
+      return year + 544 - 1182;
+    }
+  }
+  function getKhmerLunarDayName(day: number): {
+    count: number;
+    moonStatus: number;
+  } {
+    return {
+      count: (day % 15) + 1,
+      moonStatus:
+        day > 14 ? constant.moonStatus["រោច"] : constant.moonStatus["កើត"],
+    };
+  }
+  // Khmer date format handler
+  function formatKhmerDate(
+    day: number,
+    month: number,
+    dayjs: dayjs.Dayjs,
+    format: string,
+  ): string {
+    if (format === null || format === undefined || format === "") {
+      // Default date format
+      const dayOfWeek = dayjs.day();
+      const moonDay = getKhmerLunarDayName(day);
+      const beYear = getBEYear(dayjs);
+      const animalYear = getAnimalYear(dayjs);
+      const eraYear = getJolakSakarajYear(dayjs) % 10;
+      return constant.kh.postformat(
+        `ថ្ងៃ${constant.kh.weekdays[dayOfWeek]} ${moonDay.count}${
+          constant.kh.moonStatus[moonDay.moonStatus]
+        } ខែ${constant.kh.lunarMonths[month]} ឆ្នាំ${
+          constant.kh.animalYear[animalYear]
+        } ${constant.kh.eraYear[eraYear]} ពុទ្ធសករាជ ${beYear}`,
+      );
+    } else if (typeof format === "string") {
+      const formatRules = {
+        W: () => {
+          return constant.kh.weekdays[dayjs.day()];
+        },
+        w: () => {
+          return constant.kh.weekdaysShort[dayjs.day()];
+        },
+        d: () => {
+          const moonDay = getKhmerLunarDayName(day);
+          return moonDay.count;
+        },
+        D: () => {
+          const moonDay = getKhmerLunarDayName(day);
+          return ("" + moonDay.count).length === 1
+            ? `០${moonDay.count}`
+            : moonDay.count;
+        },
+        N: () => {
+          const moonDay = getKhmerLunarDayName(day);
+          return constant.kh.moonStatus[moonDay.moonStatus];
+        },
+        n: () => {
+          const moonDay = getKhmerLunarDayName(day);
+          return constant.kh.moonStatusShort[moonDay.moonStatus];
+        },
+        o: () => {
+          return constant.kh.moonDays[day];
+        },
+        m: () => {
+          return constant.kh.lunarMonths[month];
+        },
+        M: () => {
+          return constant.kh.months[dayjs.month()];
+        },
+        a: () => {
+          return constant.kh.animalYear[getAnimalYear(dayjs)];
+        },
+        e: () => {
+          return constant.kh.eraYear[getJolakSakarajYear(dayjs) % 10];
+        },
+        b: () => {
+          return getBEYear(dayjs);
+        },
+        c: () => {
+          return dayjs.year();
+        },
+        j: () => {
+          return getJolakSakarajYear(dayjs);
+        },
+      };
+      return constant.kh.postformat(
+        format.replace(
+          new RegExp(Object.keys(formatRules).join("|"), "g"),
+          (m) => formatRules[m](),
+        ),
+      );
+    }
+  }
+  // format date to Khmer date
+  function format(format?: string): string {
+    const date = globalDate.clone();
+    const lunarDate = getLunarDate(date);
+    const result = formatKhmerDate(
+      lunarDate.day,
+      lunarDate.month,
+      date,
+      format,
+    );
+    return result;
+  }
+  return {
+    format,
+    khmerNewYearDate: getKhmerNewYear,
+  };
+}

package/src/lerngSak.ts ADDED Viewed

@@ -0,0 +1,288 @@
+import dayjs from "dayjs";
+import { constant } from "./constant";
+// calculate Khmer New Year
+// based on: https://www.dahlina.com/education/khmer_new_year_time.html?fbclid=IwAR0Eq6US-F0LfplMjKzmiRn7rvPgi31i74Wpv4mNhU034mzdyj-3hYrCA8w
+export default function learnSak(jsYear: number = dayjs().year()) {
+  if (arguments.length === 0) {
+    jsYear = dayjs().year();
+  } else {
+    jsYear = arguments[0];
+  }
+  const getInfo = (
+    jsYear: number,
+  ): {
+    harkun: number;
+    kromathopol: number;
+    avaman: number;
+    bodithey: number;
+  } => {
+    let h = 292207 * jsYear + 373;
+    let harkun = Math.floor(h / 800) + 1;
+    let kromathopol = 800 - (h % 800);
+    let a = 11 * harkun + 650;
+    let avaman = a % 692;
+    let bodithey = (harkun + Math.floor(a / 692)) % 30;
+    return {
+      harkun,
+      kromathopol,
+      avaman,
+      bodithey,
+    };
+  };
+  const getHas366Days = (jsYear: number): boolean => {
+    const { kromathopol } = getInfo(jsYear);
+    return kromathopol <= 207;
+  };
+  const getIsAdhikameas = (jsYear: number): boolean => {
+    const { bodithey: infoOfYear } = getInfo(jsYear);
+    const { bodithey: infoOfNextYear } = getInfo(jsYear + 1);
+    return (
+      !(infoOfYear === 25 && infoOfNextYear === 5) &&
+      (infoOfYear > 24 ||
+        infoOfNextYear < 6 ||
+        (infoOfYear === 24 && infoOfNextYear === 6))
+    );
+  };
+  const getIsChantreathimeas = (jsYear: number): boolean => {
+    const { avaman: infoOfYear } = getInfo(jsYear);
+    const { avaman: infoOfNextYear } = getInfo(jsYear + 1);
+    const { avaman: infoOfPrevYear } = getInfo(jsYear - 1);
+    const has366Days = getHas366Days(jsYear);
+    return (
+      (has366Days && infoOfYear < 127) ||
+      (!(infoOfYear === 137 && infoOfNextYear === 0) &&
+        ((!has366Days && infoOfYear < 138) ||
+          (infoOfPrevYear === 137 && infoOfYear === 0)))
+    );
+  };
+  const has366Days = getHas366Days(jsYear);
+  const isAdhikameas = getIsAdhikameas(jsYear);
+  const isChantreathimeas = getIsChantreathimeas(jsYear);
+  const jesthHas30 = (): boolean => {
+    const isAthikameas = isAdhikameas;
+    let tmp = isChantreathimeas;
+    if (isAthikameas && isChantreathimeas) {
+      tmp = false;
+    }
+    if (
+      !isChantreathimeas &&
+      getIsAdhikameas(jsYear - 1) &&
+      getIsChantreathimeas(jsYear - 1)
+    ) {
+      tmp = true;
+    }
+    return tmp;
+  };
+  const dayLerngSak = (getInfo(jsYear).harkun - 2) % 7;
+  const lunarDateLerngSak = (): {
+    day: number;
+    month: number;
+  } => {
+    let { bodithey: bodithey } = getInfo(jsYear);
+    if (getIsAdhikameas(jsYear - 1) && getIsChantreathimeas(jsYear - 1)) {
+      bodithey = (bodithey + 1) % 30;
+    }
+    return {
+      day: bodithey >= 6 ? bodithey - 1 : bodithey,
+      month:
+        bodithey >= 6
+          ? constant.lunarMonths["ចេត្រ"]
+          : constant.lunarMonths["ពិសាខ"],
+    };
+  };
+  const getSunInfo = (sotin: number) => {
+    const infoOfPreviousYear = getInfo(jsYear - 1);
+    const sunAverageAsLibda = (): number => {
+      let r2 = 800 * sotin + infoOfPreviousYear.kromathopol;
+      let reasey = Math.floor(r2 / 24350); // រាសី
+      let r3 = r2 % 24350;
+      let angsar = Math.floor(r3 / 811); // អង្សា
+      let r4 = r3 % 811;
+      let l1 = Math.floor(r4 / 14);
+      let libda = l1 - 3; // លិប្ដា
+      return 30 * 60 * reasey + 60 * angsar + libda;
+    };
+    const leftOver = (): number => {
+      let s1 = 30 * 60 * 2 + 60 * 20;
+      let leftOver = sunAverageAsLibda() - s1; // មធ្យមព្រះអាទិត្យ - R2.A20.L0
+      if (sunAverageAsLibda() < s1) {
+        // បើតូចជាង ខ្ចី ១២ រាសី
+        leftOver += 30 * 60 * 12;
+      }
+      return leftOver;
+    };
+    const kaen = (): number => {
+      return Math.floor(leftOver() / (30 * 60));
+    };
+    const lastLeftOver = (): {
+      reasey: number;
+      angsar: number;
+      libda: number;
+    } => {
+      let rs = -1;
+      if ([0, 1, 2].includes(kaen())) {
+        rs = kaen();
+      } else if ([3, 4, 5].includes(kaen())) {
+        rs = 30 * 60 * 6 - leftOver(); // R6.A0.L0 - leftover
+      } else if ([6, 7, 8].includes(kaen())) {
+        rs = leftOver() - 30 * 60 * 6; // leftover - R6.A0.L0
+      } else if ([9, 10, 11].includes(kaen())) {
+        rs = 30 * 60 * 11 + 60 * 29 + 60 - leftOver(); // R11.A29.L60 - leftover
+      }
+      return {
+        reasey: Math.floor(rs / (30 * 60)),
+        angsar: Math.floor((rs % (30 * 60)) / 60),
+        libda: rs % 60,
+      };
+    };
+    const khan = (): number => {
+      if (lastLeftOver().angsar >= 15) {
+        return 2 * lastLeftOver().reasey + 1;
+      } else {
+        return 2 * lastLeftOver().reasey;
+      }
+    };
+    const pouichalip = (): number => {
+      if (lastLeftOver().angsar >= 15) {
+        return 60 * (lastLeftOver().angsar - 15) + lastLeftOver().libda;
+      } else {
+        return 60 * lastLeftOver().angsar + lastLeftOver().libda;
+      }
+    };
+    const phol = (): {
+      reasey: number;
+      angsar: number;
+      libda: number;
+    } => {
+      const chhayaSun = (
+        khan: number,
+      ): {
+        multiplicity: number;
+        chhaya: number;
+      } => {
+        let multiplicities = [35, 32, 27, 22, 13, 5];
+        let chhayas = [0, 35, 67, 94, 116, 129];
+        switch (khan) {
+          case 0:
+          case 1:
+          case 2:
+          case 3:
+          case 4:
+          case 5:
+            return {
+              multiplicity: multiplicities[khan],
+              chhaya: chhayas[khan],
+            };
+          default:
+            return {
+              multiplicity: 0,
+              chhaya: 134,
+            };
+        }
+      };
+      let val = chhayaSun(khan());
+      let q = Math.floor((pouichalip() * val.multiplicity) / 900);
+      return {
+        reasey: 0,
+        angsar: Math.floor((q + val.chhaya) / 60),
+        libda: (q + val.chhaya) % 60,
+      };
+    };
+    const sunInaugurationAsLibda = (): number => {
+      let pholAsLibda =
+        30 * 60 * phol().reasey + 60 * phol().angsar + phol().libda;
+      if (kaen() <= 5) {
+        return sunAverageAsLibda() - pholAsLibda;
+      } else {
+        return sunAverageAsLibda() + pholAsLibda;
+      }
+    };
+    return {
+      sunAverageAsLibda,
+      khan,
+      pouichalip,
+      phol,
+      sunInaugurationAsLibda,
+    };
+  };
+  const newYearsDaySotins = (): {
+    sotin: number;
+    reasey: number;
+    angsar: number;
+    libda: number;
+  }[] => {
+    let sotins = getHas366Days(jsYear - 1)
+      ? [363, 364, 365, 366]
+      : [362, 363, 364, 365]; // សុទិន
+    return sotins.map((sotin) => {
+      let sunInfo = getSunInfo(sotin);
+      return {
+        sotin: sotin,
+        reasey: Math.floor(sunInfo.sunInaugurationAsLibda() / (30 * 60)),
+        angsar: Math.floor((sunInfo.sunInaugurationAsLibda() % (30 * 60)) / 60), // អង្សាស្មើសូន្យ គីជាថ្ងៃចូលឆ្នាំ, មួយ ឬ ពីរ ថ្ងៃបន្ទាប់ជាថ្ងៃវ័នបត ហើយ ថ្ងៃចុងក្រោយគីឡើងស័ក
+        libda: sunInfo.sunInaugurationAsLibda() % 60,
+      };
+    });
+  };
+  const timeOfNewYear = (): {
+    hour: number;
+    minute: number;
+  } => {
+    let sotinNewYear = newYearsDaySotins().filter(function (sotin) {
+      return sotin.angsar === 0;
+    });
+    if (sotinNewYear.length > 0) {
+      let libda = sotinNewYear[0].libda; // ២៤ ម៉ោង មាន ៦០លិប្ដា
+      let minutes = 24 * 60 - libda * 24;
+      return {
+        hour: Math.floor(minutes / 60),
+        minute: minutes % 60,
+      };
+    } else {
+      throw Error(
+        "Plugin is facing wrong calculation on new years hour. No sotin with angsar = 0",
+      );
+    }
+  };
+  const info = getInfo(jsYear);
+  return {
+    jsYear: jsYear,
+    harkun: info.harkun,
+    kromathopol: info.kromathopol,
+    avaman: info.avaman,
+    bodithey: info.bodithey,
+    has366Days: has366Days,
+    isAdhikameas: isAdhikameas,
+    isChantreathimeas: isChantreathimeas,
+    jesthHas30: jesthHas30(),
+    dayLerngSak: dayLerngSak,
+    lunarDateLerngSak: lunarDateLerngSak(),
+    newYearsDaySotins: newYearsDaySotins(),
+    timeOfNewYear: timeOfNewYear(),
+  };
+}

package/src/main.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import dayjskh from "./dayjskh";
+import type { PluginFunc } from "dayjs";
+import type plugin from "../types";
+import { constant } from "./constant";
+const toKhDate: PluginFunc<plugin.toKhDate> = (o, c, d) => {
+  const proto = c.prototype;
+  proto.toKhDate = function (format?: string) {
+    const date = constant.kh.preparse(this.format());
+    return dayjskh(date).format(format);
+  };
+  proto.khNewYear = function () {
+    return dayjskh(this.year()).khmerNewYearDate(this.year());
+  };
+};
+export default toKhDate;

package/src/vite-env.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ /// <reference types="vite/client" />

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src", "types"]
+}

package/types/index.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+// add type to support dayjs
+import type { Dayjs, PluginFunc } from "dayjs/esm/index";
+declare const plugin: PluginFunc;
+export = plugin;
+declare namespace plugin {
+  export interface toKhDate {
+    toKhDate(format?: string): string;
+    khNewYear(): {
+      date: dayjs.Dayjs;
+      days: number;
+      dates: { date: dayjs.Dayjs; dayName: string }[];
+    };
+  }
+}
+declare module "dayjs" {
+  interface Dayjs extends plugin.toKhDate {}
+}