mumineen-ui-plugins 1.1.0

package/dist/hijri-calendar/libs/HijriDate.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HijriDate = void 0;
+// Hijri year remainders for determining Kabisa years
+const KABISA_YEAR_REMAINDERS = [2, 5, 8, 10, 13, 16, 19, 21, 24, 27, 29];
+// number of days in a Hijri year per month
+const DAYS_IN_YEAR = [30, 59, 89, 118, 148, 177, 207, 236, 266, 295, 325];
+// number of days in 30-years per Hijri year
+const DAYS_IN_30_YEARS = [
+    354, 708, 1063, 1417, 1771, 2126, 2480, 2834, 3189, 3543, 3898, 4252, 4606, 4961, 5315, 5669, 6024, 6378, 6732,
+    7087, 7441, 7796, 8150, 8504, 8859, 9213, 9567, 9922, 10276, 10631,
+];
+const MONTH_NAMES = {
+    long: {
+        en: [
+            "Moharram al-Haraam",
+            "Safar al-Muzaffar",
+            "Rabi al-Awwal",
+            "Rabi al-Aakhar",
+            "Jumada al-Ula",
+            "Jumada al-Ukhra",
+            "Rajab al-Asab",
+            "Shabaan al-Karim",
+            "Ramadaan al-Moazzam",
+            "Shawwal al-Mukarram",
+            "Zilqadah al-Haraam",
+            "Zilhaj al-Haraam",
+        ],
+    },
+    short: {
+        en: [
+            "Moharram",
+            "Safar",
+            "Rabi I",
+            "Rabi II",
+            "Jumada I",
+            "Jumada II",
+            "Rajab",
+            "Shabaan",
+            "Ramadaan",
+            "Shawwal",
+            "Zilqadah",
+            "Zilhaj",
+        ],
+    },
+};
+class HijriDate {
+    constructor(year, month, day) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
+    }
+    getYear() {
+        return this.year;
+    }
+    getMonth() {
+        return this.month;
+    }
+    getDate() {
+        return this.day;
+    }
+    static getMonthName(month) {
+        return MONTH_NAMES.long.en[month];
+    }
+    getShortMonthName(month) {
+        return MONTH_NAMES.short.en[month];
+    }
+    // is the specified Gregorian Date object a Julian date?
+    static isJulian(date) {
+        if (date.getFullYear() < 1582) {
+            return true;
+        }
+        else if (date.getFullYear() === 1582) {
+            if (date.getMonth() < 9) {
+                return true;
+            }
+            else if (date.getMonth() === 9) {
+                if (date.getDate() < 5) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // return Astronomical Julian Date corresponding to the specified Gregorian Date object
+    static gregorianToAJD(date) {
+        var a, b, year = date.getFullYear(), month = date.getMonth() + 1, day = date.getDate() +
+            date.getHours() / 24 +
+            date.getMinutes() / 1440 +
+            date.getSeconds() / 86400 +
+            date.getMilliseconds() / 86400000;
+        if (month < 3) {
+            year--;
+            month += 12;
+        }
+        if (HijriDate.isJulian(date)) {
+            b = 0;
+        }
+        else {
+            a = Math.floor(year / 100);
+            b = 2 - a + Math.floor(a / 4);
+        }
+        return Math.floor(365.25 * (year + 4716)) + Math.floor(30.6001 * (month + 1)) + day + b - 1524.5;
+    }
+    // return Gregorian Date object corresponding to the specified Astronomical Julian Date
+    ajdToGregorian(ajd) {
+        var a, b, c, d, e, f, z, alpha, year, month, day, hrs, min, sec, msc;
+        z = Math.floor(ajd + 0.5);
+        f = ajd + 0.5 - z;
+        if (z < 2299161) {
+            a = z;
+        }
+        else {
+            alpha = Math.floor((z - 1867216.25) / 36524.25);
+            a = z + 1 + alpha - Math.floor(0.25 * alpha);
+        }
+        b = a + 1524;
+        c = Math.floor((b - 122.1) / 365.25);
+        d = Math.floor(365.25 * c);
+        e = Math.floor((b - d) / 30.6001);
+        day = b - d - Math.floor(30.6001 * e) + f;
+        hrs = (day - Math.floor(day)) * 24;
+        min = (hrs - Math.floor(hrs)) * 60;
+        sec = (min - Math.floor(min)) * 60;
+        msc = (sec - Math.floor(sec)) * 1000;
+        month = e < 14 ? e - 2 : e - 14;
+        year = month < 2 ? c - 4715 : c - 4716;
+        return new Date(year, month, day, hrs, min, sec, msc);
+    }
+    // is the specified Hijri year a Kabisa year?
+    static isKabisa(year) {
+        for (var i in KABISA_YEAR_REMAINDERS) {
+            if (year % 30 === KABISA_YEAR_REMAINDERS[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // return number of days in the specified Hijri year and month
+    static daysInMonth(year, month) {
+        return (month === 11 && HijriDate.isKabisa(year)) || month % 2 === 0 ? 30 : 29;
+    }
+    // return day of Hijri year corresponding to this Hijri Date object
+    dayOfYear() {
+        return this.month === 0 ? this.day : DAYS_IN_YEAR[this.month - 1] + this.day;
+    }
+    // return Hijri Date object corresponding to specified Astronomical Julian Date
+    static fromAJD(ajd) {
+        var year, month, date, i = 0, left = Math.floor(ajd - 1948083.5), y30 = Math.floor(left / 10631.0);
+        left -= y30 * 10631;
+        while (left > DAYS_IN_30_YEARS[i]) {
+            i += 1;
+        }
+        year = Math.round(y30 * 30.0 + i);
+        if (i > 0) {
+            left -= DAYS_IN_30_YEARS[i - 1];
+        }
+        i = 0;
+        while (left > DAYS_IN_YEAR[i]) {
+            i += 1;
+        }
+        month = Math.round(i);
+        date = i > 0 ? Math.round(left - DAYS_IN_YEAR[i - 1]) : Math.round(left);
+        return new HijriDate(year, month, date);
+    }
+    // return Astronomical Julian Date corresponding to this Hijri Date object
+    toAJD() {
+        var y30 = Math.floor(this.year / 30.0), ajd = 1948083.5 + y30 * 10631 + this.dayOfYear();
+        if (this.year % 30 !== 0) {
+            ajd += DAYS_IN_30_YEARS[this.year - y30 * 30 - 1];
+        }
+        return ajd;
+    }
+    // return Hijri Date object corresponding to the specified Gregorian date object
+    static fromGregorian(date) {
+        return HijriDate.fromAJD(HijriDate.gregorianToAJD(date));
+    }
+    // return Gregorian date object corresponding to this Hijri Date object
+    toGregorian() {
+        return this.ajdToGregorian(this.toAJD());
+    }
+}
+exports.HijriDate = HijriDate;

package/dist/hijri-calendar/libs/classSet.d.ts

@@ -0,0 +1 @@
+export function classSet(classNames: any): string;

package/dist/hijri-calendar/libs/classSet.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classSet = void 0;
+const classSet = classNames => {
+    var names = "";
+    if (typeof classNames == "object") {
+        for (var name in classNames) {
+            if (!classNames.hasOwnProperty(name) || !classNames[name]) {
+                continue;
+            }
+            names += name + " ";
+        }
+    }
+    else {
+        for (var i = 0; i < arguments.length; i++) {
+            // We should technically exclude 0 too, but for the sake of backward
+            // compat we'll keep it (for now)
+            if (arguments[i] == null) {
+                continue;
+            }
+            names += arguments[i] + " ";
+        }
+    }
+    return names.trim();
+};
+exports.classSet = classSet;

package/dist/hijri-calendar/libs/date.d.ts

@@ -0,0 +1,5 @@
+export declare class DateUtil {
+    static monthNames: string[];
+    static getMonthName(month: any): string;
+    static getShortMonthName(month: any): string;
+}

package/dist/hijri-calendar/libs/date.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateUtil = void 0;
+class DateUtil {
+    static getMonthName(month) {
+        return DateUtil.monthNames[month];
+    }
+    static getShortMonthName(month) {
+        return DateUtil.getMonthName(month).substr(0, 3);
+    }
+}
+exports.DateUtil = DateUtil;
+DateUtil.monthNames = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+];

package/dist/hijri-calendar/utils.d.ts

@@ -0,0 +1,10 @@
+import { Miqaat, MiqaatMonth } from "./HijriCalender.interface";
+import { Day } from "./libs/HijriCalendar";
+export declare const useDayMiqaats: (miqaats: MiqaatMonth[], day: Day) => Miqaat[];
+export declare const getHijriDate: (day: Day) => string;
+export declare const getGregorianDate: (day: Day) => string;
+/**
+ * Returns a function that will call the given handler and prevent the default event behavior.
+ * @param handler: The handler to call.
+ */
+export declare const preventDefault: (handler?: (event: any) => void) => (event: any) => void;

package/dist/hijri-calendar/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preventDefault = exports.getGregorianDate = exports.getHijriDate = exports.useDayMiqaats = void 0;
+const HijriDate_1 = require("./libs/HijriDate");
+const date_1 = require("./libs/date");
+const useDayMiqaats = (miqaats, day) => {
+    const { hijri } = day;
+    return miqaats
+        .filter(({ date, month }) => date == hijri.date && month == hijri.month)
+        .map(({ miqaats }) => miqaats)
+        .flat()
+        .filter(miqaat => !(miqaat.year && miqaat.year > hijri.year));
+};
+exports.useDayMiqaats = useDayMiqaats;
+const getHijriDate = (day) => {
+    if (day && day.hijri) {
+        const { hijri: { date, month, year }, } = day;
+        return `${date.toString()} ${HijriDate_1.HijriDate.getMonthName(month)} ${year.toString()} H`;
+    }
+};
+exports.getHijriDate = getHijriDate;
+const getGregorianDate = (day) => {
+    if (day && day.gregorian) {
+        const { gregorian: { date, month, year }, } = day;
+        return `${date.toString()} ${date_1.DateUtil.getMonthName(month)} ${year.toString()} AD`;
+    }
+};
+exports.getGregorianDate = getGregorianDate;
+/**
+ * Returns a function that will call the given handler and prevent the default event behavior.
+ * @param handler: The handler to call.
+ */
+const preventDefault = (handler) => (event) => {
+    event.preventDefault();
+    handler && handler(event);
+};
+exports.preventDefault = preventDefault;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { CalendarFrame as HijriCalendar } from "./hijri-calendar/CalendarFrame";
+export { MiqaatList } from "./hijri-calendar/MiqaatList";
+export { Day } from "./hijri-calendar/libs/HijriCalendar";
+export { MiqaatMonth, Miqaat } from "./hijri-calendar/HijriCalender.interface";
+export { getGregorianDate, getHijriDate } from "./hijri-calendar/utils";

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHijriDate = exports.getGregorianDate = exports.MiqaatList = exports.HijriCalendar = void 0;
+var CalendarFrame_1 = require("./hijri-calendar/CalendarFrame");
+Object.defineProperty(exports, "HijriCalendar", { enumerable: true, get: function () { return CalendarFrame_1.CalendarFrame; } });
+var MiqaatList_1 = require("./hijri-calendar/MiqaatList");
+Object.defineProperty(exports, "MiqaatList", { enumerable: true, get: function () { return MiqaatList_1.MiqaatList; } });
+var utils_1 = require("./hijri-calendar/utils");
+Object.defineProperty(exports, "getGregorianDate", { enumerable: true, get: function () { return utils_1.getGregorianDate; } });
+Object.defineProperty(exports, "getHijriDate", { enumerable: true, get: function () { return utils_1.getHijriDate; } });

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "mumineen-ui-plugins",
+  "version": "1.1.0",
+  "description": "",
+  "main": "dist/index",
+  "scripts": {
+    "build": "rimraf dist/ && tsc",
+    "watch": "rimraf dist/ && tsc --watch",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.tsx\"",
+    "update:version": "npm version minor --no-git-tag-version",
+    "prepub:npm": "npm run format && npm run build && npm run update:version",
+    "publish:npm": "npm run prepub:npm && npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/navedr/mumineen_calendar_react.git"
+  },
+  "files": [
+    "dist/**/*",
+    "src/hijri-calendar/styles.css"
+  ],
+  "keywords": [],
+  "author": "Naved Rangwala",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^20.4.10",
+    "@types/react": "^17.0.0",
+    "prettier": "^2.2.1",
+    "react": "^16.8.2",
+    "react-dom": "^16.8.2",
+    "rimraf": "^3.0.2",
+    "typescript": "*"
+  },
+  "peerDependencies": {
+    "@types/react": ">=16.14.8",
+    "react": ">=16.14.0",
+    "react-dom": ">=16.14.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "bugs": {
+    "url": "https://github.com/navedr/mumineen-ui-plugins/issues"
+  },
+  "homepage": "https://github.com/navedr/mumineen-ui-plugins#readme",
+  "dependencies": {
+    "lazy.js": "^0.5.1"
+  }
+}